home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume11 / jove.pch / part03 / jove.pch.3
Text File  |  1987-09-15  |  50KB  |  2,356 lines
  1. diff -c ojove/jove.h jove/jove.h
  2. *** ojove/jove.h    Thu Jul 16 09:14:38 1987
  3. --- jove/jove.h    Fri Jul 10 09:25:51 1987
  4. ***************
  5. *** 57,71 ****
  6.   #define FORWARD        1
  7.   #define BACKWARD    -1
  8.   
  9. ! #define CTL(c)        ('c' & 037)
  10. ! #define META(c)        ('c' | 0200)
  11.   #define RUBOUT        '\177'
  12. ! #define LF        CTL(J)
  13. ! #define CR        CTL(M)
  14. ! #define BS        CTL(H)
  15.   #define ESC        '\033'
  16.   
  17. - #define DoTimes(f, n)    exp_p = YES, exp = n, f
  18.   #define HALF(wp)    ((wp->w_height - 1) / 2)
  19.   #define IsModified(b)    (b->b_modified)
  20.   #define SIZE(wp)    (wp->w_height - 1)
  21. --- 57,70 ----
  22.   #define FORWARD        1
  23.   #define BACKWARD    -1
  24.   
  25. ! #define CTL(c)        (c & 037)
  26. ! #define META(c)        (c | 0200)
  27.   #define RUBOUT        '\177'
  28. ! #define LF        CTL('J')
  29. ! #define CR        CTL('M')
  30. ! #define BS        CTL('H')
  31.   #define ESC        '\033'
  32.   
  33.   #define HALF(wp)    ((wp->w_height - 1) / 2)
  34.   #define IsModified(b)    (b->b_modified)
  35.   #define SIZE(wp)    (wp->w_height - 1)
  36. ***************
  37. *** 81,86 ****
  38. --- 80,86 ----
  39.   #define lastp(line)    (line == curbuf->b_last)
  40.   #define makedirty(line)    line->l_dline |= DIRTY
  41.   #define one_windp()    (fwind->w_next == fwind)
  42. + #define CharUpcase(c)    (CaseEquiv[c])
  43.   
  44.   extern int    OkayAbort,    /* okay to abort redisplay */
  45.           BufSize;
  46. ***************
  47. *** 121,126 ****
  48. --- 121,127 ----
  49.   #define SetMajor(x)    ((curbuf->b_major = x), UpdModLine++)
  50.   
  51.   extern char    CharTable[NMAJORS][128];
  52. + extern char    CaseEquiv[128];
  53.   
  54.   /* setjmp/longjmp args for DoKeys() mainjmp */
  55.   #define FIRSTCALL    0
  56. ***************
  57. *** 192,213 ****
  58.       Process    *p_next;
  59.   #ifdef PIPEPROCS
  60.       int    p_toproc,    /* read p_fromproc and write p_toproc */
  61. !         p_portpid,    /* Pid of child (the portsrv) */
  62. !         p_pid;        /* Pid of real child i.e. not portsrv */
  63.   #else
  64. !     int    p_fd,        /* File descriptor of ptyp? opened r/w */
  65.           p_pid;        /* pid of child (the shell) */
  66.   #endif
  67. !     Buffer    *p_buffer;    /* Add output to end of this buffer */
  68.       char    *p_name;    /* ... */
  69.       char    p_state,    /* State */
  70.           p_howdied,    /* Killed? or Exited? */
  71. !         p_reason,    /* If signaled, p_reason is the signal; else
  72.                      it is the the exit code */
  73. !         p_eof;        /* Received EOF, so can be free'd up */
  74. !     Mark    *p_mark;    /* Where output left us. */
  75.       data_obj
  76. !         *p_cmd;        /* Command to call when process dies */
  77.   };
  78.   #endif IPROCS
  79.   
  80. --- 193,213 ----
  81.       Process    *p_next;
  82.   #ifdef PIPEPROCS
  83.       int    p_toproc,    /* read p_fromproc and write p_toproc */
  84. !         p_portpid,    /* pid of child (the portsrv) */
  85. !         p_pid;        /* pid of real child i.e. not portsrv */
  86.   #else
  87. !     int    p_fd,        /* file descriptor of pty? opened r/w */
  88.           p_pid;        /* pid of child (the shell) */
  89.   #endif
  90. !     Buffer    *p_buffer;    /* add output to end of this buffer */
  91.       char    *p_name;    /* ... */
  92.       char    p_state,    /* State */
  93.           p_howdied,    /* Killed? or Exited? */
  94. !         p_reason;    /* If signaled, p_reason is the signal; else
  95.                      it is the the exit code */
  96. !     Mark    *p_mark;    /* where output left us */
  97.       data_obj
  98. !         *p_cmd;        /* command to call when process dies */
  99.   };
  100.   #endif IPROCS
  101.   
  102. ***************
  103. *** 242,249 ****
  104.       Line    *m_line;
  105.       int    m_char;
  106.       Mark    *m_next;    /* list of marks */
  107. ! #define FLOATER    1
  108. !     char    m_floater;    /* FLOATERing mark? */
  109.   };
  110.   
  111.   struct buffer {
  112. --- 242,251 ----
  113.       Line    *m_line;
  114.       int    m_char;
  115.       Mark    *m_next;    /* list of marks */
  116. ! #define M_FIXED        00
  117. ! #define M_FLOATER    01
  118. ! #define M_BIG_DELETE    02
  119. !     char    m_flags;    /* FLOATERing mark? */
  120.   };
  121.   
  122.   struct buffer {
  123. ***************
  124. *** 380,387 ****
  125.       ScrollStep,        /* how should we scroll */
  126.       WtOnMk,            /* write files on compile-it command */
  127.       EndWNewline,        /* end files with a blank line */
  128. !     MarkThresh,        /* moves greater than MarkThresh
  129. !                    will SetMark */
  130.       PDelay,            /* paren flash delay in tenths of a second */
  131.       CIndIncrmt,        /* how much each indentation level pushes
  132.                      over in C mode */
  133. --- 382,388 ----
  134.       ScrollStep,        /* how should we scroll */
  135.       WtOnMk,            /* write files on compile-it command */
  136.       EndWNewline,        /* end files with a blank line */
  137. !     MarkThresh,        /* moves greater than MarkThresh will SetMark */
  138.       PDelay,            /* paren flash delay in tenths of a second */
  139.       CIndIncrmt,        /* how much each indentation level pushes
  140.                      over in C mode */
  141. ***************
  142. *** 408,413 ****
  143. --- 409,415 ----
  144.       SExitChar,        /* type this to stop i-search */
  145.   #endif
  146.       IntChar,        /* ttysets this to generate QUIT */
  147. +     DoEVexpand,        /* treat $foo as environment variable */
  148.       EWSize;            /* size to make the error window */
  149.   
  150.   extern char
  151. ***************
  152. *** 427,435 ****
  153.       Shell[128];        /* shell to use */
  154.   
  155.   extern int
  156. -     exp,        /* argument count */
  157. -     exp_p,        /* argument count is supplied */
  158. - 
  159.       TOabort,    /* flag set by Typeout() */
  160.       io,        /* file descriptor for reading and writing files */
  161.       errormsg,    /* last message was an error message
  162. --- 429,434 ----
  163. ***************
  164. *** 539,544 ****
  165. --- 538,546 ----
  166.       *tgoto(),
  167.       *pr_name(),
  168.       *sprint(),
  169. + #ifdef IPROCS
  170. +     *pstate(),
  171. + #endif
  172.       *StrIndex();
  173.   
  174.   extern Bufpos
  175. diff -c ojove/keymaps.txt jove/keymaps.txt
  176. *** ojove/keymaps.txt    Thu Jul 16 09:14:39 1987
  177. --- jove/keymaps.txt    Thu Jun 11 15:43:50 1987
  178. ***************
  179. *** 34,40 ****
  180.       "search-reverse",        /* ^R */
  181.       "search-forward",        /* ^S */
  182.       "transpose-characters",        /* ^T */
  183. !     "quadruple-numeric-argument",    /* ^U */
  184.       "next-page",            /* ^V */
  185.       "kill-region",            /* ^W */
  186.       "prefix-2",            /* ^X */
  187. --- 34,40 ----
  188.       "search-reverse",        /* ^R */
  189.       "search-forward",        /* ^S */
  190.       "transpose-characters",        /* ^T */
  191. !     "gather-numeric-argument",    /* ^U */
  192.       "next-page",            /* ^V */
  193.       "kill-region",            /* ^W */
  194.       "prefix-2",            /* ^X */
  195. diff -c ojove/macros.c jove/macros.c
  196. *** ojove/macros.c    Thu Jul 16 09:14:41 1987
  197. --- jove/macros.c    Fri Jun 19 16:01:00 1987
  198. ***************
  199. *** 8,14 ****
  200.   #include "jove.h"
  201.   
  202.   struct macro    *macros = 0;        /* Macros */
  203. - data_obj    *LastCmd;
  204.   
  205.   private
  206.   add_mac(new)
  207. --- 8,13 ----
  208. ***************
  209. *** 84,90 ****
  210.           complain("[Too many macros at once!]");
  211.       macstack[stackp] = mac;
  212.       mac->m_offset = 0;
  213. !     mac->m_ntimes = exp;
  214.       mac->m_flags |= EXECUTE;
  215.   }
  216.   
  217. --- 83,89 ----
  218.           complain("[Too many macros at once!]");
  219.       macstack[stackp] = mac;
  220.       mac->m_offset = 0;
  221. !     mac->m_ntimes = arg_value();
  222.       mac->m_flags |= EXECUTE;
  223.   }
  224.   
  225. ***************
  226. *** 362,368 ****
  227.           if (!InJoverc) {
  228.               TOstart("Warning", TRUE);
  229.               Typeout("Warning: your macros file is in the old format.");
  230. !             Typeout("Do you want me to convert \"%s\" to the new", pr_name(file));
  231.               Typeout("format?");
  232.               f_mess(msg);
  233.               TOstop();
  234. --- 361,367 ----
  235.           if (!InJoverc) {
  236.               TOstart("Warning", TRUE);
  237.               Typeout("Warning: your macros file is in the old format.");
  238. !             Typeout("Do you want me to convert \"%s\" to the new", pr_name(file, YES));
  239.               Typeout("format?");
  240.               f_mess(msg);
  241.               TOstop();
  242. diff -c ojove/marks.c jove/marks.c
  243. *** ojove/marks.c    Thu Jul 16 09:14:42 1987
  244. --- jove/marks.c    Wed Jun 24 13:22:48 1987
  245. ***************
  246. *** 17,23 ****
  247.   
  248.       MarkSet(newmark, line, column);
  249.       newmark->m_next = curbuf->b_marks;
  250. !     newmark->m_floater = type;
  251.       curbuf->b_marks = newmark;
  252.       return newmark;
  253.   }
  254. --- 17,23 ----
  255.   
  256.       MarkSet(newmark, line, column);
  257.       newmark->m_next = curbuf->b_marks;
  258. !     newmark->m_flags = type;
  259.       curbuf->b_marks = newmark;
  260.       return newmark;
  261.   }
  262. ***************
  263. *** 70,76 ****
  264.                   pmark = NMARKS - 1;
  265.           } while (curbuf->b_markring[pmark] != 0);
  266.   
  267. !         curbuf->b_markring[pmark] = MakeMark(curline, curchar, MarksShouldFloat);
  268.           ToMark(curmark);
  269.           DelMark(curmark);
  270.           curmark = 0;
  271. --- 70,76 ----
  272.                   pmark = NMARKS - 1;
  273.           } while (curbuf->b_markring[pmark] != 0);
  274.   
  275. !         curbuf->b_markring[pmark] = MakeMark(curline, curchar, MarksShouldFloat ? M_FLOATER : M_FIXED);
  276.           ToMark(curmark);
  277.           DelMark(curmark);
  278.           curmark = 0;
  279. ***************
  280. *** 85,102 ****
  281.   
  282.   SetMark()
  283.   {
  284. !     if (exp_p)
  285.           PopMark();
  286.       else
  287. !         DoSetMark(curline, curchar);
  288.   }
  289.   
  290. ! DoSetMark(l, c)
  291.   Line    *l;
  292.   {
  293.       curbuf->b_themark = (curbuf->b_themark + 1) % NMARKS;
  294.       if (curmark == 0)
  295. !         curmark = MakeMark(l, c, MarksShouldFloat);
  296.       else
  297.           MarkSet(curmark, l, c);
  298.       s_mess("[Point pushed]");
  299. --- 85,107 ----
  300.   
  301.   SetMark()
  302.   {
  303. !     if (is_an_arg())
  304.           PopMark();
  305.       else
  306. !         set_mark();
  307.   }
  308.   
  309. ! set_mark()
  310. ! {
  311. !     do_set_mark(curline, curchar);
  312. ! }
  313. ! 
  314. ! do_set_mark(l, c)
  315.   Line    *l;
  316.   {
  317.       curbuf->b_themark = (curbuf->b_themark + 1) % NMARKS;
  318.       if (curmark == 0)
  319. !         curmark = MakeMark(l, c, MarksShouldFloat ? M_FLOATER : M_FIXED);
  320.       else
  321.           MarkSet(curmark, l, c);
  322.       s_mess("[Point pushed]");
  323. ***************
  324. *** 151,167 ****
  325.       if (curbuf->b_marks == 0)
  326.           return;
  327.       while (lp != line2->l_next) {
  328. !         for (m = curbuf->b_marks; m != 0; m = m->m_next) {
  329. ! /*            if (!m->m_floater)
  330. !                 continue; */
  331.               if (m->m_line == lp)
  332.                   m->m_char |= (1 << 15);
  333. -         }
  334.           lp = lp->l_next;
  335.       }
  336.       for (m = curbuf->b_marks; m; m = m->m_next) {
  337. - /*        if (!m->m_floater)
  338. -             continue; */
  339.           if ((m->m_char & (1 << 15)) == 0)
  340.               continue;    /* Not effected */
  341.           m->m_char &= ~(1 << 15);
  342. --- 156,167 ----
  343.       if (curbuf->b_marks == 0)
  344.           return;
  345.       while (lp != line2->l_next) {
  346. !         for (m = curbuf->b_marks; m != 0; m = m->m_next)
  347.               if (m->m_line == lp)
  348.                   m->m_char |= (1 << 15);
  349.           lp = lp->l_next;
  350.       }
  351.       for (m = curbuf->b_marks; m; m = m->m_next) {
  352.           if ((m->m_char & (1 << 15)) == 0)
  353.               continue;    /* Not effected */
  354.           m->m_char &= ~(1 << 15);
  355. ***************
  356. *** 178,187 ****
  357. --- 178,189 ----
  358.                   m->m_char = char1 + (m->m_char - char2);
  359.               else
  360.                   m->m_char = char1;
  361. +             m->m_flags |= M_BIG_DELETE;
  362.               m->m_line = line1;
  363.           } else {
  364.               m->m_char = char1;
  365.               m->m_line = line1;
  366. +             m->m_flags |= M_BIG_DELETE;
  367.           }
  368.       }
  369.   }
  370. ***************
  371. *** 196,202 ****
  372.       register Mark    *m;
  373.   
  374.       for (m = curbuf->b_marks; m != 0; m = m->m_next) {
  375. !         if (!m->m_floater)
  376.               continue;
  377.           if (m->m_line == line1) {
  378.               if (m->m_char > char1) {
  379. --- 198,204 ----
  380.       register Mark    *m;
  381.   
  382.       for (m = curbuf->b_marks; m != 0; m = m->m_next) {
  383. !         if ((m->m_flags & M_FLOATER) == 0)
  384.               continue;
  385.           if (m->m_line == line1) {
  386.               if (m->m_char > char1) {
  387. diff -c ojove/misc.c jove/misc.c
  388. *** ojove/misc.c    Thu Jul 16 09:14:43 1987
  389. --- jove/misc.c    Fri Jul 10 09:25:50 1987
  390. ***************
  391. *** 12,161 ****
  392.   #include "termcap.h"
  393.   #endif
  394.   
  395. - Digit()
  396. - {
  397. -     GetExp(LastKeyStruck);
  398. - }
  399. - 
  400. - Digit0()
  401. - {
  402. -     GetExp('0');
  403. - }
  404. - 
  405. - Digit1()
  406. - {
  407. -     GetExp('1');
  408. - }
  409. - 
  410. - Digit2()
  411. - {
  412. -     GetExp('2');
  413. - }
  414. - 
  415. - Digit3()
  416. - {
  417. -     GetExp('3');
  418. - }
  419. - 
  420. - Digit4()
  421. - {
  422. -     GetExp('4');
  423. - }
  424. - 
  425. - Digit5()
  426. - {
  427. -     GetExp('5');
  428. - }
  429. - 
  430. - Digit6()
  431. - {
  432. -     GetExp('6');
  433. - }
  434. - 
  435. - Digit7()
  436. - {
  437. -     GetExp('7');
  438. - }
  439. - 
  440. - Digit8()
  441. - {
  442. -     GetExp('8');
  443. - }
  444. - 
  445. - Digit9()
  446. - {
  447. -     GetExp('9');
  448. - }
  449. - 
  450.   prCTIME()
  451.   {
  452.       s_mess(": %f %s", get_time((time_t *) 0, (char *) 0, 0, -1));
  453.   }
  454.   
  455. - extern int    alarmed;
  456. - 
  457. - FourTime()
  458. - {
  459. -     int    oldc = LastKeyStruck,
  460. -         newc;
  461. -     int    nexp;
  462. - 
  463. -     alarmed = 0;
  464. -     exp_p = YES;
  465. -     this_cmd = ARG_CMD;
  466. -     do {
  467. -         if ((nexp = exp * 4) != 0)
  468. -             exp = nexp;
  469. -         if (!alarmed)
  470. -             newc = waitchar();
  471. -         else
  472. -             newc = getch();
  473. -         if (alarmed)
  474. -             message(key_strokes);
  475. -     } while (newc == oldc);
  476. -     Ungetc(newc);
  477. - }
  478. - 
  479. - int    exp_p,
  480. -     exp;
  481. - 
  482. - GetExp(c)
  483. - {
  484. -     int    sign = 0;
  485. -     static int    digited;
  486. - 
  487. -     if (!isdigit(c) && c != '-')
  488. -         complain((char *) 0);
  489. -     if (exp_p == NO) {    /* if we just got here */
  490. -         exp = 0;    /* start over */
  491. -         digited = NO;
  492. -     } else if (exp_p == YES_NODIGIT) {
  493. -         sign = (exp < 0) ? -1 : 1;
  494. -         exp = 0;
  495. -     }
  496. - 
  497. -     if (!sign)
  498. -         sign = (exp < 0) ? -1 : 1;
  499. -     if (sign == -1)
  500. -         exp = -exp;
  501. -     if (c == '-') {
  502. -         sign = -sign;
  503. -         goto goread;
  504. -     }
  505. -     for (;;) {
  506. -         if (alarmed)
  507. -             message(key_strokes);
  508. -         if (isdigit(c)) {
  509. -             exp = (exp * 10) + (c - '0');
  510. -             digited++;
  511. -         } else {
  512. -             if (digited)
  513. -                 exp_p = YES;
  514. -             else {
  515. -                 exp = 1;
  516. -                 if (exp_p == NO)
  517. -                     exp_p = YES_NODIGIT;
  518. -             }
  519. -             exp *= sign;
  520. -             this_cmd = ARG_CMD;
  521. -             Ungetc(c);
  522. -             return;
  523. -         }
  524. - goread:        if (!alarmed)
  525. -             c = waitchar();
  526. -         else {
  527. -             add_mess(NullStr);
  528. -             c = getch();
  529. -         }
  530. -     }
  531. - }
  532. - 
  533.   ChrToOct()
  534.   {
  535. !     int    c;
  536.   
  537. !     c = waitchar();
  538. !     if (alarmed)
  539.           message(key_strokes);
  540.       ins_str(sprint("\\%03o", c), NO);
  541.   }
  542. --- 12,29 ----
  543.   #include "termcap.h"
  544.   #endif
  545.   
  546.   prCTIME()
  547.   {
  548.       s_mess(": %f %s", get_time((time_t *) 0, (char *) 0, 0, -1));
  549.   }
  550.   
  551.   ChrToOct()
  552.   {
  553. !     int    c,
  554. !         slow;
  555.   
  556. !     c = waitchar(&slow);
  557. !     if (slow)
  558.           message(key_strokes);
  559.       ins_str(sprint("\\%03o", c), NO);
  560.   }
  561. ***************
  562. *** 197,209 ****
  563.   
  564.       if (curchar == 0 || (eolp() && curchar == 1))
  565.           complain((char *) 0);    /* BEEP */
  566. -     exp = 1;
  567.       if (eolp())
  568. !         BackChar();
  569.       before = linebuf[curchar - 1];
  570. !     DelPChar();
  571. !     ForChar();
  572. !     Insert(before);
  573.   }
  574.   
  575.   /* Switch current line with previous one */
  576. --- 65,76 ----
  577.   
  578.       if (curchar == 0 || (eolp() && curchar == 1))
  579.           complain((char *) 0);    /* BEEP */
  580.       if (eolp())
  581. !         b_char(1);
  582.       before = linebuf[curchar - 1];
  583. !     del_char(BACKWARD, 1);
  584. !     f_char(1);
  585. !     insert_c(before, 1);
  586.   }
  587.   
  588.   /* Switch current line with previous one */
  589. ***************
  590. *** 214,220 ****
  591.   
  592.       if (firstp(curline))
  593.           return;
  594. -     exp = 1;
  595.       lsave();
  596.       old_prev = curline->l_prev->l_dline;
  597.       curline->l_prev->l_dline = curline->l_dline;
  598. --- 81,86 ----
  599. ***************
  600. *** 221,227 ****
  601.       curline->l_dline = old_prev;
  602.       getDOT();
  603.       if (!lastp(curline))
  604. !         line_move(FORWARD, NO);
  605.       modify();
  606.   }
  607.   
  608. --- 87,93 ----
  609.       curline->l_dline = old_prev;
  610.       getDOT();
  611.       if (!lastp(curline))
  612. !         line_move(FORWARD, 1, NO);
  613.       modify();
  614.   }
  615.   
  616. ***************
  617. *** 239,252 ****
  618.   {
  619.       Line    *line2;
  620.       int    char2;
  621.   
  622. !     if (exp_p) {
  623. !         if (exp == 0) {    /* Kill to beginning of line */
  624.               line2 = curline;
  625.               char2 = 0;
  626.           } else {
  627. !             line2 = next_line(curline, exp);
  628. !             if ((LineDist(curline, line2) < exp) || (line2 == curline))
  629.                   char2 = length(line2);
  630.               else
  631.                   char2 = 0;
  632. --- 105,119 ----
  633.   {
  634.       Line    *line2;
  635.       int    char2;
  636. +     int    num = arg_value();
  637.   
  638. !     if (is_an_arg()) {
  639. !         if (num == 0) {    /* Kill to beginning of line */
  640.               line2 = curline;
  641.               char2 = 0;
  642.           } else {
  643. !             line2 = next_line(curline, num);
  644. !             if ((LineDist(curline, line2) < num) || (line2 == curline))
  645.                   char2 = length(line2);
  646.               else
  647.                   char2 = 0;
  648. ***************
  649. *** 264,274 ****
  650.       reg_kill(line2, char2, 0);
  651.   }
  652.   
  653. ! /* Kill to beginning of sentence */
  654.   
  655.   KillBos()
  656.   {
  657. !     exp = -exp;
  658.       KillEos();
  659.   }
  660.   
  661. --- 131,141 ----
  662.       reg_kill(line2, char2, 0);
  663.   }
  664.   
  665. ! /* kill to beginning of sentence */
  666.   
  667.   KillBos()
  668.   {
  669. !     negate_arg_value();
  670.       KillEos();
  671.   }
  672.   
  673. ***************
  674. *** 316,330 ****
  675.   {
  676.       register data_obj    *cp;
  677.       register int    c;
  678.   
  679. !     c = waitchar();
  680. !     if (c == CTL(G)) {
  681.           message("[Aborted]");
  682.           rbell();
  683.           return;
  684.       }
  685.   
  686. !     if (alarmed)
  687.           message(key_strokes);
  688.   
  689.       cp = map[c];
  690. --- 183,198 ----
  691.   {
  692.       register data_obj    *cp;
  693.       register int    c;
  694. +     int    slow;
  695.   
  696. !     c = waitchar(&slow);
  697. !     if (c == CTL('G')) {
  698.           message("[Aborted]");
  699.           rbell();
  700.           return;
  701.       }
  702.   
  703. !     if (slow)
  704.           message(key_strokes);
  705.   
  706.       cp = map[c];
  707. ***************
  708. *** 348,354 ****
  709.       line = killbuf[killptr];
  710.       lp = lastline(line);
  711.       dot = DoYank(line, 0, lp, length(lp), curline, curchar, curbuf);
  712. !     SetMark();
  713.       SetDot(dot);
  714.   }
  715.   
  716. --- 216,222 ----
  717.       line = killbuf[killptr];
  718.       lp = lastline(line);
  719.       dot = DoYank(line, 0, lp, length(lp), curline, curchar, curbuf);
  720. !     set_mark();
  721.       SetDot(dot);
  722.   }
  723.   
  724. ***************
  725. *** 357,363 ****
  726.       if (!ModBufs(NO))
  727.           message("[No buffers need saving]");
  728.       else
  729. !         put_bufs(exp_p);
  730.   }
  731.   
  732.   put_bufs(askp)
  733. --- 225,231 ----
  734.       if (!ModBufs(NO))
  735.           message("[No buffers need saving]");
  736.       else
  737. !         put_bufs(is_an_arg());
  738.   }
  739.   
  740.   put_bufs(askp)
  741. ***************
  742. *** 403,418 ****
  743.       Line    *newline;
  744.   
  745.   #ifndef ANSICODES
  746. !     if (exp_p == NO)
  747.           return;
  748.   #else
  749. !     if (exp_p == NO || exp <= 0) {
  750.           if (SP)
  751.               putpad(SP, 1);    /* Ask for cursor position */
  752.           return;
  753.       }
  754.   #endif
  755. !     newline = next_line(curbuf->b_first, exp - 1);
  756.       PushPntp(newline);
  757.       SetLine(newline);
  758.   }
  759. --- 271,286 ----
  760.       Line    *newline;
  761.   
  762.   #ifndef ANSICODES
  763. !     if (!is_an_arg())
  764.           return;
  765.   #else
  766. !     if (!is_an_arg() || arg_value() <= 0) {
  767.           if (SP)
  768.               putpad(SP, 1);    /* Ask for cursor position */
  769.           return;
  770.       }
  771.   #endif
  772. !     newline = next_line(curbuf->b_first, arg_value() - 1);
  773.       PushPntp(newline);
  774.       SetLine(newline);
  775.   }
  776. ***************
  777. *** 440,452 ****
  778.       static char *unsupported = "[Unsupported ANSI code received]";
  779.   
  780.       while (isdigit(c = getch()))
  781. !         num1 = (num1*10) + (c - '0');
  782.   
  783.       switch (c) {
  784.       case ';':
  785.           num2 = 0;
  786.           while (isdigit(c = getch()))
  787. !             num2 = (num2*10) + (c - '0');
  788.           switch (c) {
  789.           case 'R':
  790.               MoveToCursor(--num1, --num2);
  791. --- 308,320 ----
  792.       static char *unsupported = "[Unsupported ANSI code received]";
  793.   
  794.       while (isdigit(c = getch()))
  795. !         num1 = (num1 * 10) + (c - '0');
  796.   
  797.       switch (c) {
  798.       case ';':
  799.           num2 = 0;
  800.           while (isdigit(c = getch()))
  801. !             num2 = (num2 * 10) + (c - '0');
  802.           switch (c) {
  803.           case 'R':
  804.               MoveToCursor(--num1, --num2);
  805. ***************
  806. *** 459,468 ****
  807.           }
  808.           break;
  809.       case 'A':
  810. !         line_move(BACKWARD, YES);
  811.           break;
  812.       case 'B':
  813. !         line_move(FORWARD, YES);
  814.           break;
  815.       case 'C':
  816.           ForChar();
  817. --- 327,336 ----
  818.           }
  819.           break;
  820.       case 'A':
  821. !         PrevLine();
  822.           break;
  823.       case 'B':
  824. !         NextLine();
  825.           break;
  826.       case 'C':
  827.           ForChar();
  828. ***************
  829. *** 479,484 ****
  830. --- 347,369 ----
  831.               break;
  832.           }
  833.           /* FALL THROUGH */
  834. + 
  835. +     case 'P':
  836. +         PrevPage();
  837. +         break;
  838. + 
  839. +     case 'Q':
  840. +         NextPage();
  841. +         break;
  842. + 
  843. +     case 'R':
  844. +         UpScroll();
  845. +         break;
  846. + 
  847. +     case 'S':
  848. +         DownScroll();
  849. +         break;
  850. + 
  851.       default:
  852.           complain(unsupported);
  853.       }
  854. diff -c ojove/move.c jove/move.c
  855. *** ojove/move.c    Thu Jul 16 09:14:44 1987
  856. --- jove/move.c    Fri Jun 12 11:53:33 1987
  857. ***************
  858. *** 10,26 ****
  859.   
  860.   static int    line_pos;
  861.   
  862. ! ForChar()
  863.   {
  864. -     register int    num = exp;
  865.   
  866. !     if (exp < 0) {
  867. !         exp = -exp;
  868. !         BackChar();
  869.           return;
  870.       }
  871. !     exp = 1;
  872. !     while (--num >= 0) {
  873.           if (eolp()) {            /* Go to the next Line */
  874.               if (curline->l_next == 0)
  875.                   break;
  876. --- 10,24 ----
  877.   
  878.   static int    line_pos;
  879.   
  880. ! f_char(n)
  881. ! register int    n;
  882.   {
  883.   
  884. !     if (n < 0) {
  885. !         b_char(-n);
  886.           return;
  887.       }
  888. !     while (--n >= 0) {
  889.           if (eolp()) {            /* Go to the next Line */
  890.               if (curline->l_next == 0)
  891.                   break;
  892. ***************
  893. *** 30,46 ****
  894.       }
  895.   }
  896.   
  897. ! BackChar()
  898.   {
  899. -     register int    num = exp;
  900.   
  901. !     if (exp < 0) {
  902. !         exp = -exp;
  903. !         ForChar();
  904.           return;
  905.       }
  906. !     exp = 1;
  907. !     while (--num >= 0) {
  908.           if (bolp()) {
  909.               if (curline->l_prev == 0)
  910.                   break;
  911. --- 28,42 ----
  912.       }
  913.   }
  914.   
  915. ! b_char(n)
  916. ! register int    n;
  917.   {
  918.   
  919. !     if (n < 0) {
  920. !         f_char(-n);
  921.           return;
  922.       }
  923. !     while (--n >= 0) {
  924.           if (bolp()) {
  925.               if (curline->l_prev == 0)
  926.                   break;
  927. ***************
  928. *** 51,61 ****
  929.       }
  930.   }
  931.   
  932.   NextLine()
  933.   {
  934.       if ((curline == curbuf->b_last) && eolp())
  935.           complain(NullStr);
  936. !     line_move(FORWARD, YES);
  937.   }
  938.   
  939.   PrevLine()
  940. --- 47,67 ----
  941.       }
  942.   }
  943.   
  944. + ForChar()
  945. + {
  946. +     f_char(arg_value());
  947. + }
  948. + 
  949. + BackChar()
  950. + {
  951. +     b_char(arg_value());
  952. + }
  953. + 
  954.   NextLine()
  955.   {
  956.       if ((curline == curbuf->b_last) && eolp())
  957.           complain(NullStr);
  958. !     line_move(FORWARD, arg_value(), YES);
  959.   }
  960.   
  961.   PrevLine()
  962. ***************
  963. *** 62,68 ****
  964.   {
  965.       if ((curline == curbuf->b_first) && bolp())
  966.           complain(NullStr);
  967. !     line_move(BACKWARD, YES);
  968.   }
  969.   
  970.   /* moves to a different line in DIR; LINE_CMD says whether this is
  971. --- 68,74 ----
  972.   {
  973.       if ((curline == curbuf->b_first) && bolp())
  974.           complain(NullStr);
  975. !     line_move(BACKWARD, arg_value(), YES);
  976.   }
  977.   
  978.   /* moves to a different line in DIR; LINE_CMD says whether this is
  979. ***************
  980. *** 69,80 ****
  981.      being called from NextLine() or PrevLine(), in which case it tries
  982.      to line up the column with the column of the current line */
  983.   
  984. ! line_move(dir, line_cmd)
  985.   {
  986.       Line    *(*proc)() = (dir == FORWARD) ? next_line : prev_line;
  987.       Line    *line;
  988.   
  989. !     line = (*proc)(curline, exp);
  990.       if (line == curline) {
  991.           (dir == FORWARD) ? Eol() : Bol();
  992.           return;
  993. --- 75,86 ----
  994.      being called from NextLine() or PrevLine(), in which case it tries
  995.      to line up the column with the column of the current line */
  996.   
  997. ! line_move(dir, n, line_cmd)
  998.   {
  999.       Line    *(*proc)() = (dir == FORWARD) ? next_line : prev_line;
  1000.       Line    *line;
  1001.   
  1002. !     line = (*proc)(curline, n);
  1003.       if (line == curline) {
  1004.           (dir == FORWARD) ? Eol() : Bol();
  1005.           return;
  1006. ***************
  1007. *** 142,147 ****
  1008. --- 148,154 ----
  1009.      with all the kludgery involved with paragraphs, and moving backwards
  1010.      is particularly yucky. */
  1011.   
  1012. + private
  1013.   to_sent(dir)
  1014.   {
  1015.       Bufpos    *new,
  1016. ***************
  1017. *** 152,158 ****
  1018.   
  1019.       new = dosearch("^[ \t]*$\\|[?.!]", dir, 1);
  1020.       if (new == 0) {
  1021. !         (dir < 0) ? ToFirst() : ToLast();
  1022.           return;
  1023.       }
  1024.       SetDot(new);
  1025. --- 159,165 ----
  1026.   
  1027.       new = dosearch("^[ \t]*$\\|[?.!]", dir, 1);
  1028.       if (new == 0) {
  1029. !         (dir == BACKWARD) ? ToFirst() : ToLast();
  1030.           return;
  1031.       }
  1032.       SetDot(new);
  1033. ***************
  1034. *** 168,174 ****
  1035.       }
  1036.       if (blnkp(linebuf)) {
  1037.           Bol();
  1038. !         BackChar();
  1039.           if (old.p_line == curline && old.p_char >= curchar) {
  1040.               to_word(1);    /* Oh brother this is painful */
  1041.               to_sent(1);
  1042. --- 175,181 ----
  1043.       }
  1044.       if (blnkp(linebuf)) {
  1045.           Bol();
  1046. !         b_char(1);
  1047.           if (old.p_line == curline && old.p_char >= curchar) {
  1048.               to_word(1);    /* Oh brother this is painful */
  1049.               to_sent(1);
  1050. ***************
  1051. *** 186,201 ****
  1052.   
  1053.   Bos()
  1054.   {
  1055. !     int    num = exp;
  1056.   
  1057. !     if (exp < 0) {
  1058. !         exp = -exp;
  1059.           Eos();
  1060.           return;
  1061.       }
  1062.   
  1063. -     exp = 1;
  1064. - 
  1065.       while (--num >= 0) {
  1066.           to_sent(-1);
  1067.           if (bobp())
  1068. --- 193,206 ----
  1069.   
  1070.   Bos()
  1071.   {
  1072. !     register int    num = arg_value();
  1073.   
  1074. !     if (num < 0) {
  1075. !         negate_arg_value();
  1076.           Eos();
  1077.           return;
  1078.       }
  1079.   
  1080.       while (--num >= 0) {
  1081.           to_sent(-1);
  1082.           if (bobp())
  1083. ***************
  1084. *** 205,220 ****
  1085.   
  1086.   Eos()
  1087.   {
  1088. !     int    num = exp;
  1089.   
  1090. !     if (exp < 0) {
  1091. !         exp = -exp;
  1092.           Bos();
  1093.           return;
  1094.       }
  1095.   
  1096. -     exp = 1;
  1097. - 
  1098.       while (--num >= 0) {
  1099.           to_sent(1);
  1100.           if (eobp())
  1101. --- 210,223 ----
  1102.   
  1103.   Eos()
  1104.   {
  1105. !     register int    num = arg_value();
  1106.   
  1107. !     if (num < 0) {
  1108. !         negate_arg_value();
  1109.           Bos();
  1110.           return;
  1111.       }
  1112.   
  1113.       while (--num >= 0) {
  1114.           to_sent(1);
  1115.           if (eobp())
  1116. ***************
  1117. *** 222,240 ****
  1118.       }
  1119.   }
  1120.   
  1121. ! ForWord()
  1122.   {
  1123.       register char    c;
  1124. -     register int    num = exp;
  1125.   
  1126. !     if (exp < 0) {
  1127. !         exp = -exp;
  1128. !         BackWord();
  1129.           return;
  1130.       }
  1131. -     exp = 1;
  1132.       while (--num >= 0) {
  1133. !         to_word(1);
  1134.           while ((c = linebuf[curchar]) != 0 && isword(c))
  1135.               curchar++;
  1136.           if (eobp())
  1137. --- 225,241 ----
  1138.       }
  1139.   }
  1140.   
  1141. ! f_word(num)
  1142. ! register int    num;
  1143.   {
  1144.       register char    c;
  1145.   
  1146. !     if (num < 0) {
  1147. !         b_word(-num);
  1148.           return;
  1149.       }
  1150.       while (--num >= 0) {
  1151. !         to_word(FORWARD);
  1152.           while ((c = linebuf[curchar]) != 0 && isword(c))
  1153.               curchar++;
  1154.           if (eobp())
  1155. ***************
  1156. *** 243,261 ****
  1157.       this_cmd = 0;    /* Semi kludge to stop some unfavorable behavior */
  1158.   }
  1159.   
  1160. ! BackWord()
  1161.   {
  1162. -     register int    num = exp;
  1163.       register char    c;
  1164.   
  1165. !     if (exp < 0) {
  1166. !         exp = -exp;
  1167. !         ForWord();
  1168.           return;
  1169.       }
  1170. -     exp = 1;
  1171.       while (--num >= 0) {
  1172. !         to_word(-1);
  1173.           while (!bolp() && (c = linebuf[curchar - 1], isword(c)))
  1174.               --curchar;
  1175.           if (bobp())
  1176. --- 244,260 ----
  1177.       this_cmd = 0;    /* Semi kludge to stop some unfavorable behavior */
  1178.   }
  1179.   
  1180. ! b_word(num)
  1181. ! register int    num;
  1182.   {
  1183.       register char    c;
  1184.   
  1185. !     if (num < 0) {
  1186. !         f_word(-num);
  1187.           return;
  1188.       }
  1189.       while (--num >= 0) {
  1190. !         to_word(BACKWARD);
  1191.           while (!bolp() && (c = linebuf[curchar - 1], isword(c)))
  1192.               --curchar;
  1193.           if (bobp())
  1194. ***************
  1195. *** 263,265 ****
  1196. --- 262,275 ----
  1197.       }
  1198.       this_cmd = 0;
  1199.   }
  1200. + 
  1201. + ForWord()
  1202. + {
  1203. +     f_word(arg_value());
  1204. + }
  1205. + 
  1206. + BackWord()
  1207. + {
  1208. +     b_word(arg_value());
  1209. + }
  1210. + 
  1211. diff -c ojove/paragraph.c jove/paragraph.c
  1212. *** ojove/paragraph.c    Thu Jul 16 09:14:45 1987
  1213. --- jove/paragraph.c    Wed Jun 24 12:43:24 1987
  1214. ***************
  1215. *** 204,210 ****
  1216.       int    this_indent;
  1217.       Bufpos    orig;        /* remember where we were when we started */
  1218.   
  1219. -     exp = 1;
  1220.       DOTsave(&orig);
  1221.   strt:
  1222.       this = curline;
  1223. --- 204,209 ----
  1224. ***************
  1225. *** 218,224 ****
  1226.                   if (firstp(curline))
  1227.                       complain((char *) 0);
  1228.                   else
  1229. !                     line_move(BACKWARD, NO);
  1230.               goto strt;
  1231.           } else {
  1232.               while (i_blank(curline))
  1233. --- 217,223 ----
  1234.                   if (firstp(curline))
  1235.                       complain((char *) 0);
  1236.                   else
  1237. !                     line_move(BACKWARD, 1, NO);
  1238.               goto strt;
  1239.           } else {
  1240.               while (i_blank(curline))
  1241. ***************
  1242. *** 225,231 ****
  1243.                   if (lastp(curline))
  1244.                       complain((char *) 0);
  1245.                   else
  1246. !                     line_move(FORWARD, NO);
  1247.               head = curline;
  1248.               next = curline->l_next;
  1249.               if (!i_bsblank(next))
  1250. --- 224,230 ----
  1251.                   if (lastp(curline))
  1252.                       complain((char *) 0);
  1253.                   else
  1254. !                     line_move(FORWARD, 1, NO);
  1255.               head = curline;
  1256.               next = curline->l_next;
  1257.               if (!i_bsblank(next))
  1258. ***************
  1259. *** 302,308 ****
  1260.   
  1261.   Justify()
  1262.   {
  1263. !     use_lmargin = (exp_p != NO);
  1264.       find_para(BACKWARD);
  1265.       DoJustify(para_head, 0, para_tail, length(para_tail), NO,
  1266.             use_lmargin ? LMargin : body_indent);
  1267. --- 301,307 ----
  1268.   
  1269.   Justify()
  1270.   {
  1271. !     use_lmargin = is_an_arg();
  1272.       find_para(BACKWARD);
  1273.       DoJustify(para_head, 0, para_tail, length(para_tail), NO,
  1274.             use_lmargin ? LMargin : body_indent);
  1275. ***************
  1276. *** 339,345 ****
  1277.       Line    *rl1,
  1278.           *rl2;
  1279.   
  1280. !     use_lmargin = (exp_p != NO);
  1281.       (void) fixorder(&l1, &c1, &l2, &c2);
  1282.       do {
  1283.           DotTo(l1, c1);
  1284. --- 338,344 ----
  1285.       Line    *rl1,
  1286.           *rl2;
  1287.   
  1288. !     use_lmargin = is_an_arg();
  1289.       (void) fixorder(&l1, &c1, &l2, &c2);
  1290.       do {
  1291.           DotTo(l1, c1);
  1292. ***************
  1293. *** 346,352 ****
  1294.           find_para(FORWARD);
  1295.           rl1 = max_line(l1, para_head);
  1296.           rl2 = min_line(l2, para_tail);
  1297. !         tailmark = MakeMark(para_tail, 0, FLOATER);
  1298.           DoJustify(rl1, (rl1 == l1) ? c1 : 0, rl2,
  1299.                 (rl2 == l2) ? c2 : length(rl2),
  1300.                 NO, use_lmargin ? LMargin : body_indent);
  1301. --- 345,351 ----
  1302.           find_para(FORWARD);
  1303.           rl1 = max_line(l1, para_head);
  1304.           rl2 = min_line(l2, para_tail);
  1305. !         tailmark = MakeMark(para_tail, 0, M_FLOATER);
  1306.           DoJustify(rl1, (rl1 == l1) ? c1 : 0, rl2,
  1307.                 (rl2 == l2) ? c2 : length(rl2),
  1308.                 NO, use_lmargin ? LMargin : body_indent);
  1309. ***************
  1310. *** 356,362 ****
  1311.       } while (l1 != 0 && l2 != rl2);
  1312.   }
  1313.   
  1314. ! do_rfill()
  1315.   {
  1316.       Mark    *mp = CurMark();
  1317.       Line    *l1 = curline,
  1318. --- 355,361 ----
  1319.       } while (l1 != 0 && l2 != rl2);
  1320.   }
  1321.   
  1322. ! do_rfill(ulm)
  1323.   {
  1324.       Mark    *mp = CurMark();
  1325.       Line    *l1 = curline,
  1326. ***************
  1327. *** 364,370 ****
  1328.       int    c1 = curchar,
  1329.           c2 = mp->m_char;
  1330.   
  1331. !     use_lmargin = (exp_p != NO);
  1332.       (void) fixorder(&l1, &c1, &l2, &c2);
  1333.       DoJustify(l1, c1, l2, c2, NO, use_lmargin ? LMargin : 0);
  1334.   }
  1335. --- 363,369 ----
  1336.       int    c1 = curchar,
  1337.           c2 = mp->m_char;
  1338.   
  1339. !     use_lmargin = ulm;
  1340.       (void) fixorder(&l1, &c1, &l2, &c2);
  1341.       DoJustify(l1, c1, l2, c2, NO, use_lmargin ? LMargin : 0);
  1342.   }
  1343. ***************
  1344. *** 403,411 ****
  1345.           nspace = 0;
  1346.   
  1347.       if (diff > nspace)
  1348. !         DoTimes(DelPChar(), (diff - nspace));
  1349.       else if (diff < nspace)
  1350. !         DoTimes(Insert(' '), (nspace - diff));
  1351.   }
  1352.   
  1353.   DoJustify(l1, c1, l2, c2, scrunch, indent)
  1354. --- 402,410 ----
  1355.           nspace = 0;
  1356.   
  1357.       if (diff > nspace)
  1358. !         del_char(BACKWARD, (diff - nspace));
  1359.       else if (diff < nspace)
  1360. !         insert_c(' ', (nspace - diff));
  1361.   }
  1362.   
  1363.   DoJustify(l1, c1, l2, c2, scrunch, indent)
  1364. ***************
  1365. *** 414,423 ****
  1366.   {
  1367.       int    okay_char = -1;
  1368.       char    *cp;
  1369. !     Mark    *savedot = MakeMark(curline, curchar, FLOATER),
  1370.           *endmark;
  1371.   
  1372. -     exp = 1;
  1373.       (void) fixorder(&l1, &c1, &l2, &c2);    /* l1/c1 will be before l2/c2 */
  1374.       DotTo(l1, c1);
  1375.       if (get_indent(l1) >= c1) {
  1376. --- 413,421 ----
  1377.   {
  1378.       int    okay_char = -1;
  1379.       char    *cp;
  1380. !     Mark    *savedot = MakeMark(curline, curchar, M_FLOATER),
  1381.           *endmark;
  1382.   
  1383.       (void) fixorder(&l1, &c1, &l2, &c2);    /* l1/c1 will be before l2/c2 */
  1384.       DotTo(l1, c1);
  1385.       if (get_indent(l1) >= c1) {
  1386. ***************
  1387. *** 427,474 ****
  1388.           }
  1389.           ToIndent();
  1390.       }
  1391. !     endmark = MakeMark(l2, c2, FLOATER);
  1392.   
  1393.       for (;;) {
  1394. !         cp = StrIndex(1, linebuf, curchar, ' ');
  1395. !         if (cp == 0)
  1396. !             Eol();
  1397. !         else
  1398. !             curchar = (cp - linebuf);
  1399. !         if (curline == endmark->m_line && curchar >= endmark->m_char)
  1400. !             goto outahere;
  1401. !         if (eolp()) {
  1402. !             ins_str("  ", NO);
  1403. !             DelNChar();    /* delete line separator */
  1404. !             curchar -= 2;    /* back over the spaces */
  1405. !         }
  1406. !         /* at this point we are ALWAYS sitting right after
  1407. !            a word - that is, just before some spaces or the
  1408. !            end of the line */
  1409. !         if (calc_pos(linebuf, curchar) <= RMargin) {
  1410.               okay_char = curchar;
  1411.               do_space();
  1412. -             continue;
  1413.           }
  1414. - 
  1415. -         /* if we get here, we have done all we can for
  1416. -            this line - now we split the line, or just move
  1417. -            to the next one */
  1418.           if (okay_char > 0)
  1419.               curchar = okay_char;            
  1420.           if (curline == endmark->m_line && curchar >= endmark->m_char)
  1421.               goto outahere;
  1422. !         /* can't fit in small margin, so we do the best we can */
  1423.           if (eolp()) {
  1424. !             line_move(FORWARD, NO);
  1425.               n_indent(indent);
  1426.           } else {
  1427. -             /* insert a line break - line WAS too long */
  1428.               DelWtSpace();
  1429.               LineInsert(1);
  1430.               if (scrunch && TwoBlank()) {
  1431.                   Eol();
  1432. !                 DelNChar();
  1433.               }
  1434.               n_indent(indent);
  1435.           }
  1436. --- 425,464 ----
  1437.           }
  1438.           ToIndent();
  1439.       }
  1440. !     endmark = MakeMark(l2, c2, M_FLOATER);
  1441.   
  1442.       for (;;) {
  1443. !         while (calc_pos(linebuf, curchar) < RMargin) {
  1444. !             if (curline == endmark->m_line && curchar >= endmark->m_char)
  1445. !                 goto outahere;
  1446.               okay_char = curchar;
  1447. +             if (eolp()) {
  1448. +                 del_char(FORWARD, 1);    /* Delete line separator. */
  1449. +                 ins_str("  ", NO);
  1450. +             } else {
  1451. +                 cp = StrIndex(1, linebuf, curchar + 1, ' ');
  1452. +                 if (cp == 0)
  1453. +                     Eol();
  1454. +                 else
  1455. +                     curchar = (cp - linebuf);
  1456. +             }
  1457.               do_space();
  1458.           }
  1459.           if (okay_char > 0)
  1460.               curchar = okay_char;            
  1461.           if (curline == endmark->m_line && curchar >= endmark->m_char)
  1462.               goto outahere;
  1463. ! 
  1464. !         /* Can't fit in small margin, so we do the best we can. */
  1465.           if (eolp()) {
  1466. !             line_move(FORWARD, 1, NO);
  1467.               n_indent(indent);
  1468.           } else {
  1469.               DelWtSpace();
  1470.               LineInsert(1);
  1471.               if (scrunch && TwoBlank()) {
  1472.                   Eol();
  1473. !                 del_char(FORWARD, 1);
  1474.               }
  1475.               n_indent(indent);
  1476.           }
  1477. ***************
  1478. *** 486,492 ****
  1479.   
  1480.   DoPara(dir)
  1481.   {
  1482. !     register int    num = exp,
  1483.               first_time = TRUE;    
  1484.   
  1485.       while (--num >= 0) {
  1486. --- 476,482 ----
  1487.   
  1488.   DoPara(dir)
  1489.   {
  1490. !     register int    num = arg_value(),
  1491.               first_time = TRUE;    
  1492.   
  1493.       while (--num >= 0) {
  1494. ***************
  1495. *** 495,501 ****
  1496.               ((!first_time) || ((para_head == curline) && bolp()))) {
  1497.                   if (bobp())
  1498.                       complain((char *) 0);
  1499. !             BackChar();
  1500.               first_time = !first_time;
  1501.               goto tryagain;
  1502.           }
  1503. --- 485,491 ----
  1504.               ((!first_time) || ((para_head == curline) && bolp()))) {
  1505.                   if (bobp())
  1506.                       complain((char *) 0);
  1507. !             b_char(1);
  1508.               first_time = !first_time;
  1509.               goto tryagain;
  1510.           }
  1511. ***************
  1512. *** 502,508 ****
  1513.           SetLine((dir == BACKWARD) ? para_head : para_tail);
  1514.           if (dir == BACKWARD && !firstp(curline) &&
  1515.               i_blank(curline->l_prev))
  1516. !             line_move(BACKWARD, NO);
  1517.           else if (dir == FORWARD) {
  1518.               if (lastp(curline)) {
  1519.                   Eol();
  1520. --- 492,498 ----
  1521.           SetLine((dir == BACKWARD) ? para_head : para_tail);
  1522.           if (dir == BACKWARD && !firstp(curline) &&
  1523.               i_blank(curline->l_prev))
  1524. !             line_move(BACKWARD, 1, NO);
  1525.           else if (dir == FORWARD) {
  1526.               if (lastp(curline)) {
  1527.                   Eol();
  1528. ***************
  1529. *** 509,515 ****
  1530.                   break;
  1531.               }
  1532.               /* otherwise */
  1533. !             line_move(FORWARD, NO);
  1534.           }
  1535.       }
  1536.   }
  1537. --- 499,505 ----
  1538.                   break;
  1539.               }
  1540.               /* otherwise */
  1541. !             line_move(FORWARD, 1, NO);
  1542.           }
  1543.       }
  1544.   }
  1545. diff -c ojove/proc.c jove/proc.c
  1546. *** ojove/proc.c    Thu Jul 16 09:14:48 1987
  1547. --- jove/proc.c    Thu Jun 25 09:45:20 1987
  1548. ***************
  1549. *** 124,130 ****
  1550.       }
  1551.       if (cur_error != 0)
  1552.           ShowErr();
  1553. -     exp = 1;
  1554.   }
  1555.   
  1556.   /* Free up all the errors */
  1557. --- 124,129 ----
  1558. ***************
  1559. *** 145,153 ****
  1560.           noerrs[] = "No errors!";
  1561.   
  1562.   private
  1563. ! toerror(forward)
  1564.   {
  1565. -     register int    i;
  1566.       register struct error    *e = cur_error;
  1567.   
  1568.       if (e == 0)
  1569. --- 144,151 ----
  1570.           noerrs[] = "No errors!";
  1571.   
  1572.   private
  1573. ! toerror(forward, num)
  1574.   {
  1575.       register struct error    *e = cur_error;
  1576.   
  1577.       if (e == 0)
  1578. ***************
  1579. *** 156,162 ****
  1580.           (!forward && (e->er_prev == 0)))
  1581.           complain(errbounds, forward ? "last" : "first");
  1582.   
  1583. !     for (i = 0; i < exp; i++) {
  1584.           if ((e = forward ? e->er_next : e->er_prev) == 0)
  1585.               break;
  1586.           cur_error = e;
  1587. --- 154,160 ----
  1588.           (!forward && (e->er_prev == 0)))
  1589.           complain(errbounds, forward ? "last" : "first");
  1590.   
  1591. !     while (--num >= 0) {
  1592.           if ((e = forward ? e->er_next : e->er_prev) == 0)
  1593.               break;
  1594.           cur_error = e;
  1595. ***************
  1596. *** 187,194 ****
  1597.   ToError(forward)
  1598.   {
  1599.       do {
  1600. !         toerror(forward);
  1601. !         exp = 1;
  1602.       } while (!okay_error());
  1603.       ShowErr();
  1604.   }
  1605. --- 185,191 ----
  1606.   ToError(forward)
  1607.   {
  1608.       do {
  1609. !         toerror(forward, arg_value());
  1610.       } while (!okay_error());
  1611.       ShowErr();
  1612.   }
  1613. ***************
  1614. *** 293,303 ****
  1615.          default command and let the person decide. */
  1616.   
  1617.       compilation = (sindex("make", make_cmd) || sindex("cc", make_cmd));
  1618. !     if (exp_p || !compilation) {
  1619.           if (!compilation) {
  1620.               rbell();
  1621. !             Inputp = make_cmd;    /* insert the default for the
  1622. !                            user */
  1623.           }
  1624.           null_ncpy(make_cmd, ask(make_cmd, "Compilation command: "),
  1625.                   sizeof (make_cmd) - 1);
  1626. --- 290,299 ----
  1627.          default command and let the person decide. */
  1628.   
  1629.       compilation = (sindex("make", make_cmd) || sindex("cc", make_cmd));
  1630. !     if (is_an_arg() || !compilation) {
  1631.           if (!compilation) {
  1632.               rbell();
  1633. !             Inputp = make_cmd;    /* insert the default for the user */
  1634.           }
  1635.           null_ncpy(make_cmd, ask(make_cmd, "Compilation command: "),
  1636.                   sizeof (make_cmd) - 1);
  1637. ***************
  1638. *** 367,373 ****
  1639.                         curline, curchar);
  1640.           }
  1641.           SetBuf(wordsb);
  1642. !         line_move(FORWARD, NO);
  1643.       }
  1644.       add_mess("Done.");
  1645.       SetBuf(buftospel);
  1646. --- 363,369 ----
  1647.                         curline, curchar);
  1648.           }
  1649.           SetBuf(wordsb);
  1650. !         line_move(FORWARD, 1, NO);
  1651.       }
  1652.       add_mess("Done.");
  1653.       SetBuf(buftospel);
  1654. ***************
  1655. *** 378,387 ****
  1656.   
  1657.   ShToBuf()
  1658.   {
  1659. !     char    bufname[100];
  1660.   
  1661.       strcpy(bufname, ask((char *) 0, "Buffer: "));
  1662. !     DoShell(bufname, ask(ShcomBuf, "Command: "));
  1663.   }
  1664.   
  1665.   ShellCom()
  1666. --- 374,385 ----
  1667.   
  1668.   ShToBuf()
  1669.   {
  1670. !     char    bufname[128],
  1671. !         cmd[128];
  1672.   
  1673.       strcpy(bufname, ask((char *) 0, "Buffer: "));
  1674. !     strcpy(cmd, ask(ShcomBuf, "Command: "));
  1675. !     DoShell(bufname, cmd);
  1676.   }
  1677.   
  1678.   ShellCom()
  1679. ***************
  1680. *** 402,409 ****
  1681.       Window    *savewp = curwind;
  1682.       int    status;
  1683.   
  1684. !     exp = 1;
  1685. !     status = UnixToBuf(bufname, YES, 0, !exp_p, Shell,
  1686.                  ShFlags, command, (char *) 0);
  1687.       com_finish(status, command);
  1688.       SetWind(savewp);
  1689. --- 400,406 ----
  1690.       Window    *savewp = curwind;
  1691.       int    status;
  1692.   
  1693. !     status = UnixToBuf(bufname, YES, 0, !is_an_arg(), Shell,
  1694.                  ShFlags, command, (char *) 0);
  1695.       com_finish(status, command);
  1696.       SetWind(savewp);
  1697. ***************
  1698. *** 465,471 ****
  1699.      to fix everything up after we're done.  (Usually there's nothing to
  1700.      fix up.) */
  1701.   
  1702. ! /* VARARGS5 */
  1703.   
  1704.   UnixToBuf(bufname, disp, wsize, clobber, va_alist)
  1705.   char    *bufname;
  1706. --- 462,468 ----
  1707.      to fix everything up after we're done.  (Usually there's nothing to
  1708.      fix up.) */
  1709.   
  1710. ! /* VARARGS4 */
  1711.   
  1712.   UnixToBuf(bufname, disp, wsize, clobber, va_alist)
  1713.   char    *bufname;
  1714. ***************
  1715. *** 517,523 ****
  1716.   #else
  1717.       old_int = signal(SIGINT, SIG_IGN),
  1718.   #endif
  1719. -     exp = 1;
  1720.       dopipe(p);
  1721.       pid = fork();
  1722.       if (pid == -1) {
  1723. --- 514,519 ----
  1724. ***************
  1725. *** 621,633 ****
  1726.   {
  1727.       Mark    *m = CurMark();
  1728.       char    *tname = mktemp("/tmp/jfilterXXXXXX"),
  1729. !         combuf[130];
  1730.       Window    *save_wind = curwind;
  1731. !     int    status;
  1732.       File    *fp;
  1733.   
  1734. -     CATCH
  1735.       fp = open_file(tname, iobuff, F_WRITE, COMPLAIN, QUIET);
  1736.       putreg(fp, m->m_line, m->m_char, curline, curchar, YES);
  1737.       DelReg();
  1738.       sprintf(combuf, "%s < %s", cmd, tname);
  1739. --- 617,630 ----
  1740.   {
  1741.       Mark    *m = CurMark();
  1742.       char    *tname = mktemp("/tmp/jfilterXXXXXX"),
  1743. !         combuf[128];
  1744.       Window    *save_wind = curwind;
  1745. !     int    status,
  1746. !         error = NO;
  1747.       File    *fp;
  1748.   
  1749.       fp = open_file(tname, iobuff, F_WRITE, COMPLAIN, QUIET);
  1750. +     CATCH
  1751.       putreg(fp, m->m_line, m->m_char, curline, curchar, YES);
  1752.       DelReg();
  1753.       sprintf(combuf, "%s < %s", cmd, tname);
  1754. ***************
  1755. *** 634,646 ****
  1756.       status = UnixToBuf(outbuf->b_name, NO, 0, outbuf->b_type == B_SCRATCH,
  1757.                  Shell, ShFlags, combuf, (char *) 0);
  1758.       ONERROR
  1759. !     ;    /* Do nothing ... but fall through and delete the tmp
  1760. !            file. */
  1761.       ENDCATCH
  1762.       f_close(fp);
  1763.       (void) unlink(tname);
  1764.       SetWind(save_wind);
  1765. !     com_finish(status, combuf);
  1766.   }
  1767.   
  1768.   isprocbuf(bufname)
  1769. --- 631,643 ----
  1770.       status = UnixToBuf(outbuf->b_name, NO, 0, outbuf->b_type == B_SCRATCH,
  1771.                  Shell, ShFlags, combuf, (char *) 0);
  1772.       ONERROR
  1773. !     error = YES;
  1774.       ENDCATCH
  1775.       f_close(fp);
  1776.       (void) unlink(tname);
  1777.       SetWind(save_wind);
  1778. !     if (error == NO)
  1779. !         com_finish(status, combuf);
  1780.   }
  1781.   
  1782.   isprocbuf(bufname)
  1783. Only in ojove: rcs.output
  1784. diff -c ojove/re.c jove/re.c
  1785. *** ojove/re.c    Thu Jul 16 09:14:53 1987
  1786. --- jove/re.c    Wed Jun 24 12:43:25 1987
  1787. ***************
  1788. *** 26,50 ****
  1789.       WrapScan = 0,
  1790.       UseRE = 0;
  1791.   
  1792. - private char    CaseEquiv[] = {
  1793. -     '\000',    '\001',    '\002',    '\003',    '\004',    '\005',    '\006',    '\007',
  1794. -     '\010',    '\011',    '\012',    '\013',    '\014',    '\015',    '\016',    '\017',
  1795. -     '\020',    '\021',    '\022',    '\023',    '\024',    '\025',    '\026',    '\027',
  1796. -     '\030',    '\031',    '\032',    '\033',    '\034',    '\035',    '\036',    '\037',
  1797. -     '\040',    '!',    '"',    '#',    '$',    '%',    '&',    '\'',
  1798. -     '(',    ')',    '*',    '+',    ',',    '-',    '.',    '/',
  1799. -     '0',    '1',    '2',    '3',    '4',    '5',    '6',    '7',
  1800. -     '8',    '9',    ':',    ';',    '<',    '=',    '>',    '?',
  1801. -     '@',    'A',    'B',    'C',    'D',    'E',    'F',    'G',
  1802. -     'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
  1803. -     'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
  1804. -     'X',    'Y',    'Z',    '[',    '\\',    ']',    '^',    '_',
  1805. -     '`',    'A',    'B',    'C',    'D',    'E',    'F',    'G',
  1806. -     'H',    'I',    'J',    'K',    'L',    'M',    'N',    'O',
  1807. -     'P',    'Q',    'R',    'S',    'T',    'U',    'V',    'W',
  1808. -     'X',    'Y',    'Z',    '{',    '|',    '}',    '~',    '\177'
  1809. - };
  1810. - 
  1811.   #define cind_cmp(a, b)    (CaseEquiv[a] == CaseEquiv[b])
  1812.   
  1813.   private int    REpeekc;
  1814. --- 26,31 ----
  1815. ***************
  1816. *** 738,747 ****
  1817.   
  1818.       if (!delp) while (c = *repp++) {
  1819.           if (c == '\\') {
  1820. !             if ((c = *repp++) == '\0') {
  1821.                   *tp++ = '\\';
  1822.                     goto endchk;
  1823. !             } else if ((c = *repp++) >= '1' && c <= nparens + '1') {
  1824.                   tp = insert(tp, endp, c - '1');
  1825.                   continue;
  1826.               }
  1827. --- 719,729 ----
  1828.   
  1829.       if (!delp) while (c = *repp++) {
  1830.           if (c == '\\') {
  1831. !             c = *repp++;
  1832. !             if (c == '\0') {
  1833.                   *tp++ = '\\';
  1834.                     goto endchk;
  1835. !             } else if (c >= '1' && c <= nparens + '1') {
  1836.                   tp = insert(tp, endp, c - '1');
  1837.                   continue;
  1838.               }
  1839. ***************
  1840. *** 786,792 ****
  1841.           repbuf[sizeof rep_str],
  1842.           *altbuf[NALTS];
  1843.       int    npars;
  1844. !     Mark    *m = MakeMark(curline, REbom, FLOATER);
  1845.   
  1846.       message("Type C-X C-C to continue with query replace.");
  1847.   
  1848. --- 768,774 ----
  1849.           repbuf[sizeof rep_str],
  1850.           *altbuf[NALTS];
  1851.       int    npars;
  1852. !     Mark    *m = MakeMark(curline, REbom, M_FLOATER);
  1853.   
  1854.       message("Type C-X C-C to continue with query replace.");
  1855.   
  1856. ***************
  1857. *** 801,807 ****
  1858.       byte_copy(sbuf, searchstr, sizeof searchstr);
  1859.       byte_copy(repbuf, rep_str, sizeof rep_str);
  1860.       byte_copy((char *) altbuf, (char *) alternates, sizeof alternates);
  1861. !     if (!exp_p)
  1862.           ToMark(m);
  1863.       DelMark(m);
  1864.   }
  1865. --- 783,789 ----
  1866.       byte_copy(sbuf, searchstr, sizeof searchstr);
  1867.       byte_copy(repbuf, rep_str, sizeof rep_str);
  1868.       byte_copy((char *) altbuf, (char *) alternates, sizeof alternates);
  1869. !     if (!is_an_arg())
  1870.           ToMark(m);
  1871.       DelMark(m);
  1872.   }
  1873. diff -c ojove/re1.c jove/re1.c
  1874. *** ojove/re1.c    Thu Jul 16 09:14:58 1987
  1875. --- jove/re1.c    Fri Jul 10 09:25:51 1987
  1876. ***************
  1877. *** 8,15 ****
  1878.   #include "jove.h"
  1879.   #include "io.h"
  1880.   #include "re.h"
  1881.   
  1882. ! static
  1883.   substitute(query, l1, char1, l2, char2)
  1884.   Line    *l1,
  1885.       *l2;
  1886. --- 8,17 ----
  1887.   #include "jove.h"
  1888.   #include "io.h"
  1889.   #include "re.h"
  1890. + #include <sys/types.h>
  1891. + #include <sys/stat.h>
  1892.   
  1893. ! private
  1894.   substitute(query, l1, char1, l2, char2)
  1895.   Line    *l1,
  1896.       *l2;
  1897. ***************
  1898. *** 35,41 ****
  1899.               if (query) {
  1900.                   message("Replace (Type '?' for help)? ");
  1901.   reswitch:            redisplay();
  1902. !                 switch (Upper(getchar())) {
  1903.                   case '.':
  1904.                       stop++;
  1905.                       /* Fall into ... */
  1906. --- 37,43 ----
  1907.               if (query) {
  1908.                   message("Replace (Type '?' for help)? ");
  1909.   reswitch:            redisplay();
  1910. !                 switch (CharUpcase(getchar())) {
  1911.                   case '.':
  1912.                       stop++;
  1913.                       /* Fall into ... */
  1914. ***************
  1915. *** 51,57 ****
  1916.                           goto nxtline;
  1917.                       continue;
  1918.   
  1919. !                 case CTL(W):
  1920.                       re_dosub(linebuf, YES);
  1921.                       numdone++;
  1922.                       offset = curchar = REbom;
  1923. --- 53,59 ----
  1924.                           goto nxtline;
  1925.                       continue;
  1926.   
  1927. !                 case CTL('W'):
  1928.                       re_dosub(linebuf, YES);
  1929.                       numdone++;
  1930.                       offset = curchar = REbom;
  1931. ***************
  1932. *** 58,64 ****
  1933.                       makedirty(curline);
  1934.                       /* Fall into ... */
  1935.   
  1936. !                 case CTL(R):
  1937.                   case 'R':
  1938.                       RErecur();
  1939.                       offset = curchar;
  1940. --- 60,66 ----
  1941.                       makedirty(curline);
  1942.                       /* Fall into ... */
  1943.   
  1944. !                 case CTL('R'):
  1945.                   case 'R':
  1946.                       RErecur();
  1947.                       offset = curchar;
  1948. ***************
  1949. *** 65,71 ****
  1950.                       lp = curline;
  1951.                       continue;
  1952.   
  1953. !                 case CTL(U):
  1954.                   case 'U':
  1955.                       if (UNDO_lp == 0)
  1956.                           continue;
  1957. --- 67,73 ----
  1958.                       lp = curline;
  1959.                       continue;
  1960.   
  1961. !                 case CTL('U'):
  1962.                   case 'U':
  1963.                       if (UNDO_lp == 0)
  1964.                           continue;
  1965. ***************
  1966. *** 85,91 ****
  1967.                   case 'Q':
  1968.                       goto done;
  1969.   
  1970. !                 case CTL(L):
  1971.                       RedrawDisplay();
  1972.                       goto reswitch;
  1973.   
  1974. --- 87,93 ----
  1975.                   case 'Q':
  1976.                       goto done;
  1977.   
  1978. !                 case CTL('L'):
  1979.                       RedrawDisplay();
  1980.                       goto reswitch;
  1981.   
  1982. ***************
  1983. *** 110,116 ****
  1984.   nxtline:            break;
  1985.           }
  1986.       }
  1987. !     SetMark();
  1988.   done:    s_mess("%d substitution%n.", numdone, numdone);
  1989.   }
  1990.   
  1991. --- 112,118 ----
  1992.   nxtline:            break;
  1993.           }
  1994.       }
  1995. !     set_mark();
  1996.   done:    s_mess("%d substitution%n.", numdone, numdone);
  1997.   }
  1998.   
  1999. ***************
  2000. *** 117,126 ****
  2001.   /* Prompt for search and replacement strings and do the substitution.  The
  2002.      point is restored when we're done. */
  2003.   
  2004. ! static
  2005.   replace(query, inreg)
  2006.   {
  2007. !     Mark    *save = MakeMark(curline, curchar, FLOATER),
  2008.           *m;
  2009.       char    *rep_ptr;
  2010.       Line    *l1 = curline,
  2011. --- 119,128 ----
  2012.   /* Prompt for search and replacement strings and do the substitution.  The
  2013.      point is restored when we're done. */
  2014.   
  2015. ! private
  2016.   replace(query, inreg)
  2017.   {
  2018. !     Mark    *save = MakeMark(curline, curchar, M_FLOATER),
  2019.           *m;
  2020.       char    *rep_ptr;
  2021.       Line    *l1 = curline,
  2022. ***************
  2023. *** 166,174 ****
  2024.       replace(0, NO);
  2025.   }
  2026.   
  2027. ! /* C tags package. */
  2028.   
  2029. ! static
  2030.   lookup(searchbuf, filebuf, tag, file)
  2031.   char    *searchbuf,
  2032.       *filebuf,
  2033. --- 168,180 ----
  2034.       replace(0, NO);
  2035.   }
  2036.   
  2037. ! /* Lookup a tag in tag file FILE.  FILE is assumed to be sorted
  2038. !    alphabetically.  The FASTTAGS code, which is implemented with
  2039. !    a binary search, depends on this assumption.  If it's not true
  2040. !    it is possible to comment out the fast tag code (which is clearly
  2041. !    labeled) and everything else will just work. */
  2042.   
  2043. ! private
  2044.   lookup(searchbuf, filebuf, tag, file)
  2045.   char    *searchbuf,
  2046.       *filebuf,
  2047. ***************
  2048. *** 176,205 ****
  2049.       *file;
  2050.   {
  2051.       register int    taglen = strlen(tag);
  2052. !     char    line[128],
  2053. !         pattern[100];
  2054. !     File    *fp;
  2055.   
  2056.       fp = open_file(file, iobuff, F_READ, !COMPLAIN, QUIET);
  2057.       if (fp == NIL)
  2058.           return 0;
  2059. !     sprintf(pattern, "^%s[^\t]*\t\\([^\t]*\\)\t[?/]\\(.*\\)[?/]$", tag);
  2060.       while (f_gets(fp, line, sizeof line) != EOF) {
  2061. !         if (line[0] != *tag || strncmp(tag, line, taglen) != 0)
  2062.               continue;
  2063. !         if (!LookingAt(pattern, line, 0)) {
  2064.               complain("I thought I saw it!");
  2065.               break;
  2066.           } else {
  2067.               putmatch(2, searchbuf, 100);
  2068. !             putmatch(1, filebuf, 100);
  2069. !             close_file(fp);
  2070. !             return 1;
  2071.           }
  2072.       }
  2073. !     f_close(fp);
  2074. !     s_mess("Can't find tag \"%s\".", tag);
  2075. !     return 0;
  2076.   }
  2077.   
  2078.   char    TagFile[128] = "./tags";
  2079. --- 182,267 ----
  2080.       *file;
  2081.   {
  2082.       register int    taglen = strlen(tag);
  2083. !     char    line[BUFSIZ],
  2084. !         pattern[128];
  2085. !     register File    *fp;
  2086. !     struct stat    stbuf;
  2087. !     int    fast = YES,
  2088. !         success = NO;
  2089. !     register off_t    lower, upper;
  2090.   
  2091. +     sprintf(pattern, "^%s[^\t]*\t*\\([^\t]*\\)\t*[?/]\\([^?/]*\\)[?/]", tag);
  2092.       fp = open_file(file, iobuff, F_READ, !COMPLAIN, QUIET);
  2093.       if (fp == NIL)
  2094.           return 0;
  2095. ! 
  2096. !     /* ********BEGIN FAST TAG CODE******** */
  2097. ! 
  2098. !     if (stat(file, &stbuf) < 0)
  2099. !         fast = NO;
  2100. !     else {
  2101. !         lower = 0;
  2102. !         upper = stbuf.st_size;
  2103. !         if (upper - lower < BUFSIZ)
  2104. !             fast = NO;
  2105. !     }
  2106. !     if (fast == YES) for (;;) {
  2107. !         off_t    mid;
  2108. !         int    whichway;
  2109. ! 
  2110. !         if (upper - lower < BUFSIZ) {
  2111. !             f_seek(fp, lower);
  2112. !             break;            /* stop this nonsense */
  2113. !         }
  2114. !         mid = (lower + upper) / 2;
  2115. !         f_seek(fp, mid);
  2116. !         f_toNL(fp);
  2117. !         if (f_gets(fp, line, sizeof line) == EOF)
  2118. !             break;
  2119. !         whichway = strncmp(line, tag, taglen);
  2120. !         if (whichway < 0) {
  2121. !             lower = mid;
  2122. !             continue;
  2123. !         } else if (whichway > 0) {
  2124. !             upper = mid;
  2125. !             continue;
  2126. !         } else {
  2127. !             if (strcmp(tag, line) == 0)    /* exact match */
  2128. !                 goto found;
  2129. !             goto look_harder;
  2130. !         }
  2131. !     }
  2132. !     f_toNL(fp);
  2133. !     /* END FAST TAG CODE */
  2134. ! 
  2135.       while (f_gets(fp, line, sizeof line) != EOF) {
  2136. !         int    cmp;
  2137. ! 
  2138. ! look_harder:    if (line[0] > *tag)
  2139. !             break;
  2140. !         else if ((cmp = strncmp(line, tag, taglen)) > 0)
  2141. !             break;
  2142. !         else if (cmp < 0)
  2143.               continue;
  2144. !         /* if we get here, we've found the match */
  2145. ! found:        if (!LookingAt(pattern, line, 0)) {
  2146.               complain("I thought I saw it!");
  2147.               break;
  2148.           } else {
  2149. +             putmatch(1, filebuf, FILESIZE);
  2150.               putmatch(2, searchbuf, 100);
  2151. !             success = YES;
  2152. !             if (strcmp(tag, line) == 0)    /* exact match */
  2153. !                 break;
  2154. !             continue;
  2155.           }
  2156.       }
  2157. !     close_file(fp);
  2158. !         
  2159. !     if (success == NO)
  2160. !         s_mess("Can't find tag \"%s\".", tag);
  2161. ! 
  2162. !     return success;
  2163.   }
  2164.   
  2165.   char    TagFile[128] = "./tags";
  2166. ***************
  2167. *** 223,235 ****
  2168.           tagfname = TagFile;
  2169.       if (lookup(sstr, filebuf, tag, tagfname) == 0)
  2170.           return;
  2171. !     SetMark();
  2172.       b = do_find(curwind, filebuf, 0);
  2173.       if (curbuf != b)
  2174.           SetABuf(curbuf);
  2175.       SetBuf(b);
  2176.       if ((bp = dosearch(sstr, BACKWARD, 0)) == 0 &&
  2177. !         (WrapScan || ((bp = dosearch(sstr, FORWARD, 0)) == 0)))
  2178.           message("Well, I found the file, but the tag is missing.");
  2179.       else
  2180.           SetDot(bp);
  2181. --- 285,297 ----
  2182.           tagfname = TagFile;
  2183.       if (lookup(sstr, filebuf, tag, tagfname) == 0)
  2184.           return;
  2185. !     set_mark();
  2186.       b = do_find(curwind, filebuf, 0);
  2187.       if (curbuf != b)
  2188.           SetABuf(curbuf);
  2189.       SetBuf(b);
  2190.       if ((bp = dosearch(sstr, BACKWARD, 0)) == 0 &&
  2191. !         ((bp = dosearch(sstr, FORWARD, 0)) == 0))
  2192.           message("Well, I found the file, but the tag is missing.");
  2193.       else
  2194.           SetDot(bp);
  2195. ***************
  2196. *** 237,243 ****
  2197.   
  2198.   FindTag()
  2199.   {
  2200. !     int    localp = !exp_p;
  2201.       char    tag[128];
  2202.   
  2203.       strcpy(tag, ask((char *) 0, ProcFmt));
  2204. --- 299,305 ----
  2205.   
  2206.   FindTag()
  2207.   {
  2208. !     int    localp = !is_an_arg();
  2209.       char    tag[128];
  2210.   
  2211.       strcpy(tag, ask((char *) 0, ProcFmt));
  2212. ***************
  2213. *** 260,266 ****
  2214.           c2++;
  2215.   
  2216.       null_ncpy(tagname, linebuf + c1, c2 - c1);
  2217. !     find_tag(tagname, !exp_p);
  2218.   }
  2219.   
  2220.   /* I-search returns a code saying what to do:
  2221. --- 322,328 ----
  2222.           c2++;
  2223.   
  2224.       null_ncpy(tagname, linebuf + c1, c2 - c1);
  2225. !     find_tag(tagname, !is_an_arg());
  2226.   }
  2227.   
  2228.   /* I-search returns a code saying what to do:
  2229. ***************
  2230. *** 282,288 ****
  2231.           *incp = 0;
  2232.   int    SExitChar = CR;
  2233.   
  2234. ! #define cmp_char(a, b)    ((a) == (b) || (CaseIgnore && (Upper(a) == Upper(b))))
  2235.   
  2236.   static Bufpos *
  2237.   doisearch(dir, c, failing)
  2238. --- 344,350 ----
  2239.           *incp = 0;
  2240.   int    SExitChar = CR;
  2241.   
  2242. ! #define cmp_char(a, b)    ((a) == (b) || (CaseIgnore && (CharUpcase(a) == CharUpcase(b))))
  2243.   
  2244.   static Bufpos *
  2245.   doisearch(dir, c, failing)
  2246. ***************
  2247. *** 294,300 ****
  2248.       Bufpos    *bp;
  2249.       extern int    okay_wrap;
  2250.   
  2251. !     if (c == CTL(S) || c == CTL(R))
  2252.           goto dosrch;
  2253.   
  2254.       if (failing)
  2255. --- 356,362 ----
  2256.       Bufpos    *bp;
  2257.       extern int    okay_wrap;
  2258.   
  2259. !     if (c == CTL('S') || c == CTL('R'))
  2260.           goto dosrch;
  2261.   
  2262.       if (failing)
  2263. ***************
  2264. *** 338,344 ****
  2265.           SetDot(&save_env);
  2266.       else {
  2267.           if (LineDist(curline, save_env.p_line) >= MarkThresh)
  2268. !             DoSetMark(save_env.p_line, save_env.p_char);
  2269.       }
  2270.       setsearch(ISbuf);
  2271.   }
  2272. --- 400,406 ----
  2273.           SetDot(&save_env);
  2274.       else {
  2275.           if (LineDist(curline, save_env.p_line) >= MarkThresh)
  2276. !             do_set_mark(save_env.p_line, save_env.p_char);
  2277.       }
  2278.       setsearch(ISbuf);
  2279.   }
  2280. ***************
  2281. *** 385,391 ****
  2282.           case BS:
  2283.               return DELETE;
  2284.   
  2285. !         case CTL(G):
  2286.               /* If we're failing, we backup until we're no longer
  2287.                  failing or we've reached the beginning; else, we
  2288.                  just about the search and go back to the start. */
  2289. --- 447,453 ----
  2290.           case BS:
  2291.               return DELETE;
  2292.   
  2293. !         case CTL('G'):
  2294.               /* If we're failing, we backup until we're no longer
  2295.                  failing or we've reached the beginning; else, we
  2296.                  just about the search and go back to the start. */
  2297. ***************
  2298. *** 393,402 ****
  2299.                   return BACKUP;
  2300.               return TOSTART;
  2301.   
  2302. !         case CTL(\\):
  2303. !             c = CTL(S);
  2304. !         case CTL(S):
  2305. !         case CTL(R):
  2306.               /* If this is the first time through and we have a
  2307.                  search string left over from last time, use that
  2308.                  one now. */
  2309. --- 455,464 ----
  2310.                   return BACKUP;
  2311.               return TOSTART;
  2312.   
  2313. !         case CTL('\\'):
  2314. !             c = CTL('S');
  2315. !         case CTL('S'):
  2316. !         case CTL('R'):
  2317.               /* If this is the first time through and we have a
  2318.                  search string left over from last time, use that
  2319.                  one now. */
  2320. ***************
  2321. *** 404,410 ****
  2322.                   strcpy(ISbuf, getsearch());
  2323.                   incp = &ISbuf[strlen(ISbuf)];
  2324.               }
  2325. !             ndir = (c == CTL(S)) ? FORWARD : BACKWARD;
  2326.               /* If we're failing and we're not changing our
  2327.                  direction, don't recur since there's no way
  2328.                  the search can work. */
  2329. --- 466,472 ----
  2330.                   strcpy(ISbuf, getsearch());
  2331.                   incp = &ISbuf[strlen(ISbuf)];
  2332.               }
  2333. !             ndir = (c == CTL('S')) ? FORWARD : BACKWARD;
  2334.               /* If we're failing and we're not changing our
  2335.                  direction, don't recur since there's no way
  2336.                  the search can work. */
  2337. ***************
  2338. *** 423,430 ****
  2339.               add_mess("\\");
  2340.               /* Fall into ... */
  2341.   
  2342. !         case CTL(Q):
  2343. !         case CTL(^):
  2344.               add_mess("");
  2345.               c = getch() | 0400;
  2346.               /* Fall into ... */
  2347. --- 485,492 ----
  2348.               add_mess("\\");
  2349.               /* Fall into ... */
  2350.   
  2351. !         case CTL('Q'):
  2352. !         case CTL('^'):
  2353.               add_mess("");
  2354.               c = getch() | 0400;
  2355.               /* Fall into ... */
  2356.