home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume14 / jove4.9 / part04 / misc.c < prev    next >
C/C++ Source or Header  |  1988-04-25  |  8KB  |  485 lines
  1. /***************************************************************************
  2.  * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
  3.  * is provided to you without charge, and with no warranty.  You may give  *
  4.  * away copies of JOVE, including sources, provided that this notice is    *
  5.  * included in all the files.                                              *
  6.  ***************************************************************************/
  7.  
  8. #include "jove.h"
  9. #include "ctype.h"
  10. #include <signal.h>
  11. #ifdef ANSICODES
  12. #include "termcap.h"
  13. #endif
  14.  
  15. void
  16. prCTIME()
  17. {
  18.     s_mess(": %f %s", get_time((time_t *) 0, (char *) 0, 0, -1));
  19. }
  20.  
  21. void
  22. ChrToOct()
  23. {
  24.     int    c,
  25.         slow;
  26.  
  27.     c = waitchar(&slow);
  28.     if (slow)
  29.         message(key_strokes);
  30.     ins_str(sprint("\\%03o", c), NO);
  31. }
  32.  
  33. void
  34. StrLength()
  35. {
  36.     static char    inquotes[] = "Where are the quotes?";
  37.     char    *first = StrIndex(-1, linebuf, curchar, '"'),
  38.         *last = StrIndex(1, linebuf, curchar + 1, '"'),
  39.         c;
  40.     int    numchars = 0;
  41.  
  42.     if (first == 0 || last == 0)
  43.         complain(inquotes);
  44.     first += 1;
  45.     while (first < last) {
  46.         c = *first++;
  47.         if (c == '\\') {
  48.             int    num;
  49.  
  50.             if (!isdigit(*first))
  51.                 first += 1;
  52.             else {
  53.                 num = 3;
  54.                 while (num-- && isdigit(*first++) && first < last)
  55.                     ;
  56.             }
  57.         }
  58.         numchars += 1;
  59.     }
  60.     s_mess("%d characters", numchars);
  61. }
  62.  
  63. /* Transpos cur_char with cur_char - 1 */
  64.  
  65. void
  66. TransChar()
  67. {
  68.     char    before;
  69.  
  70.     if (curchar == 0 || (eolp() && curchar == 1))
  71.         complain((char *) 0);    /* BEEP */
  72.     if (eolp())
  73.         b_char(1);
  74.     before = linebuf[curchar - 1];
  75.     del_char(BACKWARD, 1);
  76.     f_char(1);
  77.     insert_c(before, 1);
  78. }
  79.  
  80. /* Switch current line with previous one */
  81.  
  82. void
  83. TransLines()
  84. {
  85.     disk_line    old_prev;
  86.  
  87.     if (firstp(curline))
  88.         return;
  89.     lsave();
  90.     old_prev = curline->l_prev->l_dline;
  91.     curline->l_prev->l_dline = curline->l_dline;
  92.     curline->l_dline = old_prev;
  93.     getDOT();
  94.     if (!lastp(curline))
  95.         line_move(FORWARD, 1, NO);
  96.     modify();
  97. }
  98.  
  99. void
  100. Leave()
  101. {
  102.     longjmp(mainjmp, QUIT);
  103. }
  104.  
  105. /* If argument is specified, kill that many lines down.  Otherwise,
  106.    if we "appear" to be at the end of a line, i.e. everything to the
  107.    right of the cursor is white space, we delete the line separator
  108.    as if we were at the end of the line. */
  109.  
  110. void
  111. KillEOL()
  112. {
  113.     Line    *line2;
  114.     int    char2;
  115.     int    num = arg_value();
  116.  
  117.     if (is_an_arg()) {
  118.         if (num == 0) {    /* Kill to beginning of line */
  119.             line2 = curline;
  120.             char2 = 0;
  121.         } else {
  122.             line2 = next_line(curline, num);
  123.             if ((LineDist(curline, line2) < num) || (line2 == curline))
  124.                 char2 = length(line2);
  125.             else
  126.                 char2 = 0;
  127.         }
  128.     } else if (blnkp(&linebuf[curchar])) {
  129.         line2 = next_line(curline, 1);
  130.         if (line2 == curline)
  131.             char2 = length(curline);
  132.         else
  133.             char2 = 0;
  134.     } else {
  135.         line2 = curline;
  136.         char2 = length(curline);
  137.     }
  138.     reg_kill(line2, char2, 0);
  139. }
  140.  
  141. /* kill to beginning of sentence */
  142.  
  143. void
  144. KillBos()
  145. {
  146.     negate_arg_value();
  147.     KillEos();
  148. }
  149.  
  150. /* Kill to end of sentence */
  151.  
  152. void
  153. KillEos()
  154. {
  155.     Line    *line1;
  156.     int    char1;
  157.  
  158.     line1 = curline;
  159.     char1 = curchar;
  160.     Eos();
  161.     reg_kill(line1, char1, 1);
  162. }
  163.  
  164. void
  165. KillExpr()
  166. {
  167.     Line    *line1;
  168.     int    char1;
  169.  
  170.     line1 = curline;
  171.     char1 = curchar;
  172.     FSexpr();
  173.     reg_kill(line1, char1, 1);
  174. }
  175.  
  176. void
  177. EscPrefix()
  178. {
  179.     HandlePref(pref1map);
  180. }
  181.  
  182. void
  183. CtlxPrefix()
  184. {
  185.     HandlePref(pref2map);
  186. }
  187.  
  188. void
  189. MiscPrefix()
  190. {
  191.     HandlePref(miscmap);
  192. }
  193.  
  194. void
  195. HandlePref(map)
  196. data_obj    **map;
  197. {
  198.     register data_obj    *cp;
  199.     register int    c;
  200.     int    slow;
  201.  
  202.     c = waitchar(&slow);
  203.     if (c == AbortChar) {
  204.         message("[Aborted]");
  205.         rbell();
  206.         return;
  207.     }
  208.  
  209.     if (slow)
  210.         message(key_strokes);
  211.  
  212.     cp = map[c];
  213.     if (cp == 0) {
  214.         s_mess("[%sunbound]", key_strokes);
  215.         rbell();
  216.     } else
  217.         ExecCmd(cp);
  218. }
  219.  
  220. void
  221. Yank()
  222. {
  223.     Line    *line,
  224.         *lp;
  225.     Bufpos    *dot;
  226.  
  227.     if (killbuf[killptr] == 0)
  228.         complain("[Nothing to yank!]");
  229.     lsave();
  230.     this_cmd = YANKCMD;
  231.     line = killbuf[killptr];
  232.     lp = lastline(line);
  233.     dot = DoYank(line, 0, lp, length(lp), curline, curchar, curbuf);
  234.     set_mark();
  235.     SetDot(dot);
  236. }
  237.  
  238. void
  239. WtModBuf()
  240. {
  241.     if (!ModBufs(NO))
  242.         message("[No buffers need saving]");
  243.     else
  244.         put_bufs(is_an_arg());
  245. }
  246.  
  247. void
  248. put_bufs(askp)
  249. {
  250.     register Buffer    *oldb = curbuf,    
  251.             *b;        
  252.  
  253.     for (b = world; b != 0; b = b->b_next) {
  254.         if (!IsModified(b) || b->b_type != B_FILE)
  255.             continue;
  256.         SetBuf(b);    /* Make this current Buffer */
  257.         if (curbuf->b_fname == 0) {
  258.             char    *newname;
  259.  
  260.             newname = ask(NullStr, "Buffer \"%s\" needs a file name; type Return to skip: ", b->b_name);
  261.             if (*newname == 0)
  262.                 continue;
  263.             setfname(b, newname);
  264.         }
  265.         if (askp && (yes_or_no_p("Write %s? ", curbuf->b_fname) == NO))
  266.             continue;
  267.         filemunge(curbuf->b_fname);
  268. #ifndef MAC
  269. #ifndef MSDOS
  270.         chk_mtime(curbuf, curbuf->b_fname, "save");
  271. #endif /* MSDOS */
  272. #endif /* MAC */
  273.         file_write(curbuf->b_fname, 0);
  274.         unmodify();
  275.     }
  276.     SetBuf(oldb);
  277. }
  278.  
  279. void
  280. ToIndent()
  281. {
  282.     register char    *cp,
  283.             c;
  284.  
  285.     for (cp = linebuf; c = *cp; cp++)
  286.         if (c != ' ' && c != '\t')
  287.             break;
  288.     curchar = cp - linebuf;
  289. }
  290.  
  291. /* GoLine -- go to a line, usually wired to goto-line, ESC g or ESC G.
  292.    If no argument is specified it asks for a line number. */
  293. void
  294. GoLine()
  295. {
  296.       Line    *newline;
  297.  
  298. #ifndef ANSICODES
  299.      if (!is_an_arg())
  300.          set_arg_value(ask_int("Line: ",10));
  301. #else /* not ANSICODES */
  302.      if (!is_an_arg() || arg_value() <= 0) {
  303.           if (SP) {
  304.               putpad(SP, 1);    /* Ask for cursor position */
  305.             return;
  306.         }
  307.          set_arg_value(ask_int("Line: ", 10));
  308.       }
  309. #endif /* ANSICODES */
  310.      newline = next_line(curbuf->b_first, arg_value() - 1);
  311.       PushPntp(newline);
  312.       SetLine(newline);
  313. }
  314.  
  315. #ifdef ANSICODES
  316. void
  317. MoveToCursor(line, col)
  318. {
  319.     register struct scrimage *sp = &PhysScreen[line];
  320.  
  321.     while (sp->s_id == 0)
  322.         sp = &PhysScreen[--line];
  323.     if (sp->s_flags & MODELINE)
  324.         complain((char *) 0);
  325.     if (curwind != sp->s_window)
  326.         SetWind(sp->s_window);
  327.     SetLine(sp->s_lp);
  328.     curchar = how_far(sp->s_lp, col);
  329. }
  330.  
  331. void
  332. AnsiCodes()
  333. {
  334.     int    c;
  335.     int    num1 = 0;
  336.     int    num2;
  337.     static char *unsupported = "[Unsupported ANSI code received]";
  338.  
  339.     while (isdigit(c = getch()))
  340.         num1 = (num1 * 10) + (c - '0');
  341.  
  342.     switch (c) {
  343.     case ';':
  344.         num2 = 0;
  345.         while (isdigit(c = getch()))
  346.             num2 = (num2 * 10) + (c - '0');
  347.         switch (c) {
  348.         case 'R':
  349.             MoveToCursor(--num1, --num2);
  350.             break;
  351.         case 'H':
  352.             Eow();
  353.             Bol();
  354.             break;
  355.         default:
  356.             complain(unsupported);
  357.         }
  358.         break;
  359.     case 'A':
  360.         PrevLine();
  361.         break;
  362.     case 'B':
  363.         NextLine();
  364.         break;
  365.     case 'C':
  366.         ForChar();
  367.         break;
  368.     case 'D':
  369.         BackChar();
  370.         break;
  371.     case 'H':
  372.         Bow();
  373.         break;
  374.     case 'J':
  375.         if (num1 == 2) {
  376.             ClAndRedraw();
  377.             break;
  378.         }
  379.     case 'z':    /* Sun function keys send <esc>[Nz */
  380.         switch(num1) {
  381.             case 193:    /* L2 */
  382.                 SetMark();
  383.                 break;
  384.             case 194:    /* L3 */
  385.                 PopMark();
  386.                 break;
  387.             case 195:    /* L4 */
  388.                 DelReg();
  389.                 break;
  390.             case 208:    /* R1 */
  391.                 QRepSearch();
  392.                 break;
  393.             case 209:    /* R2 */
  394.                 IncFSearch();
  395.                 break;
  396.             case 210:    /* R3 */
  397.                 WtModBuf();
  398.                 break;
  399.             case 211:    /* R4 */
  400.                 RepSearch();
  401.                 break;
  402.             case 212:    /* R5 */
  403.                 IncRSearch();
  404.                 break;
  405.             case 213:    /* R6 */
  406.                 Leave();
  407.                 break;
  408.             case 214:    /* R7 */
  409.                 BackWord();
  410.                 break;
  411.             case 215:    /* R8 == UpArrow */
  412.                 break;
  413.             case 216:    /* R9 */
  414.                 ForWord();
  415.                 break;
  416.             case 217:    /* R10 == LeftArrow */
  417.                 break;
  418.             case 218:    /* R11 */
  419.                 NextWindow();
  420.                 break;
  421.             case 219:    /* R12 == RightArrow */
  422.                 break;
  423.             case 220:    /* R13 */
  424.             case 221:    /* R14 == DownArrow */
  425.                 break;
  426.             case 222:    /* R15 */
  427.             case 225:    /* F2 */
  428.             case 226:    /* F3 */
  429.             case 227:    /* F4 */
  430.                 break;
  431.             case 228:    /* F5 */
  432.                 break;
  433.             case 229:    /* F6 */
  434.                 break;
  435.             case 230:    /* F7 */
  436.                 break;
  437.             case 231:    /* F8 */
  438.                 break;
  439.             case 232:    /* F9 */
  440.                 break;
  441.             default:
  442.                 num1 = -1;    /* Hack flags failure */
  443.                 break;
  444.         }
  445.         if (num1 >= 0)
  446.             break;
  447.     case 'P':
  448.         PrevPage();
  449.         break;
  450.  
  451.     case 'Q':
  452.         NextPage();
  453.         break;
  454.  
  455.     case 'R':
  456.         UpScroll();
  457.         break;
  458.  
  459.     case 'S':
  460.         DownScroll();
  461.         break;
  462.     default:
  463.         complain(unsupported);
  464.     }
  465. }
  466. #endif /* ANSICODES */
  467.  
  468. void
  469. NotModified()
  470. {
  471.     unmodify();
  472. }
  473.  
  474. void
  475. SetLMargin()
  476. {
  477.     LMargin = calc_pos(linebuf, curchar);
  478. }
  479.  
  480. void
  481. SetRMargin()
  482. {
  483.     RMargin = calc_pos(linebuf, curchar);
  484. }
  485.