home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume11 / jove.pch / part02 / jove.pch.2
Encoding:
Text File  |  1987-09-15  |  42.7 KB  |  1,999 lines
  1. diff -c ojove/fp.c jove/fp.c
  2. *** ojove/fp.c    Thu Jul 16 09:14:23 1987
  3. --- jove/fp.c    Fri Jun 12 10:30:44 1987
  4. ***************
  5. *** 7,12 ****
  6. --- 7,13 ----
  7.   
  8.   #include "jove.h"
  9.   #include "io.h"
  10. + #include "ctype.h"
  11.   #include "termcap.h"
  12.   #include <sys/stat.h>
  13.   #include <sys/file.h>
  14. ***************
  15. *** 14,22 ****
  16.   
  17.   #define MAXFILES    20    /* good enough for my purposes */
  18.   
  19. ! static File    _openfiles[MAXFILES] = {0};
  20.   
  21. ! static File *
  22.   f_alloc(name, flags, fd, buffer, buf_size)
  23.   char    *name,
  24.       *buffer;
  25. --- 15,23 ----
  26.   
  27.   #define MAXFILES    20    /* good enough for my purposes */
  28.   
  29. ! private File    _openfiles[MAXFILES] = {0};
  30.   
  31. ! private File *
  32.   f_alloc(name, flags, fd, buffer, buf_size)
  33.   char    *name,
  34.       *buffer;
  35. ***************
  36. *** 106,111 ****
  37. --- 107,114 ----
  38.           return EOF;
  39.       fp->f_ptr = fp->f_base;
  40.       fp->f_cnt = read(fp->f_fd, fp->f_base, fp->f_bufsize);
  41. +     while (fp->f_cnt == -1 && errno == EINTR)
  42. +         fp->f_cnt = read(fp->f_fd, fp->f_base, fp->f_bufsize);
  43.       if (fp->f_cnt == -1) {
  44.           printf("[Read error %d]", errno);
  45.           fp->f_flags |= F_ERR;
  46. ***************
  47. *** 147,152 ****
  48. --- 150,166 ----
  49.       _flush(EOF, fp);
  50.   }
  51.   
  52. + f_seek(fp, offset)
  53. + register File    *fp;
  54. + off_t    offset;
  55. + {
  56. +     if (fp->f_flags & F_WRITE)
  57. +         flush(fp);
  58. +     fp->f_cnt = 0;        /* next read will filbuf(), next write
  59. +                    will flush() with no bad effects */
  60. +     lseek(fp->f_fd, (long) offset, L_SET);
  61. + }
  62. + 
  63.   _flush(c, fp)
  64.   register File    *fp;
  65.   {
  66. ***************
  67. *** 182,188 ****
  68.           return EOF;
  69.       while (((c = getc(fp)) != EOF) && (c != '\n')) {
  70.           if (c == NULL)
  71. !             continue;    /* sorry we don't read nulls */
  72.           if (cp >= endp) {
  73.               add_mess(" [Line too long]");
  74.               rbell();
  75. --- 196,202 ----
  76.           return EOF;
  77.       while (((c = getc(fp)) != EOF) && (c != '\n')) {
  78.           if (c == NULL)
  79. !             break;        /* sorry we don't read nulls */
  80.           if (cp >= endp) {
  81.               add_mess(" [Line too long]");
  82.               rbell();
  83. ***************
  84. *** 201,215 ****
  85.       return NIL;    /* this means okay */
  86.   }
  87.   
  88.   /* Deals with output to the terminal, setting up the amount of characters
  89.      to be buffered depending on the output baud rate.  Why it's in a 
  90.      separate file I don't know ... */
  91.   
  92. ! static char    one_buf;
  93.   
  94.   int    BufSize = 1;
  95.   
  96. ! static File    _stdout = {1, 1, 1, F_WRITE, &one_buf, &one_buf};
  97.   File    *stdout = &_stdout;
  98.   
  99.   /* put a string with padding */
  100. --- 215,264 ----
  101.       return NIL;    /* this means okay */
  102.   }
  103.   
  104. + /* skip to beginning of next line, i.e., next read returns first
  105. +    character of new line */
  106. + f_toNL(fp)
  107. + register File    *fp;
  108. + {
  109. +     register int    c;
  110. + 
  111. +     if (fp->f_flags & F_EOF)
  112. +         return;
  113. +     while (((c = getc(fp)) != EOF) && (c != '\n'))
  114. +         ;
  115. +     if (c == EOF)
  116. +         fp->f_flags |= F_EOF;
  117. + }
  118. + 
  119. + f_readn(fp, addr, n)
  120. + register File    *fp;
  121. + register char    *addr;
  122. + register int    n;
  123. + {
  124. +     while (--n >= 0)
  125. +         *addr++ = getc(fp);
  126. + }
  127. + 
  128. + f_getint(fp)
  129. + File    *fp;
  130. + {
  131. +     int    n = 0,
  132. +         c;
  133. + 
  134. +     while (isdigit(c = getc(fp)))
  135. +         n = (n * 10) + c;
  136. +     return n;
  137. + }
  138. + 
  139.   /* Deals with output to the terminal, setting up the amount of characters
  140.      to be buffered depending on the output baud rate.  Why it's in a 
  141.      separate file I don't know ... */
  142.   
  143. ! private char    one_buf;
  144.   
  145.   int    BufSize = 1;
  146.   
  147. ! private File    _stdout = {1, 1, 1, F_WRITE, &one_buf, &one_buf};
  148.   File    *stdout = &_stdout;
  149.   
  150.   /* put a string with padding */
  151. diff -c ojove/funcdefs.c jove/funcdefs.c
  152. *** ojove/funcdefs.c    Thu Jul 16 09:14:24 1987
  153. --- jove/funcdefs.c    Fri Jun 12 12:25:57 1987
  154. ***************
  155. *** 6,11 ****
  156. --- 6,12 ----
  157.    ************************************************************************/
  158.   
  159.   #include "jove.h"
  160. + #include "ctype.h"
  161.   
  162.   #ifndef TXT_TO_C
  163.   extern int
  164. ***************
  165. *** 97,103 ****
  166.       ForChar(),
  167.       FSexpr(),
  168.       ForWord(),
  169. !     FourTime(),
  170.       GoLine(),
  171.       GrowWindow(),
  172.       IncFSearch(),
  173. --- 98,104 ----
  174.       ForChar(),
  175.       FSexpr(),
  176.       ForWord(),
  177. !     TimesFour(),
  178.       GoLine(),
  179.       GrowWindow(),
  180.       IncFSearch(),
  181. ***************
  182. *** 167,172 ****
  183. --- 168,174 ----
  184.       SpelBuffer(),
  185.   #endif
  186.       SplitWind(),
  187. +     GotoWind(),
  188.       Remember(),
  189.       Forget(),
  190.       StrLength(),
  191. ***************
  192. *** 354,363 ****
  193. --- 356,367 ----
  194.       FUNCTION, "forward-sentence", WIRED_CMD(Eos),
  195.       FUNCTION, "forward-word", WIRED_CMD(ForWord),
  196.       DefMajor(FUNDAMENTAL), "fundamental-mode", 0,
  197. +     FUNCTION, "gather-numeric-argument", WIRED_CMD(TimesFour),
  198.   #ifdef LISP
  199.       FUNCTION, "grind-s-expr", WIRED_CMD(GSexpr),
  200.   #endif
  201.       FUNCTION, "goto-line", WIRED_CMD(GoLine),
  202. +     FUNCTION, "goto-window-with-buffer", WIRED_CMD(GotoWind),
  203.       FUNCTION, "grow-window", WIRED_CMD(GrowWindow),
  204.       FUNCTION, "handle-tab", WIRED_CMD(Tab),
  205.       FUNCTION, "i-search-forward", WIRED_CMD(IncFSearch),
  206. ***************
  207. *** 432,438 ****
  208.       FUNCTION, "pushd", WIRED_CMD(Pushd),
  209.       FUNCTION, "pwd", WIRED_CMD(prCWD),
  210.   #endif
  211. -     FUNCTION, "quadruple-numeric-argument", WIRED_CMD(FourTime),
  212.       FUNCTION, "query-replace-string", WIRED_CMD(QRepSearch),
  213.   #ifdef IPROCS
  214.       FUNCTION, "quit-process", WIRED_CMD(ProcQuit),
  215. --- 436,441 ----
  216. ***************
  217. *** 520,530 ****
  218.           struct cmd    *which;
  219.           int    cmdlen,
  220.               found = 0;
  221. !         static struct cmd    *cmdhash[1 + 26];
  222.           static int    beenhere = NO;
  223.   
  224.   /* special case for prefix commands--only upper case ones */
  225. ! #define hash(c)    ((c == 'P') ? 0 : 1 + (c - 'a'))
  226.   
  227.           /* initialize the hash table */
  228.           if (beenhere == NO) {
  229. --- 523,533 ----
  230.           struct cmd    *which;
  231.           int    cmdlen,
  232.               found = 0;
  233. !         static struct cmd    *cmdhash[26];
  234.           static int    beenhere = NO;
  235.   
  236.   /* special case for prefix commands--only upper case ones */
  237. ! #define hash(c)    (c - 'a')
  238.   
  239.           /* initialize the hash table */
  240.           if (beenhere == NO) {
  241. ***************
  242. *** 539,546 ****
  243.           }
  244.   
  245.           /* gather the cmd name */
  246. !         while (((c = getch()) != EOF) && !index(" \t\r\n", c))
  247.               *cp++ = c;
  248.           if (c == EOF)
  249.               return 0;
  250.           *cp = '\0';
  251. --- 542,552 ----
  252.           }
  253.   
  254.           /* gather the cmd name */
  255. !         while (((c = getch()) != EOF) && !index(" \t\r\n", c)) {
  256. !             if (isupper(c))
  257. !                 c = tolower(c);
  258.               *cp++ = c;
  259. +         }
  260.           if (c == EOF)
  261.               return 0;
  262.           *cp = '\0';
  263. ***************
  264. *** 549,555 ****
  265.               return 0;
  266.   
  267.           /* look it up (in the reduced search space) */
  268. !         for (cmd = cmdhash[hash(cmdbuf[0])]; cmd->Name[0] == cmdbuf[0]; cmd++) {
  269.               if (strncmp(cmd->Name, cmdbuf, cmdlen) == 0) {
  270.                   if (strcmp(cmd->Name, cmdbuf) == 0)
  271.                       return (data_obj *) cmd;
  272. --- 555,562 ----
  273.               return 0;
  274.   
  275.           /* look it up (in the reduced search space) */
  276. !         if (islower(cmdbuf[0]))
  277. !             for (cmd = cmdhash[hash(cmdbuf[0])]; cmd != 0 && cmd->Name[0] == cmdbuf[0]; cmd++) {
  278.               if (strncmp(cmd->Name, cmdbuf, cmdlen) == 0) {
  279.                   if (strcmp(cmd->Name, cmdbuf) == 0)
  280.                       return (data_obj *) cmd;
  281. ***************
  282. *** 556,562 ****
  283.                   found++;
  284.                   which = cmd;
  285.               }
  286. !         }
  287.           if (found > 1)
  288.               complain("[\"%s\" ambiguous]", cmdbuf);
  289.           else if (found == 0)
  290. --- 563,569 ----
  291.                   found++;
  292.                   which = cmd;
  293.               }
  294. !             }
  295.           if (found > 1)
  296.               complain("[\"%s\" ambiguous]", cmdbuf);
  297.           else if (found == 0)
  298. ***************
  299. *** 565,581 ****
  300.               return (data_obj *) which;
  301.       } else {
  302.           static char    *strings[(sizeof commands) / sizeof (commands[0])];
  303. !         static int    beenhere = 0;
  304.           register int    com;
  305.   
  306. !         if (beenhere == 0) {
  307.               register char    **strs = strings;
  308. !             register struct cmd    *c = commands;
  309.   
  310. !             beenhere = 1;
  311. !             for (; c->Name; c++)
  312.                   *strs++ = c->Name;
  313.               *strs = 0;
  314.           }
  315.   
  316.           if ((com = complete(strings, prompt, CASEIND)) < 0)
  317. --- 572,588 ----
  318.               return (data_obj *) which;
  319.       } else {
  320.           static char    *strings[(sizeof commands) / sizeof (commands[0])];
  321. !         static int    beenhere = NO;
  322.           register int    com;
  323.   
  324. !         if (beenhere == NO) {
  325.               register char    **strs = strings;
  326. !             register struct cmd    *c;
  327.   
  328. !             for (c = commands; c->Name != 0; c++)
  329.                   *strs++ = c->Name;
  330.               *strs = 0;
  331. +             beenhere = YES;
  332.           }
  333.   
  334.           if ((com = complete(strings, prompt, CASEIND)) < 0)
  335. diff -c ojove/insert.c jove/insert.c
  336. *** ojove/insert.c    Thu Jul 16 09:14:25 1987
  337. --- jove/insert.c    Fri Jul 10 09:25:50 1987
  338. ***************
  339. *** 96,108 ****
  340.           incrmt = (tabstop - (dotcol % tabstop));
  341.           if (dotcol + incrmt > goal)
  342.               break;
  343. !         Insert('\t');
  344.           dotcol += incrmt;
  345.       }
  346.       if (dotcol != goal)
  347. !         DoTimes(Insert(' '), (goal - dotcol));
  348. !     exp_p = NO;
  349. !     exp = 1;
  350.   }
  351.   
  352.   SelfInsert()
  353. --- 96,106 ----
  354.           incrmt = (tabstop - (dotcol % tabstop));
  355.           if (dotcol + incrmt > goal)
  356.               break;
  357. !         insert_c('\t', 1);
  358.           dotcol += incrmt;
  359.       }
  360.       if (dotcol != goal)
  361. !         insert_c(' ', (goal - dotcol));
  362.   }
  363.   
  364.   SelfInsert()
  365. ***************
  366. *** 116,132 ****
  367.           register int    num,
  368.                   i;
  369.   
  370. !         for (i = 0, num = exp, exp = 1; i < num; i++) {
  371.               int    pos = calc_pos(linebuf, curchar);
  372.   
  373.               if (!eolp()) {
  374.                   if (linebuf[curchar] == '\t') {
  375.                       if ((pos + 1) == ((pos + tabstop) - (pos % tabstop)))
  376. !                         DelNChar();
  377.                   } else
  378. !                     DelNChar();
  379.               }
  380. !             Insert(LastKeyStruck);
  381.           }
  382.       } else
  383.           Insert(LastKeyStruck);
  384. --- 114,130 ----
  385.           register int    num,
  386.                   i;
  387.   
  388. !         for (i = 0, num = arg_value(); i < num; i++) {
  389.               int    pos = calc_pos(linebuf, curchar);
  390.   
  391.               if (!eolp()) {
  392.                   if (linebuf[curchar] == '\t') {
  393.                       if ((pos + 1) == ((pos + tabstop) - (pos % tabstop)))
  394. !                         del_char(FORWARD, 1);
  395.                   } else
  396. !                     del_char(FORWARD, 1);
  397.               }
  398. !             insert_c(LastKeyStruck, 1);
  399.           }
  400.       } else
  401.           Insert(LastKeyStruck);
  402. ***************
  403. *** 139,151 ****
  404.   
  405.   Insert(c)
  406.   {
  407. !     if (exp <= 0)
  408.           return;
  409.       modify();
  410.       makedirty(curline);
  411. !     ins_c(c, linebuf, curchar, exp, LBSIZE);
  412. !     IFixMarks(curline, curchar, curline, curchar + exp);
  413. !     curchar += exp;
  414.   }    
  415.   
  416.   /* Tab in to the right place for C mode */
  417. --- 137,155 ----
  418.   
  419.   Insert(c)
  420.   {
  421. !     insert_c(c, arg_value());
  422. ! }
  423. ! 
  424. ! /* insert character C N times at point */
  425. ! insert_c(c, n)
  426. ! {
  427. !     if (n <= 0)
  428.           return;
  429.       modify();
  430.       makedirty(curline);
  431. !     ins_c(c, linebuf, curchar, n, LBSIZE);
  432. !     IFixMarks(curline, curchar, curline, curchar + n);
  433. !     curchar += n;
  434.   }    
  435.   
  436.   /* Tab in to the right place for C mode */
  437. ***************
  438. *** 159,165 ****
  439.   
  440.           ToIndent();
  441.           if (dotchar > curchar)
  442. !             m = MakeMark(curline, dotchar, FLOATER);
  443.           (void) lisp_indent();
  444.           if (m) {
  445.               ToMark(m);
  446. --- 163,169 ----
  447.   
  448.           ToIndent();
  449.           if (dotchar > curchar)
  450. !             m = MakeMark(curline, dotchar, M_FLOATER);
  451.           (void) lisp_indent();
  452.           if (m) {
  453.               ToMark(m);
  454. ***************
  455. *** 177,191 ****
  456.   
  457.   QuotChar()
  458.   {
  459. !     int    c;
  460. !     extern int    alarmed;    /* If waitfor had to wait. */
  461.   
  462. !     c = waitchar();
  463. !     if (alarmed)
  464.           message(key_strokes);
  465. !     if (c == CTL(J))
  466. !         LineInsert(exp);
  467. !     else if (c != CTL(@))
  468.           Insert(c);
  469.   }
  470.   
  471. --- 181,195 ----
  472.   
  473.   QuotChar()
  474.   {
  475. !     int    c,
  476. !         slow;
  477.   
  478. !     c = waitchar(&slow);
  479. !     if (slow)
  480.           message(key_strokes);
  481. !     if (c == CTL('J'))
  482. !         LineInsert(arg_value());
  483. !     else if (c != CTL('@'))
  484.           Insert(c);
  485.   }
  486.   
  487. ***************
  488. *** 215,224 ****
  489.   #endif
  490.       SelfInsert();
  491.       if (MinorMode(ShowMatch) && !charp() && !in_macro()) {
  492. !         BackChar();    /* Back onto the ')' */
  493.           if ((int) bp == -1)
  494.               bp = m_paren(c, BACKWARD, NO, YES);
  495. !         ForChar();
  496.           if (bp != 0) {
  497.               nx = in_window(curwind, bp->p_line);
  498.               if (nx != -1) {        /* is visible */
  499. --- 219,228 ----
  500.   #endif
  501.       SelfInsert();
  502.       if (MinorMode(ShowMatch) && !charp() && !in_macro()) {
  503. !         b_char(1);    /* Back onto the ')' */
  504.           if ((int) bp == -1)
  505.               bp = m_paren(c, BACKWARD, NO, YES);
  506. !         f_char(1);
  507.           if (bp != 0) {
  508.               nx = in_window(curwind, bp->p_line);
  509.               if (nx != -1) {        /* is visible */
  510. ***************
  511. *** 264,279 ****
  512.   #ifdef LISP
  513.       if (MajorMode(LISPMODE))
  514.           DelWtSpace();
  515.   #endif
  516. !     else if (blnkp(linebuf))
  517.           DelWtSpace();
  518.           
  519.       /* If there is more than 2 blank lines in a row then don't make
  520.          a newline, just move down one. */
  521. !     if (exp == 1 && eolp() && TwoBlank())
  522.           SetLine(curline->l_next);
  523.       else
  524. !         LineInsert(exp);
  525.   
  526.       if (indentp)
  527.   #ifdef LISP
  528. --- 268,284 ----
  529.   #ifdef LISP
  530.       if (MajorMode(LISPMODE))
  531.           DelWtSpace();
  532. +     else
  533.   #endif
  534. !         if (blnkp(linebuf))
  535.           DelWtSpace();
  536.           
  537.       /* If there is more than 2 blank lines in a row then don't make
  538.          a newline, just move down one. */
  539. !     if (arg_value() == 1 && eolp() && TwoBlank())
  540.           SetLine(curline->l_next);
  541.       else
  542. !         LineInsert(arg_value());
  543.   
  544.       if (indentp)
  545.   #ifdef LISP
  546. ***************
  547. *** 292,298 ****
  548.       int    llen;
  549.   
  550.       if (*str == 0)
  551. !         return;    /* ain't nothing to insert! */
  552.       DOTsave(&save);
  553.       llen = strlen(linebuf);
  554.       while (c = *str++) {
  555. --- 297,303 ----
  556.       int    llen;
  557.   
  558.       if (*str == 0)
  559. !         return;        /* ain't nothing to insert! */
  560.       DOTsave(&save);
  561.       llen = strlen(linebuf);
  562.       while (c = *str++) {
  563. ***************
  564. *** 314,328 ****
  565.       makedirty(curline);
  566.   }
  567.   
  568. ! OpenLine()
  569.   {
  570.       Bufpos    dot;
  571.   
  572.       DOTsave(&dot);
  573. !     LineInsert(exp);    /* Open the lines... */
  574.       SetDot(&dot);
  575.   }
  576.   
  577.   /* Take the region FLINE/FCHAR to TLINE/TCHAR and insert it at
  578.      ATLINE/ATCHAR in WHATBUF. */
  579.   
  580. --- 319,338 ----
  581.       makedirty(curline);
  582.   }
  583.   
  584. ! open_lines(n)
  585.   {
  586.       Bufpos    dot;
  587.   
  588.       DOTsave(&dot);
  589. !     LineInsert(n);    /* Open the lines... */
  590.       SetDot(&dot);
  591.   }
  592.   
  593. + OpenLine()
  594. + {
  595. +     open_lines(arg_value());
  596. + }
  597. + 
  598.   /* Take the region FLINE/FCHAR to TLINE/TCHAR and insert it at
  599.      ATLINE/ATCHAR in WHATBUF. */
  600.   
  601. ***************
  602. *** 392,398 ****
  603.   
  604.       /* Now must find a recently killed region. */
  605.   
  606. !     if (exp < 0)
  607.           dir = 1;
  608.   
  609.       killptr += dir;
  610. --- 402,408 ----
  611.   
  612.       /* Now must find a recently killed region. */
  613.   
  614. !     if (arg_value() < 0)
  615.           dir = 1;
  616.   
  617.       killptr += dir;
  618. ***************
  619. *** 468,474 ****
  620.       }
  621.   }
  622.   
  623. ! static
  624.   newchunk()
  625.   {
  626.       register Line    *newline;
  627. --- 478,484 ----
  628.       }
  629.   }
  630.   
  631. ! private
  632.   newchunk()
  633.   {
  634.       register Line    *newline;
  635. ***************
  636. *** 520,526 ****
  637.   /* Remove the free lines, in chunk c, from the free list because they are
  638.      no longer free. */
  639.   
  640. ! static
  641.   remfreelines(c)
  642.   register struct chunk    *c;
  643.   {
  644. --- 530,536 ----
  645.   /* Remove the free lines, in chunk c, from the free list because they are
  646.      no longer free. */
  647.   
  648. ! private
  649.   remfreelines(c)
  650.   register struct chunk    *c;
  651.   {
  652. ***************
  653. *** 584,595 ****
  654.       DOTsave(&dot);
  655.       FSexpr();
  656.       DOTsave(&end);
  657. -     exp = 1;
  658.       SetDot(&dot);
  659.       for (;;) {
  660.           if (curline == end.p_line)
  661.               break;
  662. !         line_move(FORWARD, NO);
  663.           if (!blnkp(linebuf))
  664.               (void) lisp_indent();
  665.       }
  666. --- 594,604 ----
  667.       DOTsave(&dot);
  668.       FSexpr();
  669.       DOTsave(&end);
  670.       SetDot(&dot);
  671.       for (;;) {
  672.           if (curline == end.p_line)
  673.               break;
  674. !         line_move(FORWARD, 1, NO);
  675.           if (!blnkp(linebuf))
  676.               (void) lisp_indent();
  677.       }
  678. ***************
  679. *** 656,662 ****
  680.   
  681.       DOTsave(&savedot);
  682.       SetDot(bp);
  683. !     DoTimes(ForChar(), 1);
  684.       if (linebuf[curchar] != '(') {
  685.           register Word    *wp;
  686.   
  687. --- 665,671 ----
  688.   
  689.       DOTsave(&savedot);
  690.       SetDot(bp);
  691. !     f_char(1);
  692.       if (linebuf[curchar] != '(') {
  693.           register Word    *wp;
  694.   
  695. ***************
  696. *** 669,675 ****
  697.               int    c_char = curchar;
  698.   
  699.               WITH_TABLE(curbuf->b_major)
  700. !                 ForWord();
  701.               END_TABLE();
  702.               if (LookingAt("[ \t]*;\\|[ \t]*$", linebuf, curchar))
  703.                   curchar = c_char;
  704. --- 678,684 ----
  705.               int    c_char = curchar;
  706.   
  707.               WITH_TABLE(curbuf->b_major)
  708. !                 f_word(1);
  709.               END_TABLE();
  710.               if (LookingAt("[ \t]*;\\|[ \t]*$", linebuf, curchar))
  711.                   curchar = c_char;
  712. diff -c ojove/io.c jove/io.c
  713. *** ojove/io.c    Thu Jul 16 09:14:28 1987
  714. --- jove/io.c    Fri Jun 19 16:00:59 1987
  715. ***************
  716. *** 107,115 ****
  717.       }
  718.       DOTsave(&save);
  719.       dofread(fp);
  720. !     SetDot(&save);
  721. !     if (is_insert && io_chars > 0)
  722.           modify();
  723.       getDOT();
  724.       close_file(fp);
  725.   }
  726. --- 107,117 ----
  727.       }
  728.       DOTsave(&save);
  729.       dofread(fp);
  730. !     if (is_insert && io_chars > 0) {
  731.           modify();
  732. +         set_mark();
  733. +     }
  734. +     SetDot(&save);
  735.       getDOT();
  736.       close_file(fp);
  737.   }
  738. ***************
  739. *** 121,127 ****
  740.       int    xeof = 0;
  741.       Line    *savel = curline;
  742.       int    savec = curchar;
  743. !     disk_line    f_getputl() ;
  744.   
  745.       strcpy(end, linebuf + curchar);
  746.       xeof = f_gets(fp, linebuf + curchar, LBSIZE - curchar);
  747. --- 123,129 ----
  748.       int    xeof = 0;
  749.       Line    *savel = curline;
  750.       int    savec = curchar;
  751. !     extern disk_line    f_getputl();
  752.   
  753.       strcpy(end, linebuf + curchar);
  754.       xeof = f_gets(fp, linebuf + curchar, LBSIZE - curchar);
  755. ***************
  756. *** 157,169 ****
  757.   #ifndef CHDIR
  758.   
  759.   char *
  760. ! pr_name(fname)
  761.   char    *fname;
  762.   {
  763.       if (fname == 0)
  764.           return 0;
  765.   
  766. !     if (strncmp(fname, HomeDir, HomeLen) == 0) {
  767.           static char    name_buf[100];
  768.   
  769.           sprintf(name_buf, "~%s", fname + HomeLen);
  770. --- 159,171 ----
  771.   #ifndef CHDIR
  772.   
  773.   char *
  774. ! pr_name(fname, okay_home)
  775.   char    *fname;
  776.   {
  777.       if (fname == 0)
  778.           return 0;
  779.   
  780. !     if (okay_home == YES && strncmp(fname, HomeDir, HomeLen) == 0) {
  781.           static char    name_buf[100];
  782.   
  783.           sprintf(name_buf, "~%s", fname + HomeLen);
  784. ***************
  785. *** 188,194 ****
  786.   }
  787.   
  788.   char *
  789. ! pr_name(fname)
  790.   char    *fname;
  791.   {
  792.       int    n;
  793. --- 190,196 ----
  794.   }
  795.   
  796.   char *
  797. ! pr_name(fname, okay_home)
  798.   char    *fname;
  799.   {
  800.       int    n;
  801. ***************
  802. *** 201,207 ****
  803.           (fname[n] == '/'))
  804.           return fname + n + 1;
  805.   
  806. !     if (strcmp(HomeDir, "/") != 0 && strncmp(fname, HomeDir, HomeLen) == 0) {
  807.           static char    name_buf[100];
  808.   
  809.           sprintf(name_buf, "~%s", fname + HomeLen);
  810. --- 203,209 ----
  811.           (fname[n] == '/'))
  812.           return fname + n + 1;
  813.   
  814. !     if (okay_home == YES && strcmp(HomeDir, "/") != 0 && strncmp(fname, HomeDir, HomeLen) == 0) {
  815.           static char    name_buf[100];
  816.   
  817.           sprintf(name_buf, "~%s", fname + HomeLen);
  818. ***************
  819. *** 256,268 ****
  820.   
  821.   getCWD()
  822.   {
  823. !     char    *cwd = getenv("CWD");
  824.   #ifdef JOB_CONTROL
  825.       extern char    *getwd();
  826.       char    pathname[FILESIZE];
  827.   #endif
  828.   
  829.       if (cwd == 0)
  830.   #ifdef JOB_CONTROL
  831.           cwd = getwd(pathname);
  832.   #else
  833. --- 258,273 ----
  834.   
  835.   getCWD()
  836.   {
  837. !     char    *cwd;
  838.   #ifdef JOB_CONTROL
  839.       extern char    *getwd();
  840.       char    pathname[FILESIZE];
  841.   #endif
  842.   
  843. +     cwd = getenv("CWD");
  844.       if (cwd == 0)
  845. +         cwd = getenv("PWD");
  846. +     if (cwd == 0)
  847.   #ifdef JOB_CONTROL
  848.           cwd = getwd(pathname);
  849.   #else
  850. ***************
  851. *** 278,284 ****
  852.   
  853.       s_mess(": %f ");
  854.       for (i = DirSP; i >= 0; i--)
  855. !         add_mess("%s ", pr_name(DirStack[i]));
  856.   }
  857.   
  858.   prCWD()
  859. --- 283,289 ----
  860.   
  861.       s_mess(": %f ");
  862.       for (i = DirSP; i >= 0; i--)
  863. !         add_mess("%s ", pr_name(DirStack[i], YES));
  864.   }
  865.   
  866.   prCWD()
  867. ***************
  868. *** 339,344 ****
  869. --- 344,350 ----
  870.       return offset;
  871.   }
  872.   
  873. + private
  874.   dfollow(file, into)
  875.   char    *file,
  876.       *into;
  877. ***************
  878. *** 377,382 ****
  879. --- 383,389 ----
  880.   
  881.   #endif CHDIR
  882.   
  883. + private
  884.   get_hdir(user, buf)
  885.   register char    *user,
  886.           *buf;
  887. ***************
  888. *** 453,464 ****
  889.   
  890.   WrtReg()
  891.   {
  892. !     DoWriteReg(0);
  893.   }
  894.   
  895.   AppReg()
  896.   {
  897. !     DoWriteReg(1);
  898.   }
  899.   
  900.   int    CreatMode = DFLT_MODE;
  901. --- 460,471 ----
  902.   
  903.   WrtReg()
  904.   {
  905. !     DoWriteReg(NO);
  906.   }
  907.   
  908.   AppReg()
  909.   {
  910. !     DoWriteReg(YES);
  911.   }
  912.   
  913.   int    CreatMode = DFLT_MODE;
  914. ***************
  915. *** 474,480 ****
  916.       fname = ask_file((char *) 0, (char *) 0, fnamebuf);
  917.   
  918.   #ifdef BACKUPFILES
  919. !     if (!app) {
  920.           filemunge(fname);
  921.   
  922.           if (BkupOnWrite)
  923. --- 481,487 ----
  924.       fname = ask_file((char *) 0, (char *) 0, fnamebuf);
  925.   
  926.   #ifdef BACKUPFILES
  927. !     if (app == NO) {
  928.           filemunge(fname);
  929.   
  930.           if (BkupOnWrite)
  931. ***************
  932. *** 511,522 ****
  933.   
  934.       chk_mtime(curbuf, fname, "write");
  935.       filemunge(fname);
  936. !     curbuf->b_type = B_FILE;      /* In case it wasn't before. */
  937.       setfname(curbuf, fname);
  938.       file_write(fname, 0);
  939.       unmodify();
  940.   }
  941.   
  942.   File *
  943.   open_file(fname, buf, how, ifbad, loudness)
  944.   register char    *fname;
  945. --- 518,545 ----
  946.   
  947.       chk_mtime(curbuf, fname, "write");
  948.       filemunge(fname);
  949. !     curbuf->b_type = B_FILE;      /* in case it wasn't before */
  950.       setfname(curbuf, fname);
  951.       file_write(fname, 0);
  952.       unmodify();
  953.   }
  954.   
  955. + /* Open file FNAME supplying the buffer IO routine with buffer BUF.
  956. +    HOW is F_READ, F_WRITE or F_APPEND.  IFBAD == COMPLAIN means that
  957. +    if we fail at opening the file, call complain.  LOUDNESS says
  958. +    whether or not to print the "reading ..." message on the message
  959. +    line.
  960. + 
  961. +    NOTE:  This opens the pr_name(fname, NO) of fname.  That is, FNAME
  962. +       is usually an entire pathname, which can be slow when the
  963. +       pathname is long and there are lots of symbolic links along
  964. +       the way (which has become very common in my experience).  So,
  965. +       this speeds up opens file names in the local directory.  It
  966. +       will not speed up things like "../scm/foo.scm" simple because
  967. +       by the time we get here that's already been expanded to an
  968. +       absolute pathname.  But this is a start.
  969. +    */
  970. + 
  971.   File *
  972.   open_file(fname, buf, how, ifbad, loudness)
  973.   register char    *fname;
  974. ***************
  975. *** 529,535 ****
  976.       io_lines = 0;
  977.       tellall = loudness;
  978.   
  979. !     fp = f_open(fname, how, buf, LBSIZE);
  980.       if (fp == NIL) {
  981.                   message(IOerr((how == F_READ) ? "open" : "create", fname));
  982.           if (ifbad == COMPLAIN)
  983. --- 552,558 ----
  984.       io_lines = 0;
  985.       tellall = loudness;
  986.   
  987. !     fp = f_open(pr_name(fname, NO), how, buf, LBSIZE);
  988.       if (fp == NIL) {
  989.                   message(IOerr((how == F_READ) ? "open" : "create", fname));
  990.           if (ifbad == COMPLAIN)
  991. ***************
  992. *** 537,547 ****
  993.       } else {
  994.           int    readonly = FALSE;
  995.   
  996. !         if (access(fname, W_OK) == -1 && errno != ENOENT)
  997.               readonly = TRUE;
  998.                                
  999.           if (loudness != QUIET)
  1000. !             f_mess("\"%s\"%s", pr_name(fname),
  1001.                      readonly ? " [Read only]" : NullStr);
  1002.       }
  1003.       return fp;
  1004. --- 560,570 ----
  1005.       } else {
  1006.           int    readonly = FALSE;
  1007.   
  1008. !         if (access(pr_name(fname, NO), W_OK) == -1 && errno != ENOENT)
  1009.               readonly = TRUE;
  1010.                                
  1011.           if (loudness != QUIET)
  1012. !             f_mess("\"%s\"%s", pr_name(fname, YES),
  1013.                      readonly ? " [Read only]" : NullStr);
  1014.       }
  1015.       return fp;
  1016. ***************
  1017. *** 552,559 ****
  1018.      doing.
  1019.   
  1020.      I hate to use another stat(), but to use confirm we gotta
  1021. !    do this before we open the file. */
  1022.   
  1023.   chk_mtime(thisbuf, fname, how)
  1024.   Buffer    *thisbuf;
  1025.   char    *fname,
  1026. --- 575,586 ----
  1027.      doing.
  1028.   
  1029.      I hate to use another stat(), but to use confirm we gotta
  1030. !    do this before we open the file.
  1031.   
  1032. +    NOTE: This stats FNAME after converting it to a path-relative
  1033. +      name.  I can't see why this would cause a problem ...
  1034. +    */
  1035. + 
  1036.   chk_mtime(thisbuf, fname, how)
  1037.   Buffer    *thisbuf;
  1038.   char    *fname,
  1039. ***************
  1040. *** 566,577 ****
  1041.       if ((thisbuf->b_mtime != 0) &&        /* if we care ... */
  1042.           (b = file_exists(fname)) &&        /* we already have this file */
  1043.           (b == thisbuf) &&            /* and it's the current buffer */
  1044. !         (stat(fname, &stbuf) != -1) &&    /* and we can stat it */
  1045.           (stbuf.st_mtime != b->b_mtime)) {    /* and there's trouble. */
  1046.               rbell();
  1047.           redisplay();    /* Ring that bell! */
  1048.               TOstart("Warning", TRUE);
  1049. !             Typeout("\"%s\" now saved on disk is not what you last", pr_name(fname));
  1050.           Typeout("visited or saved.  Probably someone else is editing");
  1051.           Typeout("your file at the same time.");
  1052.               if (how) {
  1053. --- 593,604 ----
  1054.       if ((thisbuf->b_mtime != 0) &&        /* if we care ... */
  1055.           (b = file_exists(fname)) &&        /* we already have this file */
  1056.           (b == thisbuf) &&            /* and it's the current buffer */
  1057. !         (stat(pr_name(fname, NO), &stbuf) != -1) &&    /* and we can stat it */
  1058.           (stbuf.st_mtime != b->b_mtime)) {    /* and there's trouble. */
  1059.               rbell();
  1060.           redisplay();    /* Ring that bell! */
  1061.               TOstart("Warning", TRUE);
  1062. !             Typeout("\"%s\" now saved on disk is not what you last", pr_name(fname, YES));
  1063.           Typeout("visited or saved.  Probably someone else is editing");
  1064.           Typeout("your file at the same time.");
  1065.               if (how) {
  1066. ***************
  1067. *** 626,632 ****
  1068.           for (;;) {
  1069.               rbell();
  1070.               y_or_n = ask(NullStr, "Shall I make your changes to \"%s\" permanent? ", curbuf->b_name);
  1071. !             c = Upper(*y_or_n);
  1072.               if (c == 'Y' || c == 'N')
  1073.                   break;
  1074.           }            
  1075. --- 653,659 ----
  1076.           for (;;) {
  1077.               rbell();
  1078.               y_or_n = ask(NullStr, "Shall I make your changes to \"%s\" permanent? ", curbuf->b_name);
  1079. !             c = CharUpcase(*y_or_n);
  1080.               if (c == 'Y' || c == 'N')
  1081.                   break;
  1082.           }            
  1083. ***************
  1084. *** 658,664 ****
  1085.   
  1086.   private int    nleft,    /* number of good characters left in current block */
  1087.           tmpfd = -1;
  1088. ! private disk_line    DFree = 1;
  1089.               /* pointer to end of tmp file */
  1090.   private char    *tfname;
  1091.   
  1092. --- 685,691 ----
  1093.   
  1094.   private int    nleft,    /* number of good characters left in current block */
  1095.           tmpfd = -1;
  1096. ! disk_line    DFree = 1;
  1097.               /* pointer to end of tmp file */
  1098.   private char    *tfname;
  1099.   
  1100. ***************
  1101. *** 682,691 ****
  1102.       (void) unlink(tfname);
  1103.   }
  1104.   
  1105. ! /* Get a line at `tl' in the tmp file into `buf' which should be LBSIZE
  1106. !    long. */
  1107.   
  1108. ! int    Jr_Len;        /* Length of Just Read Line. */
  1109.   private char    *getblock();
  1110.   
  1111.   getline(addr, buf)
  1112. --- 709,718 ----
  1113.       (void) unlink(tfname);
  1114.   }
  1115.   
  1116. ! /* get a line at `tl' in the tmp file into `buf' which should be LBSIZE
  1117. !    long */
  1118.   
  1119. ! int    Jr_Len;        /* length of Just Read Line */
  1120.   private char    *getblock();
  1121.   
  1122.   getline(addr, buf)
  1123. diff -c ojove/iproc-pipes.c jove/iproc-pipes.c
  1124. *** ojove/iproc-pipes.c    Thu Jul 16 09:14:30 1987
  1125. --- jove/iproc-pipes.c    Thu Jun 25 10:02:30 1987
  1126. ***************
  1127. *** 13,20 ****
  1128.   #include <signal.h>
  1129.   #include <sgtty.h>
  1130.   
  1131. - typedef struct process    Process;
  1132. - 
  1133.   #define DEAD    1    /* Dead but haven't informed user yet */
  1134.   #define STOPPED    2    /* Job stopped */
  1135.   #define RUNNING    3    /* Just running */
  1136. --- 13,18 ----
  1137. ***************
  1138. *** 25,30 ****
  1139. --- 23,29 ----
  1140.   #define KILLED    2
  1141.   
  1142.   #define isdead(p)    (p == 0 || proc_state(p) == DEAD || p->p_toproc == -1)
  1143. + #define makedead(p)    (proc_state(p) = DEAD)
  1144.   
  1145.   #define proc_buf(p)    (p->p_buffer->b_name)
  1146.   #define proc_cmd(p)    (p->p_name)
  1147. ***************
  1148. *** 36,42 ****
  1149.       ProcOutput,
  1150.       NumProcs = 0;
  1151.   
  1152. ! static char *
  1153.   pstate(p)
  1154.   Process    *p;
  1155.   {
  1156. --- 35,41 ----
  1157.       ProcOutput,
  1158.       NumProcs = 0;
  1159.   
  1160. ! char *
  1161.   pstate(p)
  1162.   Process    *p;
  1163.   {
  1164. ***************
  1165. *** 54,65 ****
  1166.           if (p->p_howdied == EXITED) {
  1167.               if (p->p_reason == 0)
  1168.                   return "Done";
  1169. !             return sprint("[Exit %d]", p->p_reason);
  1170.           }
  1171. !         return sprint("[Killed %d]", p->p_reason);
  1172.   
  1173.       default:
  1174. !         return "Unknown state.";
  1175.       }
  1176.   }
  1177.   
  1178. --- 53,64 ----
  1179.           if (p->p_howdied == EXITED) {
  1180.               if (p->p_reason == 0)
  1181.                   return "Done";
  1182. !             return sprint("Exit %d", p->p_reason);
  1183.           }
  1184. !         return sprint("Killed %d", p->p_reason);
  1185.   
  1186.       default:
  1187. !         return "Unknown state";
  1188.       }
  1189.   }
  1190.   
  1191. ***************
  1192. *** 98,104 ****
  1193.               finish(1);
  1194.           read_proc(header.pid, header.nbytes);
  1195.       }
  1196. -     redisplay();
  1197.       here = 0;
  1198.       sigrelse(SIGCHLD);
  1199.   }
  1200. --- 97,102 ----
  1201. ***************
  1202. *** 126,132 ****
  1203.       }
  1204.   
  1205.       if (nbytes == EOF) {        /* Okay to clean up this process */
  1206. !         p->p_eof = 1;
  1207.           NumProcs--;    /* As far as getch() in main is concerned */
  1208.           return;
  1209.       }
  1210. --- 124,130 ----
  1211.       }
  1212.   
  1213.       if (nbytes == EOF) {        /* Okay to clean up this process */
  1214. !         proc_close(p);
  1215.           NumProcs--;    /* As far as getch() in main is concerned */
  1216.           return;
  1217.       }
  1218. ***************
  1219. *** 155,166 ****
  1220.       proc_kill(curbuf->b_process, SIGQUIT);
  1221.   }
  1222.   
  1223. ! static
  1224.   proc_close(p)
  1225.   Process    *p;
  1226.   {
  1227.       (void) close(p->p_toproc);
  1228. !     p->p_toproc = -1;    /* Writes will fail. */
  1229.   }
  1230.   
  1231.   do_rtp(mp)
  1232. --- 153,164 ----
  1233.       proc_kill(curbuf->b_process, SIGQUIT);
  1234.   }
  1235.   
  1236. ! private
  1237.   proc_close(p)
  1238.   Process    *p;
  1239.   {
  1240.       (void) close(p->p_toproc);
  1241. !     p->p_toproc = -1;    /* writes will fail */
  1242.   }
  1243.   
  1244.   do_rtp(mp)
  1245. ***************
  1246. *** 228,234 ****
  1247.           (void) dup2(ProcOutput, 1);
  1248.           (void) dup2(ProcOutput, 2);
  1249.           pclose(toproc);
  1250. !         execv(Portsrv, args);
  1251.           printf("Execl failed.\n");
  1252.           _exit(1);
  1253.       }
  1254. --- 226,232 ----
  1255.           (void) dup2(ProcOutput, 1);
  1256.           (void) dup2(ProcOutput, 2);
  1257.           pclose(toproc);
  1258. !         execv(Portsrv, argv);
  1259.           printf("Execl failed.\n");
  1260.           _exit(1);
  1261.       }
  1262. ***************
  1263. *** 260,270 ****
  1264.       /* Pop_wind() after everything is set up; important!
  1265.          Bindings won't work right unless newbuf->b_process is already
  1266.          set up BEFORE NEWBUF is first SetBuf()'d. */
  1267. !     newp->p_mark = MakeMark(curline, curchar, FLOATER);
  1268.   
  1269.       newp->p_toproc = toproc[1];
  1270.       newp->p_reason = 0;
  1271. -     newp->p_eof = 0;
  1272.       NumProcs++;
  1273.       (void) close(toproc[0]);
  1274.       sigrelse(SIGCHLD);
  1275. --- 258,267 ----
  1276.       /* Pop_wind() after everything is set up; important!
  1277.          Bindings won't work right unless newbuf->b_process is already
  1278.          set up BEFORE NEWBUF is first SetBuf()'d. */
  1279. !     newp->p_mark = MakeMark(curline, curchar, M_FLOATER);
  1280.   
  1281.       newp->p_toproc = toproc[1];
  1282.       newp->p_reason = 0;
  1283.       NumProcs++;
  1284.       (void) close(toproc[0]);
  1285.       sigrelse(SIGCHLD);
  1286. diff -c ojove/iproc-ptys.c jove/iproc-ptys.c
  1287. *** ojove/iproc-ptys.c    Thu Jul 16 09:14:31 1987
  1288. --- jove/iproc-ptys.c    Thu Jun 25 10:01:44 1987
  1289. ***************
  1290. *** 12,17 ****
  1291. --- 12,18 ----
  1292.   #endif
  1293.   #include <signal.h>
  1294.   #include <sgtty.h>
  1295. + #include <errno.h>
  1296.   
  1297.   #define DEAD    1    /* Dead but haven't informed user yet */
  1298.   #define STOPPED    2    /* Job stopped */
  1299. ***************
  1300. *** 23,28 ****
  1301. --- 24,30 ----
  1302.   #define KILLED    2
  1303.   
  1304.   #define isdead(p)    (p == 0 || proc_state(p) == DEAD || p->p_fd == -1)
  1305. + #define makedead(p)    (proc_state(p) = DEAD)
  1306.   
  1307.   #define proc_buf(p)    (p->p_buffer->b_name)
  1308.   #define proc_cmd(p)    (p->p_name)
  1309. ***************
  1310. *** 45,51 ****
  1311.       extern struct ltchars ls1;
  1312.   #endif
  1313.   
  1314. ! static char *
  1315.   pstate(p)
  1316.   Process    *p;
  1317.   {
  1318. --- 47,53 ----
  1319.       extern struct ltchars ls1;
  1320.   #endif
  1321.   
  1322. ! char *
  1323.   pstate(p)
  1324.   Process    *p;
  1325.   {
  1326. ***************
  1327. *** 60,71 ****
  1328.           if (p->p_howdied == EXITED) {
  1329.               if (p->p_reason == 0)
  1330.                   return "Done";
  1331. !             return sprint("exit(%d)", p->p_reason);
  1332.           }
  1333. !         return sprint("Killed(%d)", p->p_reason);
  1334.   
  1335.       default:
  1336. !         return "Unknown state.";
  1337.       }
  1338.   }
  1339.   
  1340. --- 62,73 ----
  1341.           if (p->p_howdied == EXITED) {
  1342.               if (p->p_reason == 0)
  1343.                   return "Done";
  1344. !             return sprint("Exit %d", p->p_reason);
  1345.           }
  1346. !         return sprint("Killed %d", p->p_reason);
  1347.   
  1348.       default:
  1349. !         return "Unknown state";
  1350.       }
  1351.   }
  1352.   
  1353. ***************
  1354. *** 98,111 ****
  1355.       }
  1356.   
  1357.       n = read(fd, ibuf, sizeof(ibuf) - 1);
  1358. !     if (n == 0) {
  1359. !         proc_close(p);
  1360. !         NumProcs--;
  1361.           return;
  1362.       }
  1363.       ibuf[n] = '\0';
  1364.       proc_rec(p, ibuf);
  1365. -     redisplay();
  1366.   }
  1367.   
  1368.   ProcKill()
  1369. --- 100,123 ----
  1370.       }
  1371.   
  1372.       n = read(fd, ibuf, sizeof(ibuf) - 1);
  1373. !     /* NOTE: This read somethings returns -1 when it's the first time
  1374. !        we're reading the socket.  Errno was set to I/O error or something
  1375. !        bizarre like that.  So, I'm choosing to ignore this.  I ignored
  1376. !        it before, and what happened was random text was being inserted
  1377. !        at the beginning of the buffer because the ibuf[n] = '\0' wasn't
  1378. !         working right (ibuf[-1] = '\0'). */
  1379. !     if (n == -1 && errno == EIO)
  1380.           return;
  1381. +     if (n <= 0) {
  1382. +         if (n == 0) {
  1383. +             makedead(p);
  1384. +             return;
  1385. +         }
  1386. +         sprintf(ibuf, "\n[pty read error: %d]\n", errno);
  1387. +         n = strlen(ibuf);
  1388.       }
  1389.       ibuf[n] = '\0';
  1390.       proc_rec(p, ibuf);
  1391.   }
  1392.   
  1393.   ProcKill()
  1394. ***************
  1395. *** 171,183 ****
  1396.       (void) write(p->p_fd, &c, 1);
  1397.   }
  1398.   
  1399. ! static
  1400.   proc_close(p)
  1401.   Process *p;
  1402.   {
  1403.       (void) close(p->p_fd);
  1404.       global_fd &= ~(1 << p->p_fd);
  1405. -     p->p_eof++;
  1406.   }
  1407.   
  1408.   do_rtp(mp)
  1409. --- 183,194 ----
  1410.       (void) write(p->p_fd, &c, 1);
  1411.   }
  1412.   
  1413. ! private
  1414.   proc_close(p)
  1415.   Process *p;
  1416.   {
  1417.       (void) close(p->p_fd);
  1418.       global_fd &= ~(1 << p->p_fd);
  1419.   }
  1420.   
  1421.   do_rtp(mp)
  1422. ***************
  1423. *** 216,222 ****
  1424.       va_list    ap;
  1425.       char    *argv[32],
  1426.           *cp;
  1427. !     Window *owind    = curwind;
  1428.       int    pid;
  1429.       Process    *newp;
  1430.       Buffer     *newbuf;
  1431. --- 227,233 ----
  1432.       va_list    ap;
  1433.       char    *argv[32],
  1434.           *cp;
  1435. !     Window *owind = curwind;
  1436.       int    pid;
  1437.       Process    *newp;
  1438.       Buffer     *newbuf;
  1439. ***************
  1440. *** 348,354 ****
  1441.   
  1442.       newp->p_fd = ttyfd;
  1443.       newp->p_pid = pid;
  1444. -     newp->p_eof = 0;
  1445.   
  1446.       newbuf = do_select((Window *) 0, bufname);
  1447.       newbuf->b_type = B_PROCESS;
  1448. --- 359,364 ----
  1449. ***************
  1450. *** 371,377 ****
  1451.       newp->p_name = copystr(cmdbuf);
  1452.       newp->p_state = RUNNING;
  1453.       newp->p_reason = 0;
  1454. !     newp->p_mark = MakeMark(curline, curchar, FLOATER);
  1455.   
  1456.       newp->p_next = procs;
  1457.       procs = newp;
  1458. --- 381,387 ----
  1459.       newp->p_name = copystr(cmdbuf);
  1460.       newp->p_state = RUNNING;
  1461.       newp->p_reason = 0;
  1462. !     newp->p_mark = MakeMark(curline, curchar, M_FLOATER);
  1463.   
  1464.       newp->p_next = procs;
  1465.       procs = newp;
  1466. diff -c ojove/iproc.c jove/iproc.c
  1467. *** ojove/iproc.c    Thu Jul 16 09:14:32 1987
  1468. --- jove/iproc.c    Wed Jun 24 12:52:13 1987
  1469. ***************
  1470. *** 30,36 ****
  1471.           if (!isdead(p)) {
  1472.               if (killem == -1) {
  1473.                   yorn = ask("y", "Should I kill your i-processes? ");
  1474. !                 killem = (Upper(*yorn) == 'Y');
  1475.               }
  1476.               if (killem)
  1477.                   proc_kill(p, SIGKILL);
  1478. --- 30,36 ----
  1479.           if (!isdead(p)) {
  1480.               if (killem == -1) {
  1481.                   yorn = ask("y", "Should I kill your i-processes? ");
  1482. !                 killem = (CharUpcase(*yorn) == 'Y');
  1483.               }
  1484.               if (killem)
  1485.                   proc_kill(p, SIGKILL);
  1486. ***************
  1487. *** 50,56 ****
  1488.   /* Process receive: receives the characters in buf, and appends them to
  1489.      the buffer associated with p. */
  1490.   
  1491. ! static
  1492.   proc_rec(p, buf)
  1493.   register Process    *p;
  1494.   char    *buf;
  1495. --- 50,56 ----
  1496.   /* Process receive: receives the characters in buf, and appends them to
  1497.      the buffer associated with p. */
  1498.   
  1499. ! private
  1500.   proc_rec(p, buf)
  1501.   register Process    *p;
  1502.   char    *buf;
  1503. ***************
  1504. *** 68,88 ****
  1505.       if (w != 0)
  1506.           do_disp = (in_window(w, p->p_mark->m_line) != -1);
  1507.       SetBuf(p->p_buffer);
  1508. !     savepoint = MakeMark(curline, curchar, FLOATER);
  1509. !     ToMark(p->p_mark);    /* Where output last stopped. */
  1510.       if (savepoint->m_line == curline && savepoint->m_char == curchar)
  1511.           sameplace++;
  1512.   
  1513.       ins_str(buf, YES);
  1514.       if (do_disp) {
  1515.           w->w_line = curline;
  1516.           w->w_char = curchar;
  1517.           redisplay();
  1518.       }
  1519. -     MarkSet(p->p_mark, curline, curchar);
  1520. -     if (!sameplace)
  1521. -         ToMark(savepoint);    /* Back to where we were. */
  1522. -     DelMark(savepoint);
  1523.       SetBuf(saveb);
  1524.   }
  1525.   
  1526. --- 68,91 ----
  1527.       if (w != 0)
  1528.           do_disp = (in_window(w, p->p_mark->m_line) != -1);
  1529.       SetBuf(p->p_buffer);
  1530. !     savepoint = MakeMark(curline, curchar, M_FLOATER);
  1531. !     ToMark(p->p_mark);        /* where output last stopped */
  1532.       if (savepoint->m_line == curline && savepoint->m_char == curchar)
  1533.           sameplace++;
  1534.   
  1535.       ins_str(buf, YES);
  1536. +     MarkSet(p->p_mark, curline, curchar);
  1537. +     if (!sameplace)
  1538. +         ToMark(savepoint);    /* back to where we were */
  1539. +     DelMark(savepoint);
  1540. +     /* redisplay now, instead of right after the ins_str, so that
  1541. +        we don't get a bouncing effect if point is not the same as
  1542. +        the process output position */
  1543.       if (do_disp) {
  1544.           w->w_line = curline;
  1545.           w->w_char = curchar;
  1546.           redisplay();
  1547.       }
  1548.       SetBuf(saveb);
  1549.   }
  1550.   
  1551. ***************
  1552. *** 95,105 ****
  1553.           s_mess("Cannot kill %s!", proc_buf(p));
  1554.   }
  1555.   
  1556. ! /* Deal with a process' death.  proc_rec turns on the FREEUP bit when it
  1557. !    it gets the "EOF" from portsrv.  FREEUP'd processes get unlinked from
  1558. !    the list, and the proc stucture and proc_buf(p) get free'd up, here. */
  1559.   
  1560. - private
  1561.   DealWDeath()
  1562.   {
  1563.       register Process    *p,
  1564. --- 98,107 ----
  1565.           s_mess("Cannot kill %s!", proc_buf(p));
  1566.   }
  1567.   
  1568. ! /* Deal with a process' death.  Go through all processes and find
  1569. !    the ones which have gotten EOF.  Delete them from the list and
  1570. !    free up the memory, and insert a status string. */
  1571.   
  1572.   DealWDeath()
  1573.   {
  1574.       register Process    *p,
  1575. ***************
  1576. *** 108,114 ****
  1577.       
  1578.       for (p = procs; p != 0; p = next) {
  1579.           next = p->p_next;
  1580. !         if (!p->p_eof) {
  1581.               prev = p;
  1582.               continue;
  1583.           }
  1584. --- 110,116 ----
  1585.       
  1586.       for (p = procs; p != 0; p = next) {
  1587.           next = p->p_next;
  1588. !         if (p->p_state != DEAD) {
  1589.               prev = p;
  1590.               continue;
  1591.           }
  1592. ***************
  1593. *** 130,135 ****
  1594. --- 132,138 ----
  1595.       char    *fmt = "%-15s  %-15s  %-8s %s",
  1596.           pidstr[10];
  1597.   
  1598. +     DealWDeath();
  1599.       if (procs == 0) {
  1600.           message("[No subprocesses]");
  1601.           return;
  1602. ***************
  1603. *** 142,148 ****
  1604.           sprintf(pidstr, "%d", p->p_pid);
  1605.           Typeout(fmt, proc_buf(p), pstate(p), pidstr, p->p_name);
  1606.       }
  1607. -     DealWDeath();
  1608.       TOstop();
  1609.   }
  1610.   
  1611. --- 145,150 ----
  1612. ***************
  1613. *** 160,168 ****
  1614. --- 162,193 ----
  1615.   SendData(newlinep)
  1616.   {
  1617.       register Process    *p = curbuf->b_process;
  1618. +     register char    *lp,
  1619. +             *gp;    /* JF fix for better prompt handling */
  1620.   
  1621.       if (isdead(p))
  1622.           return;
  1623. +     /* If the process mark was involved in a big deletion, because
  1624. +        the user hit ^W or something, then let's do some magic with
  1625. +        the process mark.  Problem is that if the user yanks back the
  1626. +        text he deleted, the mark stays at the beginning of the region,
  1627. +        and so the next time SendData() is called the entire region
  1628. +        will be sent.  That's not good.  So, to deal with that we reset
  1629. +        the mark to the last line, after skipping over the prompt, etc. */
  1630. +     if (p->p_mark->m_flags & M_BIG_DELETE) {
  1631. +         Bufpos    bp;
  1632. + 
  1633. +         p->p_mark->m_flags &= ~M_BIG_DELETE;
  1634. + 
  1635. +         DOTsave(&bp);
  1636. +         ToLast();
  1637. +         Bol();
  1638. +         while (LookingAt(proc_prompt, linebuf, curchar))
  1639. +             SetDot(dosearch(proc_prompt, 1, 1));
  1640. +         MarkSet(p->p_mark, curline, curchar);
  1641. +         SetDot(&bp);
  1642. +     }
  1643. + 
  1644.       if (lastp(curline)) {
  1645.           Eol();
  1646.           if (newlinep)
  1647. ***************
  1648. *** 174,181 ****
  1649.           while (LookingAt(proc_prompt, linebuf, curchar))
  1650.               SetDot(dosearch(proc_prompt, 1, 1));
  1651.           strcpy(genbuf, linebuf + curchar);
  1652. !         ToLast();
  1653. !         ins_str(genbuf, NO);
  1654.       }
  1655.   }
  1656.   
  1657. --- 199,210 ----
  1658.           while (LookingAt(proc_prompt, linebuf, curchar))
  1659.               SetDot(dosearch(proc_prompt, 1, 1));
  1660.           strcpy(genbuf, linebuf + curchar);
  1661. !         Eof();
  1662. !         gp = genbuf;
  1663. !         lp = linebuf;
  1664. !         while (*lp == *gp && *lp != '\0')
  1665. !             lp++, gp++;
  1666. !         ins_str(gp, NO);
  1667.       }
  1668.   }
  1669.   
  1670. ***************
  1671. *** 222,233 ****
  1672.   register int    pid;
  1673.   union wait    w;
  1674.   {
  1675. -     char    str[128];
  1676.       register Process    *child;
  1677.   
  1678.       if ((child = proc_pid(pid)) == 0)
  1679.           return;
  1680.   
  1681.       if (WIFSTOPPED(w))
  1682.           child->p_state = STOPPED;
  1683.       else {
  1684. --- 251,262 ----
  1685.   register int    pid;
  1686.   union wait    w;
  1687.   {
  1688.       register Process    *child;
  1689.   
  1690.       if ((child = proc_pid(pid)) == 0)
  1691.           return;
  1692.   
  1693. +     UpdModLine = YES;        /* we're changing state ... */
  1694.       if (WIFSTOPPED(w))
  1695.           child->p_state = STOPPED;
  1696.       else {
  1697. ***************
  1698. *** 238,249 ****
  1699.               child->p_reason = w.w_termsig;
  1700.               child->p_howdied = KILLED;
  1701.           }
  1702. !         proc_close(child);
  1703.       }
  1704. -     sprintf(str, "[Process %s: %s]\n",
  1705. -         proc_cmd(child),
  1706. -         pstate(child));
  1707. -     proc_rec(child, str);
  1708.   }
  1709.   
  1710.   /* Push/pod process bindings.  I openly acknowledge that this is a
  1711. --- 267,286 ----
  1712.               child->p_reason = w.w_termsig;
  1713.               child->p_howdied = KILLED;
  1714.           }
  1715. !         {
  1716. !             Buffer    *save = curbuf;
  1717. !             char    mesg[128];
  1718. ! 
  1719. !             /* insert status message now */
  1720. !             sprintf(mesg, "[Process %s: %s]\n",
  1721. !                 proc_cmd(child),
  1722. !                 pstate(child));
  1723. !             SetBuf(child->p_buffer);
  1724. !             ins_str(mesg, NO);
  1725. !             SetBuf(save);
  1726. !             redisplay();
  1727. !         }
  1728.       }
  1729.   }
  1730.   
  1731.   /* Push/pod process bindings.  I openly acknowledge that this is a
  1732. diff -c ojove/jove.c jove/jove.c
  1733. *** ojove/jove.c    Thu Jul 16 09:14:35 1987
  1734. --- jove/jove.c    Fri Jul 10 09:25:50 1987
  1735. ***************
  1736. *** 20,27 ****
  1737.   #include <sgtty.h>
  1738.   #else
  1739.   #include <termio.h>
  1740. - #endif SYSV
  1741.   #include <fcntl.h>
  1742.   
  1743.   #ifdef TIOCSLTC
  1744.   struct ltchars    ls1,
  1745. --- 20,27 ----
  1746.   #include <sgtty.h>
  1747.   #else
  1748.   #include <termio.h>
  1749.   #include <fcntl.h>
  1750. + #endif SYSV
  1751.   
  1752.   #ifdef TIOCSLTC
  1753.   struct ltchars    ls1,
  1754. ***************
  1755. *** 62,71 ****
  1756.       int    CoreDump = (code != 0 && code != SIGHUP),
  1757.           DelTmps = 1;        /* Usually we delete them. */
  1758.   
  1759. - #ifdef LSRHS
  1760. -     if (CoreDump)
  1761. -         setdump(1);
  1762. - #endif
  1763.       if (code == SIGINT) {
  1764.           char    c;
  1765.   
  1766. --- 62,67 ----
  1767. ***************
  1768. *** 106,114 ****
  1769.       if (CoreDump)
  1770.           abort();
  1771.   #ifdef PROFILING
  1772. !     exit(exp_p);
  1773.   #else
  1774. !     _exit(exp_p);
  1775.   #endif
  1776.   }
  1777.   
  1778. --- 102,110 ----
  1779.       if (CoreDump)
  1780.           abort();
  1781.   #ifdef PROFILING
  1782. !     exit(0);
  1783.   #else
  1784. !     _exit(0);
  1785.   #endif
  1786.   }
  1787.   
  1788. ***************
  1789. *** 137,143 ****
  1790.       }
  1791.       if (fcntl(fd, F_SETFL, on ? blockf : nonblockf) == -1)
  1792.       finish(SIGHUP);
  1793. -     return;
  1794.   }
  1795.   #endif SYSV
  1796.   
  1797. --- 133,138 ----
  1798. ***************
  1799. *** 399,405 ****
  1800.   }
  1801.   
  1802.   int    OKXonXoff = 0,        /* ^S and ^Q initially DON'T work */
  1803. !     IntChar = CTL(]);
  1804.   
  1805.   ttsize()
  1806.   {
  1807. --- 394,400 ----
  1808.   }
  1809.   
  1810.   int    OKXonXoff = 0,        /* ^S and ^Q initially DON'T work */
  1811. !     IntChar = CTL(']');
  1812.   
  1813.   ttsize()
  1814.   {
  1815. ***************
  1816. *** 500,505 ****
  1817. --- 495,502 ----
  1818.       TABS = !((sg1.c_oflag & TAB3) == TAB3);
  1819.       ospeed = sg1.c_cflag & CBAUD;
  1820.   
  1821. +     if (OKXonXoff)
  1822. +         sg2.c_iflag &= ~(IXON | IXOFF);
  1823.       sg2.c_iflag &= ~(INLCR|ICRNL|IGNCR);
  1824.       sg2.c_lflag &= ~(ISIG|ICANON|ECHO);
  1825.       sg2.c_oflag &= ~(OCRNL|ONLCR);
  1826. ***************
  1827. *** 584,591 ****
  1828.   
  1829.       if (cp == 0) {
  1830.           rbell();
  1831. !         exp = 1;
  1832. !         exp_p = errormsg = NO;
  1833.           message(NullStr);
  1834.       } else
  1835.           ExecCmd(cp);
  1836. --- 581,588 ----
  1837.   
  1838.       if (cp == 0) {
  1839.           rbell();
  1840. !         clr_arg_value();
  1841. !         errormsg = NO;
  1842.           message(NullStr);
  1843.       } else
  1844.           ExecCmd(cp);
  1845. ***************
  1846. *** 662,668 ****
  1847.   
  1848.   dorecover()
  1849.   {
  1850. !     execl(Recover, "jove_recover", "-d", TmpFilePath, (char *)0);
  1851.       printf("%s: execl failed!\n", Recover);
  1852.       flusho();
  1853.       _exit(-1);
  1854. --- 659,665 ----
  1855.   
  1856.   dorecover()
  1857.   {
  1858. !     execl(Recover, "jove_recover", "-d", TmpFilePath, (char *) 0);
  1859.       printf("%s: execl failed!\n", Recover);
  1860.       flusho();
  1861.       _exit(-1);
  1862. ***************
  1863. *** 721,727 ****
  1864.               case 't':
  1865.                   ++argv;
  1866.                   --argc;
  1867. -                 exp_p = YES;
  1868.                   find_tag(argv[1], YES);
  1869.                   break;
  1870.   
  1871. --- 718,723 ----
  1872. ***************
  1873. *** 812,818 ****
  1874.       Mark    *m;
  1875.   
  1876.       sprintf(bname, "%s", curbuf->b_name);
  1877. !     m = MakeMark(curline, curchar, FLOATER);
  1878.   
  1879.       RecDepth++;
  1880.       UpdModLine++;
  1881. --- 808,814 ----
  1882.       Mark    *m;
  1883.   
  1884.       sprintf(bname, "%s", curbuf->b_name);
  1885. !     m = MakeMark(curline, curchar, M_FLOATER);
  1886.   
  1887.       RecDepth++;
  1888.       UpdModLine++;
  1889. ***************
  1890. *** 820,826 ****
  1891.       UpdModLine++;
  1892.       RecDepth--;
  1893.       SetBuf(do_select(curwind, bname));
  1894. !     if (exp_p == NO)
  1895.           ToMark(m);
  1896.       DelMark(m);
  1897.   }
  1898. --- 816,822 ----
  1899.       UpdModLine++;
  1900.       RecDepth--;
  1901.       SetBuf(do_select(curwind, bname));
  1902. !     if (!is_an_arg())
  1903.           ToMark(m);
  1904.       DelMark(m);
  1905.   }
  1906. ***************
  1907. *** 846,858 ****
  1908.           if (RecDepth == 0) {
  1909.               if (ModMacs()) {
  1910.                   rbell();
  1911. !                 if (Upper(*ask("No",
  1912.   "Some MACROS haven't been saved; leave anyway? ")) != 'Y')
  1913.                       break;
  1914.               }
  1915.               if (ModBufs(0)) {
  1916.                   rbell();
  1917. !                 if (Upper(*ask("No",
  1918.   "Some buffers haven't been saved; leave anyway? ")) != 'Y')
  1919.                       break;
  1920.               }
  1921. --- 842,854 ----
  1922.           if (RecDepth == 0) {
  1923.               if (ModMacs()) {
  1924.                   rbell();
  1925. !                 if (CharUpcase(*ask("No",
  1926.   "Some MACROS haven't been saved; leave anyway? ")) != 'Y')
  1927.                       break;
  1928.               }
  1929.               if (ModBufs(0)) {
  1930.                   rbell();
  1931. !                 if (CharUpcase(*ask("No",
  1932.   "Some buffers haven't been saved; leave anyway? ")) != 'Y')
  1933.                       break;
  1934.               }
  1935. ***************
  1936. *** 880,887 ****
  1937.   
  1938.       for (;;) {
  1939.           if (this_cmd != ARG_CMD) {
  1940. !             exp = 1;
  1941. !             exp_p = NO;
  1942.               last_cmd = this_cmd;
  1943.               init_strokes();
  1944.           }
  1945. --- 876,882 ----
  1946.   
  1947.       for (;;) {
  1948.           if (this_cmd != ARG_CMD) {
  1949. !             clr_arg_value();
  1950.               last_cmd = this_cmd;
  1951.               init_strokes();
  1952.           }
  1953. ***************
  1954. *** 1051,1061 ****
  1955.       }
  1956.       if (scanvec(argv, "-r"))
  1957.           dorecover();
  1958.   
  1959. -     (void) time(&time0);
  1960.       ttinit();    /* initialize terminal (after ~/.joverc) */
  1961.       settout(ttbuf);    /* not until we know baudrate */
  1962. -     ResetTerm();
  1963.   
  1964.       (void) signal(SIGHUP, finish);
  1965.       (void) signal(SIGINT, finish);
  1966. --- 1046,1056 ----
  1967.       }
  1968.       if (scanvec(argv, "-r"))
  1969.           dorecover();
  1970. +     if (scanvec(argv, "-rc"))
  1971. +         FullRecover();
  1972.   
  1973.       ttinit();    /* initialize terminal (after ~/.joverc) */
  1974.       settout(ttbuf);    /* not until we know baudrate */
  1975.   
  1976.       (void) signal(SIGHUP, finish);
  1977.       (void) signal(SIGINT, finish);
  1978. ***************
  1979. *** 1071,1078 ****
  1980.   
  1981.       /* set things up to update the modeline every UpdFreq seconds */
  1982.       (void) signal(SIGALRM, updmode);
  1983. !     (void) alarm((unsigned) UpdFreq);
  1984.   
  1985.       cl_scr(1);
  1986.       flusho();
  1987.       RedrawDisplay();    /* start the redisplay process. */
  1988. --- 1066,1075 ----
  1989.   
  1990.       /* set things up to update the modeline every UpdFreq seconds */
  1991.       (void) signal(SIGALRM, updmode);
  1992. !     (void) time(&time0);
  1993. !     (void) alarm((unsigned) (60 - (time0 % 60)));
  1994.   
  1995. +     ResetTerm();
  1996.       cl_scr(1);
  1997.       flusho();
  1998.       RedrawDisplay();    /* start the redisplay process. */
  1999.