home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume11 / jove.pch / part04 / jove.pch.4
Text File  |  1987-09-15  |  32KB  |  1,414 lines
  1. diff -c ojove/rec.c jove/rec.c
  2. *** ojove/rec.c    Thu Jul 16 09:15:04 1987
  3. --- jove/rec.c    Mon Jul 13 09:46:08 1987
  4. ***************
  5. *** 51,57 ****
  6.       (void) unlink(recfname);
  7.   }
  8.   
  9. ! static
  10.   putaddr(addr, p)
  11.   disk_line    addr;
  12.   register File    *p;
  13. --- 51,57 ----
  14.       (void) unlink(recfname);
  15.   }
  16.   
  17. ! private
  18.   putaddr(addr, p)
  19.   disk_line    addr;
  20.   register File    *p;
  21. ***************
  22. *** 63,69 ****
  23.           putc(*cp++ & 0377, p);
  24.   }
  25.   
  26. ! static
  27.   putn(cp, nbytes)
  28.   register char    *cp;
  29.   register int    nbytes;
  30. --- 63,69 ----
  31.           putc(*cp++ & 0377, p);
  32.   }
  33.   
  34. ! private
  35.   putn(cp, nbytes)
  36.   register char    *cp;
  37.   register int    nbytes;
  38. ***************
  39. *** 74,80 ****
  40.   
  41.   /* Write out the line pointers for buffer B. */
  42.   
  43. ! static
  44.   dmppntrs(b)
  45.   register Buffer    *b;
  46.   {
  47. --- 74,80 ----
  48.   
  49.   /* Write out the line pointers for buffer B. */
  50.   
  51. ! private
  52.   dmppntrs(b)
  53.   register Buffer    *b;
  54.   {
  55. ***************
  56. *** 86,106 ****
  57.   
  58.   /* dump the buffer info and then the actual line pointers. */
  59.   
  60. ! static
  61. ! dmp_buf(b)
  62.   register Buffer    *b;
  63.   {
  64. !     static struct rec_entry    record;
  65.       register Line    *lp;
  66.       register int    nlines = 0;
  67.   
  68.       for (lp = b->b_first; lp != 0; lp = lp->l_next, nlines++)
  69. !         ;
  70.       strcpy(record.r_fname, b->b_fname ? b->b_fname : NullStr);
  71.       strcpy(record.r_bname, b->b_name);
  72.       record.r_nlines = nlines;
  73.       putn((char *) &record, sizeof record);
  74. -     dmppntrs(b);
  75.   }
  76.   
  77.   /* Goes through all the buffers and syncs them to the disk. */
  78. --- 86,107 ----
  79.   
  80.   /* dump the buffer info and then the actual line pointers. */
  81.   
  82. ! private
  83. ! dmp_buf_header(b)
  84.   register Buffer    *b;
  85.   {
  86. !     struct rec_entry    record;
  87.       register Line    *lp;
  88.       register int    nlines = 0;
  89.   
  90.       for (lp = b->b_first; lp != 0; lp = lp->l_next, nlines++)
  91. !         if (lp == b->b_dot)
  92. !             record.r_dotline = nlines;
  93.       strcpy(record.r_fname, b->b_fname ? b->b_fname : NullStr);
  94.       strcpy(record.r_bname, b->b_name);
  95.       record.r_nlines = nlines;
  96. +     record.r_dotchar = b->b_char;
  97.       putn((char *) &record, sizeof record);
  98.   }
  99.   
  100.   /* Goes through all the buffers and syncs them to the disk. */
  101. ***************
  102. *** 110,115 ****
  103. --- 111,117 ----
  104.   SyncRec()
  105.   {
  106.       register Buffer    *b;
  107. +     extern disk_line    DFree;
  108.   
  109.       if (rec_fd == 0)
  110.           recinit();    /* Init recover file. */
  111. ***************
  112. *** 123,128 ****
  113. --- 125,131 ----
  114.               continue;
  115.           else
  116.               Header.Nbuffers++;
  117. +     Header.FreePtr = DFree;
  118.       putn((char *) &Header, sizeof Header);
  119.       if (Header.Nbuffers != 0) {
  120.           SyncTmp();
  121. ***************
  122. *** 130,136 ****
  123.               if (b->b_type == B_SCRATCH || !IsModified(b))
  124.                   continue;
  125.               else
  126. !                 dmp_buf(b);
  127.       }
  128.       flush(rec_out);
  129.   }
  130. --- 133,148 ----
  131.               if (b->b_type == B_SCRATCH || !IsModified(b))
  132.                   continue;
  133.               else
  134. !                 dmp_buf_header(b);
  135. !         for (b = world; b != 0; b = b->b_next)
  136. !             if (b->b_type == B_SCRATCH || !IsModified(b))
  137. !                 continue;
  138. !             else
  139. !                 dmppntrs(b);
  140.       }
  141.       flush(rec_out);
  142. + }
  143. + 
  144. + FullRecover()
  145. + {
  146.   }
  147. diff -c ojove/rec.h jove/rec.h
  148. *** ojove/rec.h    Thu Jul 16 09:15:06 1987
  149. --- jove/rec.h    Thu Mar 19 17:13:30 1987
  150. ***************
  151. *** 6,20 ****
  152.    ************************************************************************/
  153.   
  154.   struct rec_head {
  155. !     int    Uid,        /* Uid of owner. */
  156. !         Pid;        /* Pid of jove process. */
  157. !     time_t    UpdTime;    /* Last time this was updated. */
  158. !     int    Nbuffers;    /* Number of buffers. */
  159.   };
  160.   
  161.   struct rec_entry {
  162.       char    r_bname[128],
  163.           r_fname[128];
  164. !     int    r_nlines;
  165.   };
  166. - 
  167. --- 6,22 ----
  168.    ************************************************************************/
  169.   
  170.   struct rec_head {
  171. !     int        Uid,        /* uid of owner */
  172. !             Pid;        /* pid of jove process */
  173. !     time_t        UpdTime;    /* last time this was updated */
  174. !     int        Nbuffers;    /* number of buffers */
  175. !     disk_line    FreePtr;    /* position of DFree */
  176.   };
  177.   
  178.   struct rec_entry {
  179.       char    r_bname[128],
  180.           r_fname[128];
  181. !     int    r_nlines,
  182. !         r_dotline,    /* so we can really save the context */
  183. !         r_dotchar;
  184.   };
  185. diff -c ojove/recover.c jove/recover.c
  186. *** ojove/recover.c    Thu Jul 16 09:15:12 1987
  187. --- jove/recover.c    Mon Jul 13 12:00:15 1987
  188. ***************
  189. *** 405,414 ****
  190.               printf("recover: cannot create %s.\n", dest);
  191.               return;
  192.           }
  193. -         seekto(src - buflist);
  194.           if (dest != tty)
  195.               printf("\"%s\"", dest);
  196. !         dump_file(outfile);
  197.       } else
  198.           printf("\nAborted!\n");
  199.       fclose(outfile);
  200. --- 405,413 ----
  201.               printf("recover: cannot create %s.\n", dest);
  202.               return;
  203.           }
  204.           if (dest != tty)
  205.               printf("\"%s\"", dest);
  206. !         dump_file(src - buflist, outfile);
  207.       } else
  208.           printf("\nAborted!\n");
  209.       fclose(outfile);
  210. ***************
  211. *** 440,454 ****
  212.   seekto(which)
  213.   {
  214.       struct rec_entry    rec;
  215.   
  216. !     fseek(ptrs_fp, (long) (sizeof Header), L_SET);
  217. !     
  218. !     while (which-- > 1) {
  219. !         read_rec(&rec);
  220. !         if (fseek(ptrs_fp, (long) rec.r_nlines * sizeof (disk_line),
  221. !             L_INCR) == -1)
  222. !             printf("recover: improper fseek!\n");
  223. !     }
  224.   }
  225.   
  226.   makblist()
  227. --- 439,451 ----
  228.   seekto(which)
  229.   {
  230.       struct rec_entry    rec;
  231. +     long    offset;
  232. +     int    i;
  233.   
  234. !     offset = sizeof (Header) + (Header.Nbuffers * sizeof (rec));
  235. !     for (i = 1; i < which; i++)
  236. !         offset += buflist[i]->r_nlines * sizeof (disk_line);
  237. !     fseek(ptrs_fp, offset, L_SET);
  238.   }
  239.   
  240.   makblist()
  241. ***************
  242. *** 455,469 ****
  243.   {
  244.       int    i;
  245.   
  246.       for (i = 1; i <= Header.Nbuffers; i++) {
  247. -         seekto(i);
  248.           if (buflist[i] == 0)
  249.               buflist[i] = (struct rec_entry *) malloc (sizeof (struct rec_entry));
  250.           read_rec(buflist[i]);
  251.       }
  252. !     if (buflist[i]) {
  253.           free((char *) buflist[i]);
  254.           buflist[i] = 0;
  255.       }
  256.   }
  257.   
  258. --- 452,467 ----
  259.   {
  260.       int    i;
  261.   
  262. +     fseek(ptrs_fp, (long) sizeof (Header), L_SET);
  263.       for (i = 1; i <= Header.Nbuffers; i++) {
  264.           if (buflist[i] == 0)
  265.               buflist[i] = (struct rec_entry *) malloc (sizeof (struct rec_entry));
  266.           read_rec(buflist[i]);
  267.       }
  268. !     while (buflist[i]) {
  269.           free((char *) buflist[i]);
  270.           buflist[i] = 0;
  271. +         i++;
  272.       }
  273.   }
  274.   
  275. ***************
  276. *** 481,496 ****
  277.       return addr;
  278.   }
  279.   
  280. ! dump_file(out)
  281.   FILE    *out;
  282.   {
  283. -     struct rec_entry    record;
  284.       register int    nlines;
  285.       register disk_line    daddr;
  286.       char    buf[BUFSIZ];
  287.   
  288. !     read_rec(&record);
  289. !     nlines = record.r_nlines;
  290.       Nchars = Nlines = 0L;
  291.       while (--nlines >= 0) {
  292.           daddr = getaddr(ptrs_fp);
  293. --- 479,493 ----
  294.       return addr;
  295.   }
  296.   
  297. ! dump_file(which, out)
  298.   FILE    *out;
  299.   {
  300.       register int    nlines;
  301.       register disk_line    daddr;
  302.       char    buf[BUFSIZ];
  303.   
  304. !     seekto(which);
  305. !     nlines = buflist[which]->r_nlines;
  306.       Nchars = Nlines = 0L;
  307.       while (--nlines >= 0) {
  308.           daddr = getaddr(ptrs_fp);
  309. ***************
  310. *** 539,549 ****
  311.   #ifdef KILL0
  312.       if (kill(Header.Pid, 0) == 0)
  313.           return 0;
  314. - #else
  315. - #ifdef LSRHS
  316. -     if (pexist(Header.Pid))
  317. -         return 0;
  318. - #endif LSRHS
  319.   #endif KILL0
  320.   
  321.       if (Header.Nbuffers == 0) {
  322. --- 536,541 ----
  323. ***************
  324. *** 568,573 ****
  325. --- 560,566 ----
  326.           return 1;
  327.       }
  328.       makblist();
  329. +     list();
  330.   
  331.       for (;;) {
  332.           tellme("(Type '?' for options): ", answer);
  333. ***************
  334. *** 699,707 ****
  335.           printf("recover: usage: recover [-d directory]\n");
  336.           printf("Use \"recover\" after JOVE has died for some\n");
  337.           printf("unknown reason.\n\n");
  338. !         printf("Use \"recover -syscrash\" when the system is in the process\n");
  339.           printf("of rebooting.  This is done automatically at reboot time\n");
  340.           printf("and so most of you don't have to worry about that.\n\n");
  341.           printf("Use \"recover -d directory\" when the tmp files are store\n");
  342.           printf("in DIRECTORY instead of the default one (/tmp).\n");
  343.           exit(0);
  344. --- 692,701 ----
  345.           printf("recover: usage: recover [-d directory]\n");
  346.           printf("Use \"recover\" after JOVE has died for some\n");
  347.           printf("unknown reason.\n\n");
  348. ! /*        printf("Use \"recover -syscrash\" when the system is in the process\n");
  349.           printf("of rebooting.  This is done automatically at reboot time\n");
  350.           printf("and so most of you don't have to worry about that.\n\n");
  351. +  */
  352.           printf("Use \"recover -d directory\" when the tmp files are store\n");
  353.           printf("in DIRECTORY instead of the default one (/tmp).\n");
  354.           exit(0);
  355. diff -c ojove/screen.c jove/screen.c
  356. *** ojove/screen.c    Thu Jul 16 09:15:18 1987
  357. --- jove/screen.c    Mon Jul 13 08:34:13 1987
  358. ***************
  359. *** 222,231 ****
  360.   
  361.   BufSwrite(linenum)
  362.   {
  363. -     char    *bp;
  364.       register int    n = cursend - cursor,
  365.               col = 0,
  366.               c;
  367.       int    StartCol = DesiredScreen[linenum].s_offset,
  368.           visspace = DesiredScreen[linenum].s_window->w_flags & W_VISSPACE,
  369.           aborted = 0;
  370. --- 222,231 ----
  371.   
  372.   BufSwrite(linenum)
  373.   {
  374.       register int    n = cursend - cursor,
  375.               col = 0,
  376.               c;
  377. +     register char    *bp;
  378.       int    StartCol = DesiredScreen[linenum].s_offset,
  379.           visspace = DesiredScreen[linenum].s_window->w_flags & W_VISSPACE,
  380.           aborted = 0;
  381. ***************
  382. *** 369,376 ****
  383.      What ever turns you on ...   */
  384.   
  385.   private struct cursaddr {
  386. !     int    c_numchars,
  387. !         (*c_proc)();
  388.   };
  389.   
  390.   private char    *Cmstr;
  391. --- 369,376 ----
  392.      What ever turns you on ...   */
  393.   
  394.   private struct cursaddr {
  395. !     int    cm_numchars,
  396. !         (*cm_proc)();
  397.   };
  398.   
  399.   private char    *Cmstr;
  400. ***************
  401. *** 532,538 ****
  402.       register int    nlines = destline - CapLine;
  403.   
  404.       while (--nlines >= 0)
  405. !         putchar('\n');
  406.       CapLine = destline;
  407.   }
  408.   
  409. --- 532,538 ----
  410.       register int    nlines = destline - CapLine;
  411.   
  412.       while (--nlines >= 0)
  413. !         putpad(NL, 1);
  414.       CapLine = destline;
  415.   }
  416.   
  417. ***************
  418. *** 574,580 ****
  419.   
  420.   #define CursMin(which,addrs,max) \
  421.       for (best = 0, cp = &addrs[1], i = 1; i < max; i++, cp++) \
  422. !         if (cp->c_numchars < addrs[best].c_numchars) \
  423.               best = i; \
  424.       which = &addrs[best];
  425.   
  426. --- 574,580 ----
  427.   
  428.   #define CursMin(which,addrs,max) \
  429.       for (best = 0, cp = &addrs[1], i = 1; i < max; i++, cp++) \
  430. !         if (cp->cm_numchars < addrs[best].cm_numchars) \
  431.               best = i; \
  432.       which = &addrs[best];
  433.   
  434. ***************
  435. *** 598,610 ****
  436.   
  437.       if (dcol == 1 || dcol == 0) {        /* Most common case. */
  438.           HorMin = &WarpHor[FORWARD];
  439. !         HorMin->c_numchars = dcol + xtracost;
  440.       } else {
  441. !         WarpHor[FORWARD].c_numchars = dcol >= 0 ? dcol + xtracost : 1000;
  442. !         WarpHor[BACKWARD].c_numchars = dcol < 0 ? -(dcol + xtracost) : 1000;
  443. !         WarpHor[FORTAB].c_numchars = dcol >= 0 && TABS ?
  444.                   ForNum(CapCol, col) + xtracost : 1000;
  445. !         WarpHor[RETFORWARD].c_numchars = (xtracost + 1 + (TABS ? ForNum(0, col) : col));
  446.   
  447.           /* Which is the shortest of the bunch */
  448.   
  449. --- 598,610 ----
  450.   
  451.       if (dcol == 1 || dcol == 0) {        /* Most common case. */
  452.           HorMin = &WarpHor[FORWARD];
  453. !         HorMin->cm_numchars = dcol + xtracost;
  454.       } else {
  455. !         WarpHor[FORWARD].cm_numchars = dcol >= 0 ? dcol + xtracost : 1000;
  456. !         WarpHor[BACKWARD].cm_numchars = dcol < 0 ? -(dcol + xtracost) : 1000;
  457. !         WarpHor[FORTAB].cm_numchars = dcol >= 0 && TABS ?
  458.                   ForNum(CapCol, col) + xtracost : 1000;
  459. !         WarpHor[RETFORWARD].cm_numchars = (xtracost + 1 + (TABS ? ForNum(0, col) : col));
  460.   
  461.           /* Which is the shortest of the bunch */
  462.   
  463. ***************
  464. *** 613,620 ****
  465.   
  466.       /* Moving vertically is more simple. */
  467.   
  468. !     WarpVert[DOWN].c_numchars = dline >= 0 ? dline : 1000;
  469. !     WarpVert[UPMOVE].c_numchars = dline < 0 ? ((-dline) * UPlen) : 1000;
  470.   
  471.       /* Which of these is simpler */
  472.       CursMin(VertMin, WarpVert, NUMVERT);
  473. --- 613,620 ----
  474.   
  475.       /* Moving vertically is more simple. */
  476.   
  477. !     WarpVert[DOWN].cm_numchars = dline >= 0 ? dline : 1000;
  478. !     WarpVert[UPMOVE].cm_numchars = dline < 0 ? ((-dline) * UPlen) : 1000;
  479.   
  480.       /* Which of these is simpler */
  481.       CursMin(VertMin, WarpVert, NUMVERT);
  482. ***************
  483. *** 624,651 ****
  484.          Homing first's total is the sum of the cost of homing
  485.          and the sum of tabbing (if possible) to the right. */
  486.       
  487. !     if (VertMin->c_numchars + HorMin->c_numchars <= 3) {
  488.           DirectMin = &WarpDirect[DIRECT];    /* A dummy ... */
  489. !         DirectMin->c_numchars = 100;
  490.       } else {
  491. !         WarpDirect[DIRECT].c_numchars = CM ?
  492.                   strlen(Cmstr = tgoto(CM, col, line)) : 1000;
  493. !         WarpDirect[HOME].c_numchars = HOlen + line +
  494. !                 WarpHor[RETFORWARD].c_numchars;
  495. !         WarpDirect[LOWER].c_numchars = LLlen + ((ILI - line) * UPlen) +
  496. !                 WarpHor[RETFORWARD].c_numchars;
  497.           CursMin(DirectMin, WarpDirect, NUMDIRECT);
  498.       }
  499.   
  500. !     if (HorMin->c_numchars + VertMin->c_numchars < DirectMin->c_numchars) {
  501.           if (line != CapLine)
  502. !             (*VertMin->c_proc)(line);
  503.           if (col != CapCol) {
  504.   #ifdef ID_CHAR
  505.               if (IN_INSmode)    /* We may use real characters ... */
  506.                   INSmode(0);
  507.   #endif
  508. !             (*HorMin->c_proc)(col);
  509.           }
  510.       } else {
  511.   #ifdef ID_CHAR
  512. --- 624,651 ----
  513.          Homing first's total is the sum of the cost of homing
  514.          and the sum of tabbing (if possible) to the right. */
  515.       
  516. !     if (VertMin->cm_numchars + HorMin->cm_numchars <= 3) {
  517.           DirectMin = &WarpDirect[DIRECT];    /* A dummy ... */
  518. !         DirectMin->cm_numchars = 100;
  519.       } else {
  520. !         WarpDirect[DIRECT].cm_numchars = CM ?
  521.                   strlen(Cmstr = tgoto(CM, col, line)) : 1000;
  522. !         WarpDirect[HOME].cm_numchars = HOlen + line +
  523. !                 WarpHor[RETFORWARD].cm_numchars;
  524. !         WarpDirect[LOWER].cm_numchars = LLlen + ((ILI - line) * UPlen) +
  525. !                 WarpHor[RETFORWARD].cm_numchars;
  526.           CursMin(DirectMin, WarpDirect, NUMDIRECT);
  527.       }
  528.   
  529. !     if (HorMin->cm_numchars + VertMin->cm_numchars < DirectMin->cm_numchars) {
  530.           if (line != CapLine)
  531. !             (*VertMin->cm_proc)(line);
  532.           if (col != CapCol) {
  533.   #ifdef ID_CHAR
  534.               if (IN_INSmode)    /* We may use real characters ... */
  535.                   INSmode(0);
  536.   #endif
  537. !             (*HorMin->cm_proc)(col);
  538.           }
  539.       } else {
  540.   #ifdef ID_CHAR
  541. ***************
  542. *** 652,658 ****
  543.           if (IN_INSmode && !MI)
  544.               INSmode(0);
  545.   #endif
  546. !         (*DirectMin->c_proc)(line, col);
  547.       }
  548.   }
  549.   
  550. --- 652,658 ----
  551.           if (IN_INSmode && !MI)
  552.               INSmode(0);
  553.   #endif
  554. !         (*DirectMin->cm_proc)(line, col);
  555.       }
  556.   }
  557.   
  558. ***************
  559. *** 716,727 ****
  560.       register int    i;
  561.   
  562.       if (CS) {
  563. !         putpad(tgoto(CS, bottom, top));
  564.           CapCol = CapLine = 0;
  565.           Placur(top, 0);
  566.           for (i = 0; i < num; i++)
  567.               putpad(SR, bottom - top);
  568. !         putpad(tgoto(CS, ILI, 0));
  569.           CapCol = CapLine = 0;
  570.       } else {
  571.           Placur(bottom - num + 1, 0);
  572. --- 716,727 ----
  573.       register int    i;
  574.   
  575.       if (CS) {
  576. !         putpad(tgoto(CS, bottom, top), 1);
  577.           CapCol = CapLine = 0;
  578.           Placur(top, 0);
  579.           for (i = 0; i < num; i++)
  580.               putpad(SR, bottom - top);
  581. !         putpad(tgoto(CS, ILI, 0), 1);
  582.           CapCol = CapLine = 0;
  583.       } else {
  584.           Placur(bottom - num + 1, 0);
  585. ***************
  586. *** 785,796 ****
  587.       register int    i;
  588.   
  589.       if (CS) {
  590. !         putpad(tgoto(CS, bottom, top));
  591.           CapCol = CapLine = 0;
  592.           Placur(bottom, 0);
  593.           for (i = 0; i < num; i++)
  594.               putpad(SF, bottom - top);
  595. !         putpad(tgoto(CS, ILI, 0));
  596.           CapCol = CapLine = 0;
  597.       } else {
  598.           Placur(top, 0);
  599. --- 785,796 ----
  600.       register int    i;
  601.   
  602.       if (CS) {
  603. !         putpad(tgoto(CS, bottom, top), 1);
  604.           CapCol = CapLine = 0;
  605.           Placur(bottom, 0);
  606.           for (i = 0; i < num; i++)
  607.               putpad(SF, bottom - top);
  608. !         putpad(tgoto(CS, ILI, 0), 1);
  609.           CapCol = CapLine = 0;
  610.       } else {
  611.           Placur(top, 0);
  612. diff -c ojove/term.c jove/term.c
  613. *** ojove/term.c    Thu Jul 16 09:15:21 1987
  614. --- jove/term.c    Wed Jun  3 16:31:57 1987
  615. ***************
  616. *** 6,11 ****
  617. --- 6,12 ----
  618.    ************************************************************************/
  619.   
  620.   #include "jove.h"
  621. + #include <ctype.h>
  622.   #include <errno.h>
  623.   #ifdef SYSV
  624.   #   include <termio.h>
  625. ***************
  626. *** 48,60 ****
  627.       *SF,    /* Scroll forward */
  628.       *SR,
  629.       *SP,    /* Send Cursor Position */
  630. - #ifdef LSRHS
  631. -     *RS,    /* Reverse video start */
  632. -     *RE,    /* Reverse end */
  633. - #endif
  634.       *VB,
  635.       *IP,    /* insert pad after character inserted */
  636. !     *lPC;
  637.   
  638.   int    LI,
  639.       ILI,    /* Internal lines, i.e., 23 of LI is 24. */
  640. --- 49,59 ----
  641.       *SF,    /* Scroll forward */
  642.       *SR,
  643.       *SP,    /* Send Cursor Position */
  644.       *VB,
  645. +     *BL,
  646.       *IP,    /* insert pad after character inserted */
  647. !     *lPC,
  648. !     *NL;
  649.   
  650.   int    LI,
  651.       ILI,    /* Internal lines, i.e., 23 of LI is 24. */
  652. ***************
  653. *** 70,103 ****
  654.       HOlen,
  655.       LLlen;
  656.   
  657. ! #ifdef SYSV /* release 2, at least */
  658. ! char PC ;
  659.   #else
  660.   extern char    PC;
  661. ! #endif SYSV
  662.   
  663.   static char    tspace[256];
  664.   
  665.   /* The ordering of ts and meas must agree !! */
  666. ! #ifdef LSRHS
  667. ! static char    *ts="vsvealdlspcssosecmclcehoupbcicimdceillsfsrvbksketiteALDLICDCrsrepcip";
  668.   static char    **meas[] = {
  669.       &VS, &VE, &AL, &DL, &SP, &CS, &SO, &SE,
  670.       &CM, &CL, &CE, &HO, &UP, &BC, &IC, &IM,
  671.       &DC, &EI, &LL, &SF, &SR, &VB, &KS, &KE,
  672.       &TI, &TE, &M_AL, &M_DL, &M_IC, &M_DC,
  673. !     &RS, &RE, &lPC, &IP, 0
  674.   };
  675. - #else
  676. - static char    *ts="vsvealdlspcssosecmclcehoupbcicimdceillsfsrvbksketiteALDLICDCpcip";
  677. - static char    **meas[] = {
  678. -     &VS, &VE, &AL, &DL, &SP, &CS, &SO, &SE,
  679. -     &CM, &CL, &CE, &HO, &UP, &BC, &IC, &IM,
  680. -     &DC, &EI, &LL, &SF, &SR, &VB, &KS, &KE,
  681. -     &TI, &TE, &M_AL, &M_DL, &M_IC, &M_DC,
  682. -     &lPC, &IP, 0
  683. - };
  684. - #endif
  685.   
  686.   static
  687.   gets(buf)
  688. --- 69,91 ----
  689.       HOlen,
  690.       LLlen;
  691.   
  692. ! #ifdef SYSVR2 /* release 2, at least */
  693. ! char    PC;
  694.   #else
  695.   extern char    PC;
  696. ! #endif SYSVR2
  697.   
  698.   static char    tspace[256];
  699.   
  700.   /* The ordering of ts and meas must agree !! */
  701. ! static char    *ts="vsvealdlspcssosecmclcehoupbcicimdceillsfsrvbksketiteALDLICDCpcipblnl";
  702.   static char    **meas[] = {
  703.       &VS, &VE, &AL, &DL, &SP, &CS, &SO, &SE,
  704.       &CM, &CL, &CE, &HO, &UP, &BC, &IC, &IM,
  705.       &DC, &EI, &LL, &SF, &SR, &VB, &KS, &KE,
  706.       &TI, &TE, &M_AL, &M_DL, &M_IC, &M_DC,
  707. !     &lPC, &IP, &BL, &NL, 0
  708.   };
  709.   
  710.   static
  711.   gets(buf)
  712. ***************
  713. *** 172,189 ****
  714.   
  715.       UL = tgetflag("ul");
  716.   
  717. ! #ifdef LSRHS        /* We, at the high school, are the only ones who
  718. !                do SO right in termcap, but unfortunately the
  719. !                right SO doesn't look as good with modelines. */
  720. !     if (RS)
  721. !         SO = RS;
  722. !     if (RE)
  723. !         SE = RE;
  724. !             /* I only ever use SO for the modeline anyway. */
  725.   
  726. ! /* SO is really BOLDFACE!  Why is LS always right and the rest of the
  727. !    world wrong? */
  728. ! #endif
  729.   #ifdef ID_CHAR
  730.       disp_opt_init();
  731.   #endif
  732. --- 160,177 ----
  733.   
  734.       UL = tgetflag("ul");
  735.   
  736. !     if (NL == 0)
  737. !         NL = "\n";
  738. !     else {            /* strip stupid padding information */
  739. !         while (isdigit(*NL))
  740. !             NL++;
  741. !         if (*NL == '*')
  742. !             NL++;
  743. !     }
  744.   
  745. !     if (BL == 0)
  746. !         BL = "\007";
  747. ! 
  748.   #ifdef ID_CHAR
  749.       disp_opt_init();
  750.   #endif
  751. diff -c ojove/termcap.h jove/termcap.h
  752. *** ojove/termcap.h    Thu Jul 16 09:15:22 1987
  753. --- jove/termcap.h    Fri May 29 16:28:21 1987
  754. ***************
  755. *** 36,48 ****
  756.       *SF,    /* Scroll forward */
  757.       *SR,    /* Scroll reverse */
  758.       *SP,    /* Send cursor position */
  759. - #ifdef LSRHS
  760. -     *RS,    /* reverse video start */
  761. -     *RE,    /* reverse video end */
  762. - #endif
  763.       *VB,    /* visible bell */
  764.       *IP,    /* insert pad after character inserted */
  765. !     *lPC;
  766.   
  767.   extern int
  768.       LI,        /* number of lines */
  769. --- 36,46 ----
  770.       *SF,    /* Scroll forward */
  771.       *SR,    /* Scroll reverse */
  772.       *SP,    /* Send cursor position */
  773.       *VB,    /* visible bell */
  774. +     *BL,    /* audible bell */
  775.       *IP,    /* insert pad after character inserted */
  776. !     *lPC,
  777. !     *NL;    /* newline character (usually \n) */
  778.   
  779.   extern int
  780.       LI,        /* number of lines */
  781. diff -c ojove/tune.h jove/tune.h
  782. *** ojove/tune.h    Thu Jul 16 09:15:22 1987
  783. --- jove/tune.h    Fri May 29 11:14:40 1987
  784. ***************
  785. *** 7,17 ****
  786.   
  787.   #define TUNED        /* don't touch this */
  788.   
  789. - /*#define LSRHS        /* if this is Lincoln-Sudbury Regional High School */
  790.   /*#define MSDOS        /* if this is MSDOS */
  791.   #define BSD4_2        /* Berkeley 4.2 BSD */
  792.   /*#define BSD4_3    /* Berkeley 4.3 BSD */
  793.   /*#define SYSV        /* for (System III/System V) UNIX systems */
  794.   #ifdef BSD4_3
  795.   #   ifndef BSD4_2
  796.   #    define BSD4_2    /* 4.3 is 4.2 only different. */
  797. --- 7,23 ----
  798.   
  799.   #define TUNED        /* don't touch this */
  800.   
  801.   /*#define MSDOS        /* if this is MSDOS */
  802.   #define BSD4_2        /* Berkeley 4.2 BSD */
  803.   /*#define BSD4_3    /* Berkeley 4.3 BSD */
  804.   /*#define SYSV        /* for (System III/System V) UNIX systems */
  805. + /*#define SYSVR2    /* system 5, rel. 2 */
  806. + #ifdef SYSVR2
  807. + #   ifndef SYSV
  808. + #    define SYSV    /* SYSV is a subset of SYSVR2 */
  809. + #   endif
  810. + #endif
  811. + 
  812.   #ifdef BSD4_3
  813.   #   ifndef BSD4_2
  814.   #    define BSD4_2    /* 4.3 is 4.2 only different. */
  815. ***************
  816. *** 36,42 ****
  817.   #    define NBUF    3
  818.   #   endif
  819.   #
  820. ! /* #   define LOAD_AV    /* Use the load average for various commands.
  821.   #               Do not define this if you lack a load average
  822.   #               system call and kmem is read protected. */
  823.   #
  824. --- 42,48 ----
  825.   #    define NBUF    3
  826.   #   endif
  827.   #
  828. ! #   define LOAD_AV    /* Use the load average for various commands.
  829.   #               Do not define this if you lack a load average
  830.   #               system call and kmem is read protected. */
  831.   #
  832. ***************
  833. *** 67,73 ****
  834.   #       define BIFF        /* if you have biff (or the equivalent) */
  835.   #       define F_COMPLETION    /* filename completion */
  836.   #       define CHDIR        /* cd command and absolute pathnames */
  837. ! #       define    KILL0    /* kill(pid, 0) returns 0 if proc exists */
  838.   #       define SPELL        /* spell words and buffer commands */
  839.   #       define ID_CHAR        /* include code to IDchar */
  840.   #       define WIRED_TERMS    /* include code for wired terminals */
  841. --- 73,79 ----
  842.   #       define BIFF        /* if you have biff (or the equivalent) */
  843.   #       define F_COMPLETION    /* filename completion */
  844.   #       define CHDIR        /* cd command and absolute pathnames */
  845. ! /*#       define    KILL0    /* kill(pid, 0) returns 0 if proc exists */
  846.   #       define SPELL        /* spell words and buffer commands */
  847.   #       define ID_CHAR        /* include code to IDchar */
  848.   #       define WIRED_TERMS    /* include code for wired terminals */
  849. diff -c ojove/util.c jove/util.c
  850. *** ojove/util.c    Thu Jul 16 09:15:24 1987
  851. --- jove/util.c    Fri Jun 19 16:01:01 1987
  852. ***************
  853. *** 7,17 ****
  854.   
  855.   #include "jove.h"
  856.   #include "ctype.h"
  857.   #include <signal.h>
  858.   #include <varargs.h>
  859.   
  860. ! #ifdef SYSV /* release 2, at least */
  861. ! short ospeed ;
  862.   #endif
  863.   
  864.   struct cmd *
  865. --- 7,18 ----
  866.   
  867.   #include "jove.h"
  868.   #include "ctype.h"
  869. + #include "termcap.h"
  870.   #include <signal.h>
  871.   #include <varargs.h>
  872.   
  873. ! #ifdef SYSVR2 /* release 2, at least */
  874. ! short    ospeed;
  875.   #endif
  876.   
  877.   struct cmd *
  878. ***************
  879. *** 27,32 ****
  880. --- 28,34 ----
  881.   }
  882.   
  883.   int    Interactive;    /* True when we invoke with the command handler? */
  884. + data_obj    *LastCmd;
  885.   char    *ProcFmt = ": %f ";
  886.   
  887.   ExecCmd(cp)
  888. ***************
  889. *** 56,76 ****
  890.   lastline(lp)
  891.   register Line    *lp;
  892.   {
  893. !     while (lp->l_next)
  894. !         lp = lp->l_next;
  895.       return lp;
  896.   }
  897.   
  898. ! Upper(c)
  899. ! register int    c;
  900. ! {
  901. !     return (islower(c) ? toupper(c) : c);
  902. ! }
  903.   
  904. - int    alarmed = 0;
  905. - 
  906.   char    key_strokes[100];
  907. ! static char    *key_p = key_strokes;
  908.   
  909.   init_strokes()
  910.   {
  911. --- 58,74 ----
  912.   lastline(lp)
  913.   register Line    *lp;
  914.   {
  915. !     register Line    *next;
  916. ! 
  917. !     while (next = lp->l_next)
  918. !         lp = next;
  919.       return lp;
  920.   }
  921.   
  922. ! private int    *slowp = 0;
  923.   
  924.   char    key_strokes[100];
  925. ! private char    *key_p = key_strokes;
  926.   
  927.   init_strokes()
  928.   {
  929. ***************
  930. *** 88,94 ****
  931.   
  932.   slowpoke()
  933.   {
  934. !     alarmed++;
  935.       f_mess(key_strokes);
  936.   }
  937.   
  938. --- 86,93 ----
  939.   
  940.   slowpoke()
  941.   {
  942. !     if (slowp)
  943. !         *slowp = YES;
  944.       f_mess(key_strokes);
  945.   }
  946.   
  947. ***************
  948. *** 95,104 ****
  949.   #ifdef BSD4_2
  950.   #    define N_SEC    1    /* will be precisely 1 second on 4.2 */
  951.   #else
  952. ! #    define N_SEC    2    /* but from 0 to 2 seconds otherwise */
  953.   #endif
  954.   
  955. ! waitchar()
  956.   {
  957.   #ifdef EUNICE
  958.       return getch();
  959. --- 94,104 ----
  960.   #ifdef BSD4_2
  961.   #    define N_SEC    1    /* will be precisely 1 second on 4.2 */
  962.   #else
  963. ! #    define N_SEC    2    /* but from 1 to 2 seconds otherwise */
  964.   #endif
  965.   
  966. ! waitchar(slow)
  967. ! int    *slow;
  968.   {
  969.   #ifdef EUNICE
  970.       return getch();
  971. ***************
  972. *** 107,113 ****
  973.       int    c;
  974.       int    (*oldproc)();
  975.   
  976. !     alarmed = 0;
  977.       oldproc = signal(SIGALRM, slowpoke);
  978.   
  979.       if ((old_time = alarm((unsigned) N_SEC)) == 0)
  980. --- 107,115 ----
  981.       int    c;
  982.       int    (*oldproc)();
  983.   
  984. !     slowp = slow;
  985. !     if (slow)
  986. !         *slow = NO;
  987.       oldproc = signal(SIGALRM, slowpoke);
  988.   
  989.       if ((old_time = alarm((unsigned) N_SEC)) == 0)
  990. ***************
  991. *** 214,220 ****
  992.       Eol();
  993.   }
  994.   
  995. ! int    MarkThresh = 22;    /* Average screen size ... */
  996.   static int    line_diff;
  997.   
  998.   LineDist(nextp, endp)
  999. --- 216,222 ----
  1000.       Eol();
  1001.   }
  1002.   
  1003. ! int    MarkThresh = 22;    /* average screen size ... */
  1004.   static int    line_diff;
  1005.   
  1006.   LineDist(nextp, endp)
  1007. ***************
  1008. *** 255,263 ****
  1009.   PushPntp(line)
  1010.   register Line    *line;
  1011.   {
  1012. -     exp_p = NO;
  1013.       if (LineDist(curline, line) >= MarkThresh)
  1014. !         SetMark();
  1015.   }
  1016.   
  1017.   ToFirst()
  1018. --- 257,264 ----
  1019.   PushPntp(line)
  1020.   register Line    *line;
  1021.   {
  1022.       if (LineDist(curline, line) >= MarkThresh)
  1023. !         set_mark();
  1024.   }
  1025.   
  1026.   ToFirst()
  1027. ***************
  1028. *** 276,282 ****
  1029.   {
  1030.       register char    c;
  1031.   
  1032. !     if (dir > 0) {
  1033.           while ((c = linebuf[curchar]) != 0 && !isword(c))
  1034.               curchar++;
  1035.           if (eolp()) {
  1036. --- 277,283 ----
  1037.   {
  1038.       register char    c;
  1039.   
  1040. !     if (dir == FORWARD) {
  1041.           while ((c = linebuf[curchar]) != 0 && !isword(c))
  1042.               curchar++;
  1043.           if (eolp()) {
  1044. ***************
  1045. *** 319,325 ****
  1046.   filename(b)
  1047.   register Buffer    *b;
  1048.   {
  1049. !     return b->b_fname ? pr_name(b->b_fname) : "[No file]";
  1050.   }
  1051.   
  1052.   char *
  1053. --- 320,326 ----
  1054.   filename(b)
  1055.   register Buffer    *b;
  1056.   {
  1057. !     return b->b_fname ? pr_name(b->b_fname, YES) : "[No file]";
  1058.   }
  1059.   
  1060.   char *
  1061. ***************
  1062. *** 430,436 ****
  1063.       return 0;
  1064.   }
  1065.   
  1066. ! /* Make `buf' modified and tell the redisplay code to update the modeline
  1067.      if it will need to be changed. */
  1068.   
  1069.   int    ModCount = 0;
  1070. --- 431,437 ----
  1071.       return 0;
  1072.   }
  1073.   
  1074. ! /* Make `buf' (un)modified and tell the redisplay code to update the modeline
  1075.      if it will need to be changed. */
  1076.   
  1077.   int    ModCount = 0;
  1078. ***************
  1079. *** 439,447 ****
  1080.   {
  1081.       extern int    DOLsave;
  1082.   
  1083. !     if (!curbuf->b_modified)
  1084.           UpdModLine++;
  1085. !     curbuf->b_modified++;
  1086.       DOLsave++;
  1087.       if (!Asking)
  1088.           ModCount++;
  1089. --- 440,449 ----
  1090.   {
  1091.       extern int    DOLsave;
  1092.   
  1093. !     if (!curbuf->b_modified) {
  1094.           UpdModLine++;
  1095. !         curbuf->b_modified = YES;
  1096. !     }
  1097.       DOLsave++;
  1098.       if (!Asking)
  1099.           ModCount++;
  1100. ***************
  1101. *** 449,457 ****
  1102.   
  1103.   unmodify()
  1104.   {
  1105. !     if (curbuf->b_modified)
  1106.           UpdModLine++;
  1107. !     curbuf->b_modified = 0;
  1108.   }
  1109.   
  1110.   numcomp(s1, s2)
  1111. --- 451,460 ----
  1112.   
  1113.   unmodify()
  1114.   {
  1115. !     if (curbuf->b_modified) {
  1116.           UpdModLine++;
  1117. !         curbuf->b_modified = NO;
  1118. !     }
  1119.   }
  1120.   
  1121.   numcomp(s1, s2)
  1122. ***************
  1123. *** 500,506 ****
  1124.   {
  1125.       register char    *pp, *pp1;
  1126.       register int    len;
  1127. !     int    numchars;    /* Number of characters to copy forward */
  1128.   
  1129.       if (num <= 0)
  1130.           return;
  1131. --- 503,509 ----
  1132.   {
  1133.       register char    *pp, *pp1;
  1134.       register int    len;
  1135. !     int    numchars;    /* number of characters to copy forward */
  1136.   
  1137.       if (num <= 0)
  1138.           return;
  1139. ***************
  1140. *** 566,572 ****
  1141.   char *
  1142.   emalloc(size)
  1143.   {
  1144. !     char    *ptr;
  1145.   
  1146.       if (ptr = malloc((unsigned) size))
  1147.           return ptr;
  1148. --- 569,575 ----
  1149.   char *
  1150.   emalloc(size)
  1151.   {
  1152. !     register char    *ptr;
  1153.   
  1154.       if (ptr = malloc((unsigned) size))
  1155.           return ptr;
  1156. ***************
  1157. *** 606,613 ****
  1158.   }
  1159.   
  1160.   #ifdef LOAD_AV
  1161. ! #  ifdef BSD4_2
  1162. ! #    ifdef PURDUE_EE
  1163.   
  1164.   get_la(dp)
  1165.   double *dp;
  1166. --- 609,616 ----
  1167.   }
  1168.   
  1169.   #ifdef LOAD_AV
  1170. ! # ifdef BSD4_2
  1171. ! #   ifdef PURDUE_EE && (vax || gould)
  1172.   
  1173.   get_la(dp)
  1174.   double *dp;
  1175. ***************
  1176. *** 615,622 ****
  1177.       *dp = (double) loadav(0) / 100.0;
  1178.   }
  1179.   
  1180. ! #    else PURDUE_EE
  1181.   
  1182.   #include <nlist.h>
  1183.   
  1184.   static struct    nlist nl[] = {
  1185. --- 618,628 ----
  1186.       *dp = (double) loadav(0) / 100.0;
  1187.   }
  1188.   
  1189. ! #   else PURDUE_EE
  1190.   
  1191. + #ifdef sun
  1192. + #   include <sys/param.h>
  1193. + #endif
  1194.   #include <nlist.h>
  1195.   
  1196.   static struct    nlist nl[] = {
  1197. ***************
  1198. *** 628,634 ****
  1199. --- 634,644 ----
  1200.   get_la(dp)
  1201.   double    *dp;
  1202.   {
  1203. + #ifdef sun
  1204. +     long    avenrun[3];
  1205. + #else
  1206.       double    avenrun[3];
  1207. + #endif
  1208.       static int    kmem = 0;
  1209.   
  1210.       if (kmem == -1) {
  1211. ***************
  1212. *** 644,650 ****
  1213. --- 654,664 ----
  1214.       }
  1215.       lseek(kmem, (long) nl[X_AVENRUN].n_value, 0);
  1216.       read(kmem, (char *) avenrun, sizeof(avenrun));
  1217. + #ifdef sun
  1218. +     *dp = (double) avenrun[0] / FSCALE;
  1219. + #else
  1220.       *dp = avenrun[0];
  1221. + #endif
  1222.   }
  1223.   
  1224.   #    endif PURDUE_EE
  1225. ***************
  1226. *** 693,703 ****
  1227.   strlen(s)
  1228.   register char    *s;
  1229.   {
  1230. !     register char    *base = s + 1;    /* Can you say kludge? */
  1231.   
  1232.       while (*s++)
  1233.           ;
  1234. !     return (s - base);
  1235.   }
  1236.   
  1237.   char *
  1238. --- 707,717 ----
  1239.   strlen(s)
  1240.   register char    *s;
  1241.   {
  1242. !     register char    *base = s;
  1243.   
  1244.       while (*s++)
  1245.           ;
  1246. !     return (s - base) - 1;
  1247.   }
  1248.   
  1249.   char *
  1250. ***************
  1251. *** 719,725 ****
  1252.           *s2;
  1253.   {
  1254.       if (!s1 || !s2)
  1255. !         return 1;    /* Which is not zero ... */
  1256.       while (*s1 == *s2++)
  1257.           if (*s1++ == '\0')
  1258.               return 0;
  1259. --- 733,739 ----
  1260.           *s2;
  1261.   {
  1262.       if (!s1 || !s2)
  1263. !         return 1;    /* which is not zero ... */
  1264.       while (*s1 == *s2++)
  1265.           if (*s1++ == '\0')
  1266.               return 0;
  1267. ***************
  1268. *** 731,738 ****
  1269.           *s2;
  1270.   {
  1271.       if (!s1 || !s2)
  1272. !         return 1;    /* Which is not zero ... */
  1273. !     while (*s1 == *s2++ || Upper(*s1) == Upper(s2[-1]))
  1274.           if (*s1++ == '\0')
  1275.               return 0;
  1276.       return (*s1 - *--s2);
  1277. --- 745,752 ----
  1278.           *s2;
  1279.   {
  1280.       if (!s1 || !s2)
  1281. !         return 1;    /* which is not zero ... */
  1282. !     while (CharUpcase(*s1) == CharUpcase(*s2++))
  1283.           if (*s1++ == '\0')
  1284.               return 0;
  1285.       return (*s1 - *--s2);
  1286. ***************
  1287. *** 744,751 ****
  1288.   register int    n;
  1289.   {
  1290.       if (!s1 || !s2)
  1291. !         return 1;    /* Which is not zero ... */
  1292. !     while (--n >= 0  && (*s1 == *s2++ || Upper(*s1) == Upper(s2[-1])))
  1293.           if (*s1++ == '\0')
  1294.               return 0;
  1295.       return ((n < 0) ? 0 : *s1 - *--s2);
  1296. --- 758,765 ----
  1297.   register int    n;
  1298.   {
  1299.       if (!s1 || !s2)
  1300. !         return 1;    /* which is not zero ... */
  1301. !     while (--n >= 0  && (CharUpcase(*s1) == CharUpcase(*s2++)))
  1302.           if (*s1++ == '\0')
  1303.               return 0;
  1304.       return ((n < 0) ? 0 : *s1 - *--s2);
  1305. diff -c ojove/vars.c jove/vars.c
  1306. *** ojove/vars.c    Thu Jul 16 09:15:25 1987
  1307. --- jove/vars.c    Thu May 28 12:48:29 1987
  1308. ***************
  1309. *** 25,30 ****
  1310. --- 25,31 ----
  1311.       VARIABLE, "disable-biff", &BiffChk, V_BOOL,
  1312.   #endif
  1313.       VARIABLE, "error-window-size", &EWSize, V_BASE10,
  1314. +     VARIABLE, "expand-environment-variables", &DoEVexpand, V_BOOL,
  1315.       VARIABLE, "file-creation-mode", &CreatMode, V_BASE8,
  1316.       VARIABLE, "files-should-end-with-newline", &EndWNewline, V_BOOL,
  1317.       VARIABLE, "internal-tabstop", &tabstop, V_BASE10|V_CLRSCREEN,
  1318. diff -c ojove/version.c jove/version.c
  1319. *** ojove/version.c    Thu Jul 16 09:15:26 1987
  1320. --- jove/version.c    Mon Jun 15 16:26:12 1987
  1321. ***************
  1322. *** 5,8 ****
  1323.    * included in all the files.                                           *
  1324.    ************************************************************************/
  1325.   
  1326. ! char    *version = "4.6.1.4";
  1327. --- 5,8 ----
  1328.    * included in all the files.                                           *
  1329.    ************************************************************************/
  1330.   
  1331. ! char    *version = "4.7";
  1332. diff -c ojove/wind.c jove/wind.c
  1333. *** ojove/wind.c    Thu Jul 16 09:15:28 1987
  1334. --- jove/wind.c    Fri Jun 12 11:39:26 1987
  1335. ***************
  1336. *** 219,225 ****
  1337.   
  1338.       DOTsave(&savedot);
  1339.   
  1340. !     switch (waitchar()) {
  1341.       case 't':
  1342.       case 'T':
  1343.           ExecCmd((data_obj *) FindCmd(FindTag));
  1344. --- 219,225 ----
  1345.   
  1346.       DOTsave(&savedot);
  1347.   
  1348. !     switch (waitchar((int *) 0)) {
  1349.       case 't':
  1350.       case 'T':
  1351.           ExecCmd((data_obj *) FindCmd(FindTag));
  1352. ***************
  1353. *** 354,365 ****
  1354.   
  1355.   GrowWindow()
  1356.   {
  1357. !     WindSize(curwind, abs(exp));
  1358.   }
  1359.   
  1360.   ShrWindow()
  1361.   {
  1362. !     WindSize(curwind, -abs(exp));
  1363.   }
  1364.   
  1365.   /* Change the size of the window by inc.  First arg is the window,
  1366. --- 354,365 ----
  1367.   
  1368.   GrowWindow()
  1369.   {
  1370. !     WindSize(curwind, abs(arg_value()));
  1371.   }
  1372.   
  1373.   ShrWindow()
  1374.   {
  1375. !     WindSize(curwind, -abs(arg_value()));
  1376.   }
  1377.   
  1378.   /* Change the size of the window by inc.  First arg is the window,
  1379. ***************
  1380. *** 434,438 ****
  1381.   
  1382.   SplitWind()
  1383.   {
  1384. !     SetWind(div_wind(curwind, exp_p ? (exp - 1) : 1));
  1385.   }
  1386. --- 434,460 ----
  1387.   
  1388.   SplitWind()
  1389.   {
  1390. !     SetWind(div_wind(curwind, is_an_arg() ? (arg_value() - 1) : 1));
  1391. ! }
  1392. ! 
  1393. ! /* Goto the window with the named buffer.  If no such window
  1394. !    exists, pop one and attach the buffer to it. */
  1395. ! GotoWind()
  1396. ! {
  1397. !     extern Buffer    *lastbuf;
  1398. !     char    *bname;
  1399. !     Window    *w;
  1400. ! 
  1401. !     bname = ask_buf(lastbuf);
  1402. !     w = curwind->w_next;
  1403. !     do {
  1404. !         if (w->w_bufp->b_name == bname) {
  1405. !             SetABuf(curbuf);
  1406. !             SetWind(w);
  1407. !             return;
  1408. !         }
  1409. !         w = w->w_next;
  1410. !     } while (w != curwind);
  1411. !     SetABuf(curbuf);
  1412. !     pop_wind(bname, NO, -1);
  1413.   }
  1414.