home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume8 / ue310usp / patches < prev    next >
Encoding:
Text File  |  1989-09-23  |  24.6 KB  |  1,028 lines
  1. *** bind.c.orig    Sat Sep 16 22:32:05 1989
  2. --- bind.c    Sun Sep 17 01:53:53 1989
  3. ***************
  4. *** 785,790 ****
  5. --- 785,795 ----
  6.           *ptr++ = '^';
  7.       }
  8.   
  9. +     if ((c & 255) == 0x7F) {
  10. +         *ptr++ = '^';
  11. +         c = '?';
  12. +     }
  13. + 
  14.       c = c & 255;    /* strip the prefixes */
  15.   
  16.       /* and output the final sequence */
  17. ***************
  18. *** 910,916 ****
  19.   
  20.       Meta and ^X prefix of lower case letters are converted to upper
  21.       case.  Real control characters are automatically converted to
  22. !     the ^A form.
  23.   */
  24.   
  25.   unsigned int PASCAL NEAR stock(keyname)
  26. --- 915,921 ----
  27.   
  28.       Meta and ^X prefix of lower case letters are converted to upper
  29.       case.  Real control characters are automatically converted to
  30. !     the ^A form.  '^?' is converted to DEL (0x7F).
  31.   */
  32.   
  33.   unsigned int PASCAL NEAR stock(keyname)
  34. ***************
  35. *** 963,969 ****
  36.   
  37.       /* a control char?  (Always upper case) */
  38.       if (*keyname == '^' && *(keyname+1) != 0) {
  39. !         c |= CTRL;
  40.           ++keyname;
  41.           uppercase(keyname);
  42.       }
  43. --- 968,977 ----
  44.   
  45.       /* a control char?  (Always upper case) */
  46.       if (*keyname == '^' && *(keyname+1) != 0) {
  47. !         if (keyname[1] == '?')
  48. !             c |= 0x7F;
  49. !         else
  50. !             c |= CTRL;
  51.           ++keyname;
  52.           uppercase(keyname);
  53.       }
  54. ***************
  55. *** 980,986 ****
  56.           uppercase(keyname);        /* Then make sure it's upper case */
  57.   
  58.       /* the final sequence... */
  59. !     c |= *keyname;
  60.       return(c);
  61.   }
  62.   
  63. --- 988,995 ----
  64.           uppercase(keyname);        /* Then make sure it's upper case */
  65.   
  66.       /* the final sequence... */
  67. !     if ((c & 255) != 0x7f)
  68. !         c |= *keyname;
  69.       return(c);
  70.   }
  71.   
  72. *** display.c.orig    Sat Sep 16 23:15:39 1989
  73. --- display.c    Sat Sep 16 23:51:59 1989
  74. ***************
  75. *** 11,16 ****
  76. --- 11,19 ----
  77.   #include    "etype.h"
  78.   #include    "edef.h"
  79.   #include    "elang.h"
  80. + #if VARARGS
  81. + #include    <varargs.h>
  82. + #endif
  83.   
  84.   typedef struct    VIDEO {
  85.       int    v_flag;         /* Flags */
  86. ***************
  87. *** 1091,1096 ****
  88. --- 1094,1106 ----
  89.   #define    ADJUST(ptr, dtype)    ptr += sizeof(dtype)
  90.   #endif
  91.   
  92. + #if VARARGS
  93. + CDECL NEAR mlwrite(va_alist)
  94. + va_dcl
  95. + {
  96. +     va_list ap;
  97. +     char *fmt;
  98. + #else
  99.   CDECL NEAR mlwrite(fmt, arg)
  100.   
  101.   char *fmt;    /* format string for output */
  102. ***************
  103. *** 1097,1104 ****
  104.   char *arg;    /* pointer to first argument to print */
  105.   
  106.   {
  107. -     register int c;     /* current char in format string */
  108.       register char *ap;    /* ptr to current data field */
  109.   
  110.       /* if we are not currently echoing on the command line, abort this */
  111.       if (discmd == FALSE)
  112. --- 1107,1115 ----
  113.   char *arg;    /* pointer to first argument to print */
  114.   
  115.   {
  116.       register char *ap;    /* ptr to current data field */
  117. + #endif
  118. +     register int c;     /* current char in format string */
  119.   
  120.       /* if we are not currently echoing on the command line, abort this */
  121.       if (discmd == FALSE)
  122. ***************
  123. *** 1116,1124 ****
  124. --- 1127,1141 ----
  125.           TTflush();
  126.       }
  127.   
  128. + #if VARARGS
  129. +     va_start(ap);
  130. +     fmt = va_arg(ap, char *);
  131. + #endif
  132.       movecursor(term.t_nrow, 0);
  133.        lastptr = &lastmesg[0];        /* setup to record message */
  134. + #if !VARARGS
  135.       ap = (char *) &arg;
  136. + #endif
  137.       while ((c = *fmt++) != 0) {
  138.           if (c != '%') {
  139.               mlout(c);
  140. ***************
  141. *** 1127,1159 ****
  142. --- 1144,1200 ----
  143.               c = *fmt++;
  144.               switch (c) {
  145.                   case 'd':
  146. + #if VARARGS
  147. +                     mlputi(va_arg(ap, int), 10);
  148. + #else
  149.                       mlputi(*(int *)ap, 10);
  150.                               ADJUST(ap, int);
  151. + #endif
  152.                       break;
  153.   
  154.                   case 'o':
  155. + #if VARARGS
  156. +                     mlputi(va_arg(ap, int), 8);
  157. + #else
  158.                       mlputi(*(int *)ap,  8);
  159.                       ADJUST(ap, int);
  160. + #endif
  161.                       break;
  162.   
  163.                   case 'x':
  164. + #if VARARGS
  165. +                     mlputi(va_arg(ap, int), 16);
  166. + #else
  167.                       mlputi(*(int *)ap, 16);
  168.                       ADJUST(ap, int);
  169. + #endif
  170.                       break;
  171.   
  172.                   case 'D':
  173. + #if VARARGS
  174. +                     mlputli(va_arg(ap, long), 10);
  175. + #else
  176.                       mlputli(*(long *)ap, 10);
  177.                       ADJUST(ap, long);
  178. + #endif
  179.                       break;
  180.   
  181.                   case 's':
  182. + #if VARARGS
  183. +                     mlputs(va_arg(ap, char *));
  184. + #else
  185.                       mlputs(*(char **)ap);
  186.                       ADJUST(ap, char *);
  187. + #endif
  188.                       break;
  189.   
  190.                   case 'f':
  191. + #if VARARGS
  192. +                     mlputf(va_arg(ap, int));
  193. + #else
  194.                       mlputf(*(int *)ap);
  195.                       ADJUST(ap, int);
  196. + #endif
  197.                       break;
  198.   
  199.                   default:
  200. *** ebind.h.orig    Sat Sep 16 23:37:51 1989
  201. --- ebind.h    Sat Sep 16 23:38:17 1989
  202. ***************
  203. *** 78,84 ****
  204.       {CTLX|'A',        BINDFNC,    setvar},
  205.       {CTLX|'B',        BINDFNC,    usebuffer},
  206.       {CTLX|'C',        BINDFNC,    spawncli},
  207. ! #if    BSD
  208.       {CTLX|'D',        BINDFNC,    bktoshell},
  209.   #endif
  210.       {CTLX|'E',        BINDFNC,    ctlxe},
  211. --- 78,84 ----
  212.       {CTLX|'A',        BINDFNC,    setvar},
  213.       {CTLX|'B',        BINDFNC,    usebuffer},
  214.       {CTLX|'C',        BINDFNC,    spawncli},
  215. ! #if    JOBCTRL
  216.       {CTLX|'D',        BINDFNC,    bktoshell},
  217.   #endif
  218.       {CTLX|'E',        BINDFNC,    ctlxe},
  219. *** edef.h.orig    Thu Jun 15 14:13:52 1989
  220. --- edef.h    Thu Jun 15 14:10:28 1989
  221. ***************
  222. *** 41,47 ****
  223.   NOSHARE int DNEAR sscroll = FALSE;    /* smooth scrolling enabled flag*/
  224.   NOSHARE int DNEAR hscroll = TRUE;    /* horizontal scrolling flag    */
  225.   NOSHARE int DNEAR hjump = 1;        /* horizontal jump size     */
  226. ! NOSHARE int DNEAR ssave = TRUE;     /* safe save flag        */
  227.   NOSHARE struct BUFFER *bstore = NULL;    /* buffer to store macro text to*/
  228.   NOSHARE int DNEAR vtrow = 0;        /* Row location of SW cursor    */
  229.   NOSHARE int DNEAR vtcol = 0;        /* Column location of SW cursor */
  230. --- 41,47 ----
  231.   NOSHARE int DNEAR sscroll = FALSE;    /* smooth scrolling enabled flag*/
  232.   NOSHARE int DNEAR hscroll = TRUE;    /* horizontal scrolling flag    */
  233.   NOSHARE int DNEAR hjump = 1;        /* horizontal jump size     */
  234. ! NOSHARE int DNEAR ssave = FALSE;     /* safe save flag        */
  235.   NOSHARE struct BUFFER *bstore = NULL;    /* buffer to store macro text to*/
  236.   NOSHARE int DNEAR vtrow = 0;        /* Row location of SW cursor    */
  237.   NOSHARE int DNEAR vtcol = 0;        /* Column location of SW cursor */
  238. *** efunc.h.orig    Sat Sep 16 23:38:37 1989
  239. --- efunc.h    Sat Sep 16 23:39:07 1989
  240. ***************
  241. *** 229,235 ****
  242.   #if    PROC
  243.       {"store-procedure",        storeproc},
  244.   #endif
  245. ! #if    BSD
  246.       {"suspend-emacs",        bktoshell},
  247.   #endif
  248.       {"transpose-characters",    twiddle},
  249. --- 229,235 ----
  250.   #if    PROC
  251.       {"store-procedure",        storeproc},
  252.   #endif
  253. ! #if    JOBCTRL
  254.       {"suspend-emacs",        bktoshell},
  255.   #endif
  256.       {"transpose-characters",    twiddle},
  257. *** input.c.orig    Thu Jun 15 14:05:11 1989
  258. --- input.c    Mon Aug 14 13:20:59 1989
  259. ***************
  260. *** 46,51 ****
  261. --- 46,59 ----
  262.   #include    "edef.h"
  263.   #include    "elang.h"
  264.   
  265. + #if USG | BSD | V7
  266. + #include    <pwd.h>
  267. + extern    struct passwd *getpwnam();
  268. + #if USG
  269. + #define    index    strchr
  270. + #endif
  271. + #endif
  272. + 
  273.   /*
  274.    * Ask a yes or no question in the message line. Return either TRUE, FALSE, or
  275.    * ABORT. The ABORT status is returned if the user bumps out of the question
  276. ***************
  277. *** 209,214 ****
  278. --- 217,227 ----
  279.       register int c;        /* current input character */
  280.       int cpos;        /* current column on screen output */
  281.       static char buf[NSTRING];/* buffer to hold tentative name */
  282. + #if USG | BSD | V7
  283. +     char *home;
  284. +     struct passwd *pwd;
  285. + #endif
  286. + 
  287.   #if    COMPLET == 0
  288.       int status;
  289.   #endif
  290. ***************
  291. *** 306,313 ****
  292.               TTflush();
  293.               if (buf[cpos - 1] == 0)
  294.                   return(buf);
  295.           } else {
  296. !             if (cpos < maxlen && c > ' ') {
  297.                   buf[cpos++] = c;
  298.                   mlout(c);
  299.                   ++ttcol;
  300. --- 319,394 ----
  301.               TTflush();
  302.               if (buf[cpos - 1] == 0)
  303.                   return(buf);
  304. + #if USG | BSD | V7
  305. +         } else if (c == '/' && type == CMP_FILENAME && buf[0] == '~') {
  306. +             int i;
  307. + 
  308. +             if (cpos == 1) {
  309. +                 if (home = (char *)getenv("HOME")) {
  310. + 
  311. +                     mlout('\b');    /* backup over ~ */
  312. +                     mlout(' ');
  313. +                     mlout('\b');
  314. +                     ttcol--;
  315. +                     TTflush();
  316. +                     strcpy(buf, home);
  317. +                     cpos = strlen(buf);
  318. +                     buf[cpos++] = '/';
  319. +                     for (i = 0; i < cpos; i++) {
  320. +                         mlout(buf[i]);
  321. +                         ttcol++;
  322. +                     }
  323. +                     TTflush();
  324. +                 } else
  325. +                     goto nextc;
  326. +             } else {
  327. +                 buf[cpos] = '\0';
  328. +                 if (pwd = getpwnam(&buf[1])) {
  329. +                     while (cpos != 0) {    /* kill    */
  330. +                         mlout('\b');    /* line    */
  331. +                         mlout(' ');
  332. +                         mlout('\b');
  333. +                         --cpos;
  334. +                         --ttcol;
  335. +                     }
  336. +                     TTflush();
  337. +                     strcpy(buf, pwd->pw_dir);
  338. +                     cpos = strlen(buf);
  339. +                     buf[cpos++] = '/';
  340. +                     for (i = 0; i < cpos; i++) {
  341. +                      mlout(buf[i]);
  342. +                         ttcol++;
  343. +                     }
  344. +                     TTflush();
  345. +                 } else
  346. +                     goto nextc;
  347. +             }
  348. +         } else if (c == '/' && type == CMP_FILENAME && buf[0] == '$') {
  349. +             int i;
  350. + 
  351. +             buf[cpos] = '\0';
  352. +             if (home = (char *)getenv(&buf[1])) {
  353. +                 while (cpos != 0) {    /* kill    */
  354. +                     mlout('\b');    /* line    */
  355. +                     mlout(' ');
  356. +                     mlout('\b');
  357. +                     --cpos;
  358. +                     --ttcol;
  359. +                 }
  360. +                 TTflush();
  361. +                 strcpy(buf, home);
  362. +                 cpos = strlen(buf);
  363. +                 buf[cpos++] = '/';
  364. +                 for (i = 0; i < cpos; i++) {
  365. +                     mlout(buf[i]);
  366. +                     ttcol++;
  367. +                 }
  368. +                 TTflush();
  369. +             } else
  370. +                 goto nextc;
  371. + #endif
  372.           } else {
  373. ! nextc:            if (cpos < maxlen && c > ' ') {
  374.                   buf[cpos++] = c;
  375.                   mlout(c);
  376.                   ++ttcol;
  377. ***************
  378. *** 476,542 ****
  379.   {
  380.       register char *fname;    /* trial file to complete */
  381.       register int index;    /* index into strings to compare */
  382. !     register char *match;    /* last file that matches string */
  383. !     register int matchflag;    /* did this file name match? */
  384. !     register int comflag;    /* was there a completion at all? */
  385. ! 
  386. !     /* start attempting completions, one character at a time */
  387. !     comflag = FALSE;
  388. !     while (*cpos < NBUFN) {
  389. ! 
  390. !         /* first, we start at the first file and scan the list */
  391. !         match = NULL;
  392. !         name[*cpos] = 0;
  393. !         fname = getffile(name);
  394. !         while (fname) {
  395. ! 
  396. !             /* is this a match? */
  397. !             matchflag = TRUE;
  398. !             for (index = 0; index < *cpos; index++)
  399. !                 if (name[index] != fname[index]) {
  400. !                     matchflag = FALSE;
  401. !                     break;
  402. !                 }
  403. ! 
  404. !             /* if it is a match */
  405. !             if (matchflag && index) {
  406. ! 
  407. !                 /* if this is the first match, simply record it */
  408. !                 if (match == NULL) {
  409. !                     match = fname;
  410. !                     name[*cpos] = fname[*cpos];
  411. !                 } else {
  412. !                     /* if there's a difference, stop here */
  413. !                     if (name[*cpos] != fname[*cpos])
  414. !                         return;
  415. !                 }
  416. !             }
  417. ! 
  418. !             /* on to the next file */
  419. !             fname = getnfile();
  420. !         }
  421. ! 
  422. !         /* with no match, we are done */
  423. !         if (match == NULL) {
  424. !             /* beep if we never matched */
  425. !             if (comflag == FALSE)
  426. !                 TTbeep();
  427. !             return;
  428. !         }
  429.   
  430. !         /* if we have completed all the way... go back */
  431. !         if (name[*cpos] == 0) {
  432. !             (*cpos)++;
  433. !             return;
  434. !         }
  435.   
  436. !         /* remember we matched, and complete one character */
  437. !         comflag = TRUE;
  438. !         TTputc(name[(*cpos)++]);
  439. !         TTflush();
  440. !     }
  441.   
  442. -     /* don't allow a completion past the end of the max file name length */
  443.       return;
  444.   }
  445.   #endif
  446. --- 557,627 ----
  447.   {
  448.       register char *fname;    /* trial file to complete */
  449.       register int index;    /* index into strings to compare */
  450. !     register int matches;    /* number of matches for name */
  451. !     char longestmatch[NSTRING]; /* temp buffer for longest match */
  452. !     int longestlen;        /* length of longest match (always > *cpos) */
  453.   
  454. !     /* everything (or nothing) matches an empty string */
  455. !     if (*cpos == 0)
  456. !         return;
  457. ! 
  458. !     /* first, we start at the first file and scan the list */
  459. !     matches = 0;
  460. !     name[*cpos] = 0;
  461. !     fname = getffile(name);
  462. !     while (fname) {
  463. ! 
  464. !         /* is this a match? */
  465. !         if (strncmp(name,fname,*cpos) == 0) {
  466. ! 
  467. !             /* count the number of matches */
  468. !             matches++;
  469. ! 
  470. !             /* if this is the first match, simply record it */
  471. !             if (matches == 1) {
  472. !                 strcpy(longestmatch,fname);
  473. !                 longestlen = strlen(longestmatch);
  474. !             } else {
  475. !                 
  476. !                 /* if there's a difference, stop here */
  477. !                 if (longestmatch[*cpos] != fname[*cpos])
  478. !                     return;
  479. ! 
  480. !                 for (index = (*cpos) + 1; index < longestlen; index++)
  481. !                     if (longestmatch[index] != fname[index]) {
  482. !                         longestlen = index;
  483. !                         longestmatch[longestlen] = 0;
  484. !                     }
  485. !             }
  486. !         }
  487. ! 
  488. !         /* on to the next file */
  489. !         fname = getnfile();
  490. !     }
  491. ! 
  492. !     /* beep if we never matched */
  493. !     if (matches == 0) {
  494. !         TTbeep();
  495. !         return;
  496. !     }
  497. ! 
  498. !     /* the longestmatch array contains the longest match so copy and print it */
  499. !     for ( ; (*cpos < (NSTRING-1)) && (*cpos < longestlen); (*cpos)++) {
  500. !         name[*cpos] = longestmatch[*cpos];
  501. !         TTputc(name[*cpos]);
  502. !     }
  503. ! 
  504. !     name[*cpos] = 0;
  505. ! 
  506. !     /* if only one file matched then increment cpos to signal complete() */
  507. !     /* that this was a complete match.  If a directory was matched then */
  508. !     /* last character will be the DIRSEPCHAR.  In this case we do NOT *
  509. !     /* want to signal a complete match. */
  510. !     if ((matches == 1) && (name[(*cpos)-1] != DIRSEPCHAR))
  511. !         (*cpos)++;
  512.   
  513. !     TTflush();
  514.   
  515.       return;
  516.   }
  517.   #endif
  518. *** tcap.c.orig    Sat Sep 16 22:25:59 1989
  519. --- tcap.c    Sat Sep 16 22:26:18 1989
  520. ***************
  521. *** 413,419 ****
  522.       register int c;
  523.       register int index;    /* index into termcap binding table */
  524.       char *sp;
  525. ! #if    BSD | V7 | HPUX
  526.       int fdset;
  527.       struct timeval timeout;
  528.   #endif
  529. --- 413,419 ----
  530.       register int c;
  531.       register int index;    /* index into termcap binding table */
  532.       char *sp;
  533. ! #if    BSD | V7 | HPUX | SUN
  534.       int fdset;
  535.       struct timeval timeout;
  536.   #endif
  537. ***************
  538. *** 427,433 ****
  539.   
  540.       /* process a possible escape sequence */
  541.       /* set up to check the keyboard for input */
  542. ! #if    BSD | V7 | HPUX
  543.       fdset = 1;
  544.       timeout.tv_sec = 0;
  545.       timeout.tv_usec = 35000L;
  546. --- 427,433 ----
  547.   
  548.       /* process a possible escape sequence */
  549.       /* set up to check the keyboard for input */
  550. ! #if    BSD | V7 | HPUX | SUN
  551.       fdset = 1;
  552.       timeout.tv_sec = 0;
  553.       timeout.tv_usec = 35000L;
  554. ***************
  555. *** 438,444 ****
  556.           return(CTRL | '[');
  557.   #endif
  558.   
  559. ! #if XENIX | SUNOS
  560.       if ((kbdmode != PLAY) && (rdchk(0) <= 0)) {
  561.           nap(35000L);
  562.           if (rdchk(0) <= 0)
  563. --- 438,444 ----
  564.           return(CTRL | '[');
  565.   #endif
  566.   
  567. ! #if XENIX
  568.       if ((kbdmode != PLAY) && (rdchk(0) <= 0)) {
  569.           nap(35000L);
  570.           if (rdchk(0) <= 0)
  571. *** unix.c.orig    Thu May 11 13:09:36 1989
  572. --- unix.c    Sun Sep 17 00:06:10 1989
  573. ***************
  574. *** 15,21 ****
  575. --- 15,28 ----
  576.   #include    <signal.h>
  577.   #include    <termio.h>
  578.   #include    <fcntl.h>
  579. + #include    <sys/types.h>
  580. + #include    <sys/stat.h>
  581. + #if    DIRENT
  582. + #include    <dirent.h>
  583. + #define direct dirent
  584. + #else
  585.   #include    <ndir.h>
  586. + #endif
  587.   int kbdflgs;            /* saved keyboard fd flags    */
  588.   int kbdpoll;            /* in O_NDELAY mode            */
  589.   int kbdqp;            /* there is a char in kbdq    */
  590. ***************
  591. *** 42,55 ****
  592.   
  593.   #if BSD
  594.   #include <sys/ioctl.h>        /* to get at the typeahead */
  595. - extern    int rtfrmshell();    /* return from suspended shell */
  596.   #define    TBUFSIZ    128
  597.   char tobuf[TBUFSIZ];        /* terminal output buffer */
  598.   #endif
  599.   #endif
  600.   
  601.   #if     V7 | USG | HPUX | SUN | XENIX | BSD
  602. - #include        <signal.h>
  603.   extern int vttidy();
  604.   #endif
  605.   
  606. --- 49,64 ----
  607.   
  608.   #if BSD
  609.   #include <sys/ioctl.h>        /* to get at the typeahead */
  610.   #define    TBUFSIZ    128
  611.   char tobuf[TBUFSIZ];        /* terminal output buffer */
  612.   #endif
  613.   #endif
  614.   
  615. + #if JOBCTRL
  616. + extern    int rtfrmshell();    /* return from suspended shell */
  617. + #endif
  618. + 
  619.   #if     V7 | USG | HPUX | SUN | XENIX | BSD
  620.   extern int vttidy();
  621.   #endif
  622.   
  623. ***************
  624. *** 75,80 ****
  625. --- 84,94 ----
  626.       kbdpoll = FALSE;
  627.   #endif
  628.   
  629. + #if    JOBCTRL
  630. +     signal(SIGTSTP,SIG_DFL);    /* set signals so that we can */
  631. +     signal(SIGCONT,rtfrmshell);    /* suspend & restart emacs */
  632. + #endif
  633. + 
  634.   #if     V7 | BSD
  635.           gtty(0, &ostate);                       /* save old state */
  636.           gtty(0, &nstate);                       /* get base of new state */
  637. ***************
  638. *** 87,96 ****
  639.       /* provide a smaller terminal output buffer so that
  640.          the type ahead detection works better (more often) */
  641.       setbuffer(stdout, &tobuf[0], TBUFSIZ);
  642. -     signal(SIGTSTP,SIG_DFL);    /* set signals so that we can */
  643. -     signal(SIGCONT,rtfrmshell);    /* suspend & restart emacs */
  644.   #endif
  645.   #endif
  646.       /* on all screens we are not sure of the initial position
  647.          of the cursor                    */
  648.       ttrow = 999;
  649. --- 101,112 ----
  650.       /* provide a smaller terminal output buffer so that
  651.          the type ahead detection works better (more often) */
  652.       setbuffer(stdout, &tobuf[0], TBUFSIZ);
  653.   #endif
  654.   #endif
  655. +     /* if we spawn a subshell we don't want to die if the user hits
  656. +        the interrupt or quit keys */
  657. +     signal(SIGINT, SIG_IGN);
  658. +     signal(SIGQUIT, SIG_IGN);
  659.       /* on all screens we are not sure of the initial position
  660.          of the cursor                    */
  661.       ttrow = 999;
  662. ***************
  663. *** 217,223 ****
  664.           if (fcntl(0, F_SETFL, kbdflgs | O_NDELAY) < 0 && kbdpoll)
  665.               return(FALSE);
  666.           kbdpoll = TRUE;
  667. !         kbdqp = (1 == read(0, kbdq, 1));
  668.       }
  669.       return(kbdqp);
  670.   #endif
  671. --- 233,239 ----
  672.           if (fcntl(0, F_SETFL, kbdflgs | O_NDELAY) < 0 && kbdpoll)
  673.               return(FALSE);
  674.           kbdpoll = TRUE;
  675. !         kbdqp = (1 == read(0, &kbdq, 1));
  676.       }
  677.       return(kbdqp);
  678.   #endif
  679. ***************
  680. *** 259,265 ****
  681.           return(TRUE);
  682.   }
  683.   
  684. ! #if    BSD
  685.   
  686.   bktoshell()        /* suspend MicroEMACS and wait to wake up */
  687.   {
  688. --- 275,281 ----
  689.           return(TRUE);
  690.   }
  691.   
  692. ! #if    JOBCTRL
  693.   
  694.   bktoshell()        /* suspend MicroEMACS and wait to wake up */
  695.   {
  696. ***************
  697. *** 299,311 ****
  698.           TTclose();                              /* stty to old modes    */
  699.           system(line);
  700.           TTopen();
  701. !         TTflush();
  702.       /* if we are interactive, pause here */
  703.       if (clexec == FALSE) {
  704.               mlputs(TEXT6);
  705.   /*                     "\r\n\n[End]" */
  706.               tgetc();
  707.           }
  708.           sgarbf = TRUE;
  709.           return(TRUE);
  710.   }
  711. --- 315,329 ----
  712.           TTclose();                              /* stty to old modes    */
  713.           system(line);
  714.           TTopen();
  715. !         movecursor(term.t_nrow, 0);             /* Seek to last line.   */
  716.       /* if we are interactive, pause here */
  717.       if (clexec == FALSE) {
  718.               mlputs(TEXT6);
  719.   /*                     "\r\n\n[End]" */
  720. +             TTflush();
  721.               tgetc();
  722.           }
  723. +     TTflush();
  724.           sgarbf = TRUE;
  725.           return(TRUE);
  726.   }
  727. ***************
  728. *** 317,323 ****
  729.    */
  730.   
  731.   execprg(f, n)
  732. - 
  733.   {
  734.           register int    s;
  735.           char            line[NLINE];
  736. --- 335,340 ----
  737. ***************
  738. *** 326,348 ****
  739.       if (restflag)
  740.           return(resterr());
  741.   
  742. !         if ((s=mlreply("!", line, NLINE)) != TRUE)
  743.                   return(s);
  744.           TTputc('\n');                /* Already have '\r'    */
  745.           TTflush();
  746.           TTclose();                              /* stty to old modes    */
  747. !         system(line);
  748.           TTopen();
  749. !         mlputs(TEXT188);                        /* Pause.               */
  750. ! /*             "[End]" */
  751. !         TTflush();
  752. !         while ((s = tgetc()) != '\r' && s != ' ')
  753. !                 ;
  754.           sgarbf = TRUE;
  755.           return(TRUE);
  756.   }
  757.   
  758.   /*
  759.    * Pipe a one line command into a window
  760.    * Bound to ^X @
  761.    */
  762. --- 343,502 ----
  763.       if (restflag)
  764.           return(resterr());
  765.   
  766. !         if ((s=mlreply("$", line, NLINE)) != TRUE)
  767.                   return(s);
  768.           TTputc('\n');                /* Already have '\r'    */
  769.           TTflush();
  770.           TTclose();                              /* stty to old modes    */
  771. !         execpr(line);
  772.           TTopen();
  773. !         movecursor(term.t_nrow, 0);             /* Seek to last line.   */
  774. !     /* if we are interactive, pause here */
  775. !     if (clexec == FALSE) {
  776. !             mlputs(TEXT188);
  777. ! /*                     "[End]" */
  778. !             TTflush();
  779. !             tgetc();
  780. !         }
  781. !     TTflush();
  782.           sgarbf = TRUE;
  783.           return(TRUE);
  784.   }
  785.   
  786.   /*
  787. +  * Run a program with arguments without using a shell.
  788. +  * Line is a string containing a program name and arguments, separated
  789. +  * by whitespace.  Shell metacharacters have no special meaning.
  790. +  */
  791. + 
  792. + execpr(line)
  793. +     char           *line;
  794. + {
  795. +     char          **stov();
  796. +     char          **argv;
  797. +     char           *cp;    /* A copy of the line in case it's $SHELL. */
  798. +     int             pid;
  799. + 
  800. +     if (line == 0 || *line == 0)
  801. +         return;
  802. + 
  803. +     cp = malloc(strlen(line) + 1);
  804. +     strcpy(cp, line);
  805. +     argv = stov(cp);
  806. + 
  807. +     pid = fork();
  808. +     switch (pid) {
  809. +     case -1:
  810. +         break;
  811. +     case 0:        /* Child. */
  812. +         signal(SIGINT, SIG_DFL);
  813. +         signal(SIGQUIT, SIG_DFL);
  814. +         execvp(argv[0], argv);
  815. +         /* Might want to print "argv[0]: Command not found.\n". */
  816. +         exit(0);
  817. +     default:        /* Parent. */
  818. +         while (wait((int *) 0) != pid)
  819. +              /* Do nothing. */ ;
  820. +         break;
  821. +     }
  822. +     free(argv);
  823. +     free(cp);
  824. + }
  825. + 
  826. + /* Number of arguments between realloc's. */
  827. + #define ALLOC_BLOCK 10
  828. + 
  829. + /*
  830. +  * Make an argv-like vector (string array) from a string (such as an
  831. +  * environment variable).  The last element of the vector is null.
  832. +  * Scatters nulls throughout s.
  833. +  */
  834. + 
  835. + char **
  836. + stov(s)
  837. +     char           *s;    /* The string to vectorize. */
  838. + {
  839. +     char           *malloc(), *realloc(), *strtok();
  840. +     int             argc;
  841. +     char          **argv;
  842. + 
  843. +     argc = 0;
  844. +     argv = (char **) malloc((unsigned) (sizeof(char *) * ALLOC_BLOCK));
  845. + 
  846. +     for (s = strtok(s, " \t\n\r"); s;
  847. +         s = strtok((char *) NULL, " \t\n\r")) {
  848. +         if (argc > 0 && argc % ALLOC_BLOCK == 0)
  849. +             argv = (char **) realloc((char *) argv, (unsigned)
  850. +                 (sizeof(char *) * (argc + ALLOC_BLOCK)));
  851. +         argv[argc++] = s;
  852. +     }
  853. +     argv = (char **) realloc((char *) argv,
  854. +         (unsigned) (sizeof(char *) * (argc + 1)));
  855. +     argv[argc] = NULL;
  856. +     return argv;
  857. + }
  858. + 
  859. + #if V7 | BSD
  860. + /* Return the next token in string, delimited by one or more members of
  861. +    the set separators.  If string is NULL, use the same string as in the
  862. +    last call.  */
  863. + 
  864. + char *
  865. + strtok(string, separators)
  866. +     char           *string;
  867. +     char           *separators;
  868. + {
  869. +     static char    *pos = NULL;    /* Current location in the string. */
  870. +     register int    token_length;
  871. + 
  872. +     if (string)
  873. +         pos = string;
  874. +     pos += strspn(pos, separators);    /* Skip initial separators. */
  875. +     token_length = strcspn(pos, separators);    /* Find token length. */
  876. +     if (token_length == 0)
  877. +         return NULL;    /* No more tokens; pos is on a 0. */
  878. +     separators = pos;    /* Re-use separators to save start of token. */
  879. +     pos += token_length;    /* Move onto the 0. */
  880. +     if (*pos)        /* If not the last token, */
  881. +         *pos++ = 0;    /* null terminate the token. */
  882. +     return separators;
  883. + }
  884. + 
  885. + /* Return the length of the span of characters at the start of string
  886. +    that are members of class.  */
  887. + 
  888. + strspn(string, class)
  889. +     char           *string;
  890. +     char           *class;
  891. + {
  892. +     char           *index();
  893. +     register int    count;
  894. + 
  895. +     for (count = 0; string[count]; ++count)
  896. +         if (!index(class, string[count]))
  897. +             break;
  898. +     return count;
  899. + }
  900. + 
  901. + /* Return the length of the span of characters at the start of string
  902. +    that are non-members of class.  */
  903. + 
  904. + strcspn(string, class)
  905. +     char           *string;
  906. +     char           *class;
  907. + {
  908. +     char           *index();
  909. +     register int    count;
  910. + 
  911. +     for (count = 0; string[count]; ++count)
  912. +         if (index(class, string[count]))
  913. +             break;
  914. +     return count;
  915. + }
  916. + 
  917. + #endif
  918. + 
  919. + /*
  920.    * Pipe a one line command into a window
  921.    * Bound to ^X @
  922.    */
  923. ***************
  924. *** 529,534 ****
  925. --- 683,689 ----
  926.       register int index;        /* index into various strings */
  927.       register int point;        /* index into other strings */
  928.       register int extflag;        /* does the file have an extention? */
  929. +     int currentdir = FALSE;
  930.   
  931.       /* first parse the file path off the file spec */
  932.       strcpy(path, fspec);
  933. ***************
  934. *** 537,542 ****
  935. --- 692,704 ----
  936.                   path[index] != '\\' && path[index] != ':'))
  937.           --index;
  938.       path[index+1] = 0;
  939. + #if HPUX
  940. +     if (index < 0) {
  941. +         strcpy(path,"./");
  942. +         index = 1;
  943. +         currentdir = TRUE;
  944. +     }
  945. + #endif
  946.   
  947.       /* check for an extension */
  948.       point = strlen(fspec) - 1;
  949. ***************
  950. *** 554,563 ****
  951.           closedir(dirptr);
  952.           dirptr = NULL;
  953.       }
  954. !     dirptr = opendir(path);
  955.       if (dirptr == NULL)
  956.           return(NULL);
  957.   
  958.       strcpy(rbuf, path);
  959.       nameptr = &rbuf[strlen(rbuf)];
  960.   
  961. --- 716,733 ----
  962.           closedir(dirptr);
  963.           dirptr = NULL;
  964.       }
  965. !     if (path[0])
  966. !         dirptr = opendir(path);
  967. !     else
  968. !         dirptr = opendir(".");
  969.       if (dirptr == NULL)
  970.           return(NULL);
  971.   
  972. + #if HPUX
  973. +     if (currentdir == TRUE)
  974. +         path[0] = '\0';
  975. + #endif
  976. + 
  977.       strcpy(rbuf, path);
  978.       nameptr = &rbuf[strlen(rbuf)];
  979.   
  980. ***************
  981. *** 580,591 ****
  982.       /* check to make sure we skip directory entries */
  983.       strcpy(nameptr, dp->d_name);
  984.       stat(rbuf, &fstat);
  985. !     if ((fstat.st_mode & S_IFMT) != S_IFREG)
  986.           goto nxtdir;
  987.   
  988.       /* return the next file name! */
  989.       return(rbuf);
  990.   }
  991.   #else
  992.   char *PASCAL NEAR getffile(fspec)
  993.   
  994. --- 750,766 ----
  995.       /* check to make sure we skip directory entries */
  996.       strcpy(nameptr, dp->d_name);
  997.       stat(rbuf, &fstat);
  998. !     if (((fstat.st_mode & S_IFMT) != S_IFREG) &&
  999. !         ((fstat.st_mode & S_IFMT) != S_IFDIR))
  1000.           goto nxtdir;
  1001.   
  1002. +     if ((fstat.st_mode & S_IFMT) == S_IFDIR)
  1003. +         strcat(rbuf,"/");
  1004. + 
  1005.       /* return the next file name! */
  1006.       return(rbuf);
  1007.   }
  1008. + 
  1009.   #else
  1010.   char *PASCAL NEAR getffile(fspec)
  1011.   
  1012. *** estruct.h.orig    Tue Sep 19 11:44:15 1989
  1013. --- estruct.h    Tue Sep 19 11:45:37 1989
  1014. ***************
  1015. *** 52,57 ****
  1016. --- 52,62 ----
  1017.   #define WMCS    0            /* Wicat's MCS            */
  1018.   #define    AOSVS    0            /* Data General AOS/VS        */
  1019.   
  1020. + /* Additional settings for Unix systems        */
  1021. + #define DIRENT  1            /* has POSIX <dirent.h> library    */
  1022. + #define JOBCTRL    0            /* has BSD job control        */
  1023. + #define VARARGS    1            /* has Unix <varargs.h>        */
  1024. + 
  1025.   /*    Compiler definitions            */
  1026.   /*    [Set one of these!!]            */
  1027.   #define UNIX    0    /* a random UNIX compiler */
  1028.