home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume1 / bourne / part6 < prev    next >
Internet Message Format  |  1986-11-30  |  63KB
  1. Date: Fri, 7 Jun 85 14:11:11 edt
  2. From: Arnold Robbins <gatech!arnold>
  3. Subject: Bourne shell history + tilde + job control + more (Part 6 of 9)
  4. Newsgroups: mod.sources
  5.  
  6. This is part 6 of 9.  It contains the second set of code diffs for the System V
  7. Release 2 Bourne shell.
  8.  
  9. BSD users who happen to also have source for System V Release 2 will probably
  10. want to use this version of the shell, since it has many bug fixes and
  11. improvements over the (much) earlier version that comes with Berkeley Unix.
  12.  
  13. Arnold Robbins
  14. arnold@gatech.{UUCP, CSNET}
  15. ----------- pretend your screen is really a paper towel ------------
  16. :::::::: name.c :::::::
  17. *** ../orig.u/name.c    Wed May 15 17:08:24 1985
  18. --- name.c    Tue May 21 19:02:42 1985
  19. ***************
  20. *** 15,21
  21.   struct namnod ps2nod =
  22.   {
  23.       (struct namnod *)NIL,
  24. !     &acctnod,
  25.       ps2name
  26.   };
  27.   struct namnod cdpnod = 
  28.  
  29. --- 15,21 -----
  30.   struct namnod ps2nod =
  31.   {
  32.       (struct namnod *)NIL,
  33. !     (struct namnod *)NIL,
  34.       ps2name
  35.   };
  36.   struct namnod cdpnod = 
  37. ***************
  38. *** 32,38
  39.   };
  40.   struct namnod ifsnod =
  41.   {
  42. !     &homenod,
  43.       &mailnod,
  44.       ifsname
  45.   };
  46.  
  47. --- 32,38 -----
  48.   };
  49.   struct namnod ifsnod =
  50.   {
  51. !     &histfnod,
  52.       &mailnod,
  53.       ifsname
  54.   };
  55. ***************
  56. *** 39,45
  57.   struct namnod ps1nod =
  58.   {
  59.       &pathnod,
  60. !     &ps2nod,
  61.       ps1name
  62.   };
  63.   struct namnod homenod =
  64.  
  65. --- 39,45 -----
  66.   struct namnod ps1nod =
  67.   {
  68.       &pathnod,
  69. !     &acctnod,
  70.       ps1name
  71.   };
  72.   struct namnod homenod =
  73. ***************
  74. *** 44,50
  75.   };
  76.   struct namnod homenod =
  77.   {
  78. -     &cdpnod,
  79.       (struct namnod *)NIL,
  80.       homename
  81.   };
  82.  
  83. --- 44,49 -----
  84.   };
  85.   struct namnod homenod =
  86.   {
  87.       (struct namnod *)NIL,
  88.       (struct namnod *)NIL,
  89.       homename
  90. ***************
  91. *** 46,51
  92.   {
  93.       &cdpnod,
  94.       (struct namnod *)NIL,
  95.       homename
  96.   };
  97.   struct namnod mailnod =
  98.  
  99. --- 45,51 -----
  100.   struct namnod homenod =
  101.   {
  102.       (struct namnod *)NIL,
  103. +     (struct namnod *)NIL,
  104.       homename
  105.   };
  106.   struct namnod mailnod =
  107. ***************
  108. *** 62,67
  109.   };
  110.   struct namnod acctnod =
  111.   {
  112.       (struct namnod *)NIL,
  113.       (struct namnod *)NIL,
  114.       acctname
  115.  
  116. --- 62,71 -----
  117.   };
  118.   struct namnod acctnod =
  119.   {
  120. +     &ps2nod,
  121. + #if pyr
  122. +     &univnod,
  123. + #else
  124.       (struct namnod *)NIL,
  125.   #endif
  126.       acctname
  127. ***************
  128. *** 63,69
  129.   struct namnod acctnod =
  130.   {
  131.       (struct namnod *)NIL,
  132. !     (struct namnod *)NIL,
  133.       acctname
  134.   };
  135.   struct namnod mailpnod =
  136.  
  137. --- 67,73 -----
  138.       &univnod,
  139.   #else
  140.       (struct namnod *)NIL,
  141. ! #endif
  142.       acctname
  143.   };
  144.   struct namnod mailpnod =
  145. ***************
  146. *** 72,77
  147.       (struct namnod *)NIL,
  148.       mailpname
  149.   };
  150.   
  151.   
  152.   struct namnod *namep = &mchknod;
  153.  
  154. --- 76,95 -----
  155.       (struct namnod *)NIL,
  156.       mailpname
  157.   };
  158. + struct namnod histfnod =
  159. + {
  160. +     &cdpnod,
  161. +     &homenod,
  162. +     histfilename
  163. + };
  164. + #if pyr
  165. + struct namnod univnod =
  166. + {
  167. +     (struct namnod *)NIL,
  168. +     (struct namnod *)NIL,
  169. +     univname
  170. + };
  171. + #endif
  172.   
  173.   
  174.   struct namnod *namep = &mchknod;
  175. ***************
  176. *** 86,91
  177.       int    low;
  178.       int    high;
  179.       int    mid;
  180.       register int cond;
  181.   
  182.       if (w == 0 || *w == 0)
  183.  
  184. --- 104,112 -----
  185.       int    low;
  186.       int    high;
  187.       int    mid;
  188. + #if gould
  189. +     int    cond;    /* DAG -- avoid optimizer bug */
  190. + #else
  191.       register int cond;
  192.   #endif
  193.   
  194. ***************
  195. *** 87,92
  196.       int    high;
  197.       int    mid;
  198.       register int cond;
  199.   
  200.       if (w == 0 || *w == 0)
  201.           return(0);
  202.  
  203. --- 108,114 -----
  204.       int    cond;    /* DAG -- avoid optimizer bug */
  205.   #else
  206.       register int cond;
  207. + #endif
  208.   
  209.       if (w == 0 || *w == 0)
  210.           return(0);
  211. ***************
  212. *** 228,233
  213.   readvar(names)
  214.   char    **names;
  215.   {
  216.       struct fileblk    fb;
  217.       register struct fileblk *f = &fb;
  218.       register char    c;
  219.  
  220. --- 250,256 -----
  221.   readvar(names)
  222.   char    **names;
  223.   {
  224. +     extern long lseek();    /* DAG -- bug fix (was missing) */
  225.       struct fileblk    fb;
  226.       register struct fileblk *f = &fb;
  227.       register char    c;
  228. ***************
  229. *** 238,244
  230.       push(f);
  231.       initf(dup(0));
  232.   
  233. !     if (lseek(0, 0L, 1) == -1)
  234.           f->fsiz = 1;
  235.   
  236.       /*
  237.  
  238. --- 261,267 -----
  239.       push(f);
  240.       initf(dup(0));
  241.   
  242. !     if (lseek(0, 0L, 1) == -1L)    /* DAG */
  243.           f->fsiz = 1;
  244.   
  245.       /*
  246. :::::::: name.h :::::::
  247. No differences encountered
  248. :::::::: print.c :::::::
  249. *** ../orig.u/print.c    Wed May 15 17:08:25 1985
  250. --- print.c    Mon May 20 15:32:21 1985
  251. ***************
  252. *** 7,12
  253.    */
  254.   
  255.   #include    "defs.h"
  256.   #include    <sys/param.h>
  257.   
  258.   #define        BUFLEN        256
  259.  
  260. --- 7,15 -----
  261.    */
  262.   
  263.   #include    "defs.h"
  264. + #if JOBS
  265. + #define        HZ    60
  266. + #else
  267.   #include    <sys/param.h>
  268.   #endif
  269.   
  270. ***************
  271. *** 8,13
  272.   
  273.   #include    "defs.h"
  274.   #include    <sys/param.h>
  275.   
  276.   #define        BUFLEN        256
  277.   
  278.  
  279. --- 11,17 -----
  280.   #define        HZ    60
  281.   #else
  282.   #include    <sys/param.h>
  283. + #endif
  284.   
  285.   #define        BUFLEN        256
  286.   
  287. ***************
  288. *** 66,73
  289.           prc_buff('h');
  290.       }
  291.   
  292. !     prn_buff(min);
  293. !     prc_buff('m');
  294.       prn_buff(sec);
  295.       prc_buff('s');
  296.   }
  297.  
  298. --- 70,80 -----
  299.           prc_buff('h');
  300.       }
  301.   
  302. !     if (min)    /* BRL... for consistency */
  303. !     {
  304. !         prn_buff(min);
  305. !         prc_buff('m');
  306. !     }
  307.       prn_buff(sec);
  308.       prc_buff('s');
  309.   }
  310. ***************
  311. *** 230,233
  312.       itos(n);
  313.   
  314.       prs_buff(numbuf);
  315.   }
  316.  
  317. --- 237,357 -----
  318.       itos(n);
  319.   
  320.       prs_buff(numbuf);
  321. + }
  322. + 
  323. + void
  324. + pr_prompt (str)
  325. + register char *str;
  326. + {
  327. +     for (; *str; str++)
  328. +     {
  329. +         if (*str != '%')
  330. +             prc_buff (*str);
  331. +         else if (*(str+1) == 'd')
  332. +         {
  333. +             /* current directory */
  334. +             str++;
  335. +             prs_buff (retcwd());
  336. +         }
  337. +         else if (*(str+1) == 'e')
  338. +         {
  339. +             /* event count */
  340. +             str++;
  341. +             if ((flags & nohistflg) == 0)
  342. +                 prn_buff (event_count);
  343. +         }
  344. +         else if (*(str+1) == 'h')
  345. +         {
  346. +             /* hostname */
  347. +             static char *cp = 0;
  348. +             static int didhost = FALSE;
  349. +             static int didgt = FALSE;
  350. + #ifdef JOBS
  351. +             static char buf[257];
  352. + 
  353. +             if (! didhost)
  354. +             {
  355. +                 gethostname (buf, sizeof buf);
  356. +                 didhost = TRUE;
  357. +                 cp = buf;
  358. +             }
  359. + #else
  360. + #include <sys/utsname.h>    /* has an extern declaration in it */
  361. +             static struct utsname name;
  362. + 
  363. +             if (! didhost)
  364. +             {
  365. +                 uname (& name);
  366. +                 /* avoid emulation bug */
  367. +                 name.sysname[sizeof(name.sysname)-1] = '\0';
  368. +                 didhost = TRUE;
  369. +                 cp = name.sysname;
  370. +             }
  371. + #endif
  372. + 
  373. + #ifdef GATECH
  374. +             /*
  375. +              * this is to get rid of the dumb gt- convention.
  376. +              * a gt w/out the - is also removed.
  377. +              */
  378. +             if (! didgt)
  379. +             {
  380. +                 didgt = TRUE;
  381. +                 if (cp[0] == 'g' && cp[1] == 't' && cp[2])
  382. +                 {
  383. +                     cp += 2;
  384. +                     if (cp[0] == '-' && cp[1])
  385. +                         cp++;
  386. +                 }
  387. +             }
  388. + #endif
  389. +             prs_buff (cp);
  390. +             str++;
  391. +         }
  392. +         else if (*(str+1) == 'l')
  393. +         {
  394. +             /* login name */
  395. +             static char *cp = 0;
  396. +             static int didname = FALSE;
  397. + 
  398. +             str++;
  399. +             if (! didname)
  400. +             {
  401. +                 cp = username ();
  402. +                 didname = TRUE;
  403. +             }
  404. + 
  405. +             if (cp)
  406. +                 prs_buff (cp);
  407. +         }
  408. +         else if (*(str+1) == 't')
  409. +         {
  410. +             /* current time, HH:MM */
  411. +             long l;
  412. +             char *cp, *ctime ();
  413. + 
  414. +             str++;
  415. +             time (& l);
  416. +             cp = ctime (& l);
  417. +             cp[16] = '\0';
  418. +             cp += 11;
  419. +             prs_buff (cp);
  420. +         }
  421. + #if pyr
  422. +         else if (*(str+1) == 'u')
  423. +         {
  424. +             /* current univeserse */
  425. +             str++;
  426. +             prs_buff (univ_name[cur_univ-1]);
  427. +         }
  428. + #endif
  429. +         else if (*(str+1) == '\0')    /* % was last char in string */
  430. +         {
  431. +             prc_buff (*str);
  432. +             continue;
  433. +         }
  434. +         else
  435. +             prc_buff (*(++str));
  436. +     }
  437. +     flushb();
  438.   }
  439. :::::::: profile.c :::::::
  440. No differences encountered
  441. :::::::: pwd.c :::::::
  442. *** ../orig.u/pwd.c    Wed May 15 17:08:27 1985
  443. --- pwd.c    Mon May 20 17:20:51 1985
  444. ***************
  445. *** 4,9
  446.    *
  447.    *    Bell Telephone Laboratories
  448.    *
  449.    */
  450.   
  451.   #include        "mac.h"
  452.  
  453. --- 4,14 -----
  454.    *
  455.    *    Bell Telephone Laboratories
  456.    *
  457. +  *    DAG -- Two ways of handling symbolic links in directory paths:
  458. +  *        Define SYMLINK if you want "cd .." to do just that.
  459. +  *        Otherwise, "cd .." takes you back the way you came.
  460. +  *    The first method was implemented by Ron Natalie and the
  461. +  *    second method was implemented by Douglas Gwyn, both of BRL.
  462.    */
  463.   
  464.   #include        "defs.h"    /* DAG -- was just "mac.h" */
  465. ***************
  466. *** 6,12
  467.    *
  468.    */
  469.   
  470. ! #include        "mac.h"
  471.   
  472.   #define    DOT        '.'
  473.   #define    NULL    0
  474.  
  475. --- 11,19 -----
  476.    *    second method was implemented by Douglas Gwyn, both of BRL.
  477.    */
  478.   
  479. ! #include        "defs.h"    /* DAG -- was just "mac.h" */
  480. ! #include    <sys/types.h>        /* DAG -- moved for SYMLINK */
  481. ! #include    <sys/stat.h>        /* DAG -- moved for SYMLINK */
  482.   
  483.   #if defined(SYMLINK) && !defined(S_IFLNK)
  484.   #define    S_IFLNK    0120000
  485. ***************
  486. *** 8,13
  487.   
  488.   #include        "mac.h"
  489.   
  490.   #define    DOT        '.'
  491.   #define    NULL    0
  492.   #define    SLASH    '/'
  493.  
  494. --- 15,24 -----
  495.   #include    <sys/types.h>        /* DAG -- moved for SYMLINK */
  496.   #include    <sys/stat.h>        /* DAG -- moved for SYMLINK */
  497.   
  498. + #if defined(SYMLINK) && !defined(S_IFLNK)
  499. + #define    S_IFLNK    0120000
  500. + #endif
  501. + 
  502.   #define    DOT        '.'
  503.   #define    NULL    0
  504.   #define    SLASH    '/'
  505. ***************
  506. *** 11,16
  507.   #define    DOT        '.'
  508.   #define    NULL    0
  509.   #define    SLASH    '/'
  510.   #define MAXPWD    256
  511.   
  512.   extern char    longpwd[];
  513.  
  514. --- 22,30 -----
  515.   #define    DOT        '.'
  516.   #define    NULL    0
  517.   #define    SLASH    '/'
  518. + #if defined(JOBS)
  519. + #define MAXPWD    (24*256)    /* who knows */
  520. + #else
  521.   #define MAXPWD    256
  522.   #endif
  523.   
  524. ***************
  525. *** 12,17
  526.   #define    NULL    0
  527.   #define    SLASH    '/'
  528.   #define MAXPWD    256
  529.   
  530.   extern char    longpwd[];
  531.   
  532.  
  533. --- 26,32 -----
  534.   #define MAXPWD    (24*256)    /* who knows */
  535.   #else
  536.   #define MAXPWD    256
  537. + #endif
  538.   
  539.   extern char    longpwd[];
  540.   
  541. ***************
  542. *** 17,22
  543.   
  544.   static char cwdname[MAXPWD];
  545.   static int     didpwd = FALSE;
  546.   
  547.   cwd(dir)
  548.       register char *dir;
  549.  
  550. --- 32,41 -----
  551.   
  552.   static char cwdname[MAXPWD];
  553.   static int     didpwd = FALSE;
  554. + #if SYMLINK
  555. + /* Stuff to handle chdirs around symbolic links */
  556. + static char    *symlink = 0;    /* Pointer to after last symlink in cwdname */
  557. + #endif
  558.   
  559.   cwd(dir)
  560.       register char *dir;
  561. ***************
  562. *** 21,26
  563.   cwd(dir)
  564.       register char *dir;
  565.   {
  566.       register char *pcwd;
  567.       register char *pdir;
  568.   
  569.  
  570. --- 40,48 -----
  571.   cwd(dir)
  572.       register char *dir;
  573.   {
  574. + #if SYMLINK
  575. +     struct stat statb;
  576. + #endif
  577.       register char *pcwd;
  578.       register char *pdir;
  579.   
  580. ***************
  581. *** 44,51
  582.           if (*pdir) 
  583.               pdir++;
  584.       }
  585. !     if(*(--pdir)==DOT && pdir>dir && *(--pdir)==SLASH)
  586. !         *pdir = NULL;
  587.       
  588.   
  589.       /* Remove extra /'s */
  590.  
  591. --- 66,73 -----
  592.           if (*pdir) 
  593.               pdir++;
  594.       }
  595. !     if(pdir>dir && *(--pdir)==DOT && pdir>dir && *(--pdir)==SLASH)    /* DAG -- bug fix (added first test) */
  596. !         *pdir = '\0';    /* DAG -- not NULL */
  597.       
  598.   
  599.       /* Remove extra /'s */
  600. ***************
  601. *** 65,70
  602.   
  603.           pcwd = cwdname;
  604.           didpwd = TRUE;
  605.       }
  606.       else
  607.       {
  608.  
  609. --- 87,95 -----
  610.   
  611.           pcwd = cwdname;
  612.           didpwd = TRUE;
  613. + #if SYMLINK
  614. +         symlink = 0;        /* Starting over, no links yet */
  615. + #endif
  616.       }
  617.       else
  618.       {
  619. ***************
  620. *** 71,76
  621.           /* Relative path */
  622.   
  623.           if (didpwd == FALSE) 
  624.               return;
  625.               
  626.           pcwd = cwdname + length(cwdname) - 1;
  627.  
  628. --- 96,104 -----
  629.           /* Relative path */
  630.   
  631.           if (didpwd == FALSE) 
  632. + #if !defined(SYMLINK) && defined(JOBS)
  633. +             pwd();        /* Get absolute pathname into cwdname[] */
  634. + #else
  635.               return;
  636.   #endif
  637.               
  638. ***************
  639. *** 72,77
  640.   
  641.           if (didpwd == FALSE) 
  642.               return;
  643.               
  644.           pcwd = cwdname + length(cwdname) - 1;
  645.           if(pcwd != cwdname+1)
  646.  
  647. --- 100,106 -----
  648.               pwd();        /* Get absolute pathname into cwdname[] */
  649.   #else
  650.               return;
  651. + #endif
  652.               
  653.           pcwd = cwdname + length(cwdname) - 1;
  654.           if(pcwd != cwdname+1)
  655. ***************
  656. *** 93,98
  657.                   ;
  658.               pcwd++;
  659.               dir += 2;
  660.               if(*dir==SLASH)
  661.               {
  662.                   dir++;
  663.  
  664. --- 122,135 -----
  665.                   ;
  666.               pcwd++;
  667.               dir += 2;
  668. + #if SYMLINK
  669. +             /* Just undid symlink, so pwd the hard way */
  670. +             if(pcwd < symlink)
  671. +             {
  672. +                 pwd();
  673. +                 return;
  674. +             }
  675. + #endif
  676.               if(*dir==SLASH)
  677.               {
  678.                   dir++;
  679. ***************
  680. *** 102,107
  681.           *pcwd++ = *dir++;
  682.           while((*dir) && (*dir != SLASH))
  683.               *pcwd++ = *dir++;
  684.           if (*dir) 
  685.               *pcwd++ = *dir++;
  686.       }
  687.  
  688. --- 139,161 -----
  689.           *pcwd++ = *dir++;
  690.           while((*dir) && (*dir != SLASH))
  691.               *pcwd++ = *dir++;
  692. + #if SYMLINK
  693. +         /* Check to see if this path component is a symbolic link */
  694. +         *pcwd = 0;
  695. +         if(lstat(cwdname, &statb) != 0)
  696. +         {
  697. +             prs(cwdname);    /* DAG */
  698. +             error(nolstat);    /* DAG -- made string sharable */
  699. +             pwd();
  700. +             return;
  701. +         }
  702. +         if((statb.st_mode & S_IFMT) == S_IFLNK)
  703. +             /* Set fence so that when we attempt to
  704. +              * "cd .." past it, we know that it is invalid
  705. +              * and have to do it the hard way
  706. +              */
  707. +             symlink = dir;
  708. + #endif
  709.           if (*dir) 
  710.               *pcwd++ = *dir++;
  711.       }
  712. ***************
  713. *** 105,111
  714.           if (*dir) 
  715.               *pcwd++ = *dir++;
  716.       }
  717. !     *pcwd = NULL;
  718.   
  719.       --pcwd;
  720.       if(pcwd>cwdname && *pcwd==SLASH)
  721.  
  722. --- 159,165 -----
  723.           if (*dir) 
  724.               *pcwd++ = *dir++;
  725.       }
  726. !     *pcwd = '\0';    /* DAG -- not NULL */
  727.   
  728.       --pcwd;
  729.       if(pcwd>cwdname && *pcwd==SLASH)
  730. ***************
  731. *** 112,118
  732.       {
  733.           /* Remove trailing / */
  734.   
  735. !         *pcwd = NULL;
  736.       }
  737.       return;
  738.   }
  739.  
  740. --- 166,172 -----
  741.       {
  742.           /* Remove trailing / */
  743.   
  744. !         *pcwd = '\0';    /* DAG -- not NULL */
  745.       }
  746.       return;
  747.   }
  748. ***************
  749. *** 168,174
  750.    *    Find the current directory the hard way.
  751.    */
  752.   
  753. ! #include    <sys/types.h>
  754.   #include    <sys/dir.h>
  755.   #include    <sys/stat.h>
  756.   
  757.  
  758. --- 222,230 -----
  759.    *    Find the current directory the hard way.
  760.    */
  761.   
  762. ! #if JOBS
  763. ! #include    <dir.h>
  764. ! #else
  765.   #include    <sys/dir.h>
  766.   #endif
  767.   
  768. ***************
  769. *** 170,176
  770.   
  771.   #include    <sys/types.h>
  772.   #include    <sys/dir.h>
  773. ! #include    <sys/stat.h>
  774.   
  775.   
  776.   static char dotdots[] =
  777.  
  778. --- 226,232 -----
  779.   #include    <dir.h>
  780.   #else
  781.   #include    <sys/dir.h>
  782. ! #endif
  783.   
  784.   
  785.   static char dotdots[] =
  786. ***************
  787. *** 176,181
  788.   static char dotdots[] =
  789.   "../../../../../../../../../../../../../../../../../../../../../../../..";
  790.   
  791.   extern struct direct    *getdir();
  792.   extern char        *movstrn();
  793.   
  794.  
  795. --- 232,240 -----
  796.   static char dotdots[] =
  797.   "../../../../../../../../../../../../../../../../../../../../../../../..";
  798.   
  799. + #if JOBS
  800. + #define    getdir(dirf)    readdir(dirf)
  801. + #else
  802.   extern struct direct    *getdir();
  803.   extern char        *movstrn();
  804.   #endif
  805. ***************
  806. *** 178,183
  807.   
  808.   extern struct direct    *getdir();
  809.   extern char        *movstrn();
  810.   
  811.   static
  812.   pwd()
  813.  
  814. --- 237,243 -----
  815.   #else
  816.   extern struct direct    *getdir();
  817.   extern char        *movstrn();
  818. + #endif
  819.   
  820.   static
  821.   pwd()
  822. ***************
  823. *** 185,190
  824.       struct stat        cdir;    /* current directory status */
  825.       struct stat        tdir;
  826.       struct stat        pdir;    /* parent directory status */
  827.       int                pdfd;    /* parent directory file descriptor */
  828.   
  829.       struct direct    *dir;
  830.  
  831. --- 245,253 -----
  832.       struct stat        cdir;    /* current directory status */
  833.       struct stat        tdir;
  834.       struct stat        pdir;    /* parent directory status */
  835. + #if JOBS
  836. +     DIR                *pdfd;    /* parent directory stream */
  837. + #else
  838.       int                pdfd;    /* parent directory file descriptor */
  839.   #endif
  840.   
  841. ***************
  842. *** 186,191
  843.       struct stat        tdir;
  844.       struct stat        pdir;    /* parent directory status */
  845.       int                pdfd;    /* parent directory file descriptor */
  846.   
  847.       struct direct    *dir;
  848.       char             *dot = dotdots + sizeof(dotdots) - 3;
  849.  
  850. --- 249,255 -----
  851.       DIR                *pdfd;    /* parent directory stream */
  852.   #else
  853.       int                pdfd;    /* parent directory file descriptor */
  854. + #endif
  855.   
  856.       struct direct    *dir;
  857.       char             *dot = dotdots + sizeof(dotdots) - 3;
  858. ***************
  859. *** 193,198
  860.       int                cwdindex = MAXPWD - 1;
  861.       int             i;
  862.       
  863.       cwdname[cwdindex] = 0;
  864.       dotdots[index] = 0;
  865.   
  866.  
  867. --- 257,265 -----
  868.       int                cwdindex = MAXPWD - 1;
  869.       int             i;
  870.       
  871. + #if SYMLINK
  872. +     symlink = 0;            /* Starting over, no links yet */
  873. + #endif
  874.       cwdname[cwdindex] = 0;
  875.       dotdots[index] = 0;
  876.   
  877. ***************
  878. *** 206,212
  879.       for(;;)
  880.       {
  881.           cdir = pdir;
  882. ! 
  883.           if ((pdfd = open(dot, 0)) < 0)
  884.           {
  885.               error("pwd: cannot open ..");
  886.  
  887. --- 273,281 -----
  888.       for(;;)
  889.       {
  890.           cdir = pdir;
  891. ! #if JOBS
  892. !         if ((pdfd = opendir(dot)) == (DIR *)0)
  893. ! #else
  894.           if ((pdfd = open(dot, 0)) < 0)
  895.   #endif
  896.           {
  897. ***************
  898. *** 208,213
  899.           cdir = pdir;
  900.   
  901.           if ((pdfd = open(dot, 0)) < 0)
  902.           {
  903.               error("pwd: cannot open ..");
  904.           }
  905.  
  906. --- 277,283 -----
  907.           if ((pdfd = opendir(dot)) == (DIR *)0)
  908.   #else
  909.           if ((pdfd = open(dot, 0)) < 0)
  910. + #endif
  911.           {
  912.               error("pwd: cannot open ..");
  913.           }
  914. ***************
  915. *** 211,217
  916.           {
  917.               error("pwd: cannot open ..");
  918.           }
  919. ! 
  920.           if(fstat(pdfd, &pdir) < 0)
  921.           {
  922.               close(pdfd);
  923.  
  924. --- 281,289 -----
  925.           {
  926.               error("pwd: cannot open ..");
  927.           }
  928. ! #if JOBS
  929. !         if(fstat(pdfd->dd_fd, &pdir) < 0)
  930. ! #else
  931.           if(fstat(pdfd, &pdir) < 0)
  932.   #endif
  933.           {
  934. ***************
  935. *** 213,218
  936.           }
  937.   
  938.           if(fstat(pdfd, &pdir) < 0)
  939.           {
  940.               close(pdfd);
  941.               error("pwd: cannot stat ..");
  942.  
  943. --- 285,291 -----
  944.           if(fstat(pdfd->dd_fd, &pdir) < 0)
  945.   #else
  946.           if(fstat(pdfd, &pdir) < 0)
  947. + #endif
  948.           {
  949.   #if JOBS
  950.               closedir(pdfd);
  951. ***************
  952. *** 214,219
  953.   
  954.           if(fstat(pdfd, &pdir) < 0)
  955.           {
  956.               close(pdfd);
  957.               error("pwd: cannot stat ..");
  958.           }
  959.  
  960. --- 287,295 -----
  961.           if(fstat(pdfd, &pdir) < 0)
  962.   #endif
  963.           {
  964. + #if JOBS
  965. +             closedir(pdfd);
  966. + #else
  967.               close(pdfd);
  968.   #endif
  969.               error("pwd: cannot stat ..");
  970. ***************
  971. *** 215,220
  972.           if(fstat(pdfd, &pdir) < 0)
  973.           {
  974.               close(pdfd);
  975.               error("pwd: cannot stat ..");
  976.           }
  977.   
  978.  
  979. --- 291,297 -----
  980.               closedir(pdfd);
  981.   #else
  982.               close(pdfd);
  983. + #endif
  984.               error("pwd: cannot stat ..");
  985.           }
  986.   
  987. ***************
  988. *** 223,228
  989.               if(cdir.st_ino == pdir.st_ino)
  990.               {
  991.                   didpwd = TRUE;
  992.                   close(pdfd);
  993.                   if (cwdindex == (MAXPWD - 1))
  994.                       cwdname[--cwdindex] = SLASH;
  995.  
  996. --- 300,308 -----
  997.               if(cdir.st_ino == pdir.st_ino)
  998.               {
  999.                   didpwd = TRUE;
  1000. + #if JOBS
  1001. +                 closedir(pdfd);
  1002. + #else
  1003.                   close(pdfd);
  1004.   #endif
  1005.                   if (cwdindex == (MAXPWD - 1))
  1006. ***************
  1007. *** 224,229
  1008.               {
  1009.                   didpwd = TRUE;
  1010.                   close(pdfd);
  1011.                   if (cwdindex == (MAXPWD - 1))
  1012.                       cwdname[--cwdindex] = SLASH;
  1013.   
  1014.  
  1015. --- 304,310 -----
  1016.                   closedir(pdfd);
  1017.   #else
  1018.                   close(pdfd);
  1019. + #endif
  1020.                   if (cwdindex == (MAXPWD - 1))
  1021.                       cwdname[--cwdindex] = SLASH;
  1022.   
  1023. ***************
  1024. *** 235,240
  1025.               {
  1026.                   if ((dir = getdir(pdfd)) == 0)
  1027.                   {
  1028.                       close(pdfd);
  1029.                       reset_dir();
  1030.                       error("pwd: read error in ..");
  1031.  
  1032. --- 316,324 -----
  1033.               {
  1034.                   if ((dir = getdir(pdfd)) == 0)
  1035.                   {
  1036. + #if JOBS
  1037. +                     closedir(pdfd);
  1038. + #else
  1039.                       close(pdfd);
  1040.                       reset_dir();
  1041.   #endif
  1042. ***************
  1043. *** 237,242
  1044.                   {
  1045.                       close(pdfd);
  1046.                       reset_dir();
  1047.                       error("pwd: read error in ..");
  1048.                   }
  1049.               }
  1050.  
  1051. --- 321,327 -----
  1052.   #else
  1053.                       close(pdfd);
  1054.                       reset_dir();
  1055. + #endif
  1056.                       error("pwd: read error in ..");
  1057.                   }
  1058.               }
  1059. ***************
  1060. *** 244,250
  1061.           }
  1062.           else
  1063.           {
  1064. !             char name[512];
  1065.               
  1066.               movstr(dot, name);
  1067.               i = length(name) - 1;
  1068.  
  1069. --- 329,335 -----
  1070.           }
  1071.           else
  1072.           {
  1073. !             char name[256+MAXPWD];    /* DAG -- (was 512) */
  1074.               
  1075.               movstr(dot, name);
  1076.               i = length(name) - 1;
  1077. ***************
  1078. *** 251,256
  1079.   
  1080.               name[i++] = '/';
  1081.   
  1082.               do
  1083.               {
  1084.                   if ((dir = getdir(pdfd)) == 0)
  1085.  
  1086. --- 336,342 -----
  1087.   
  1088.               name[i++] = '/';
  1089.   
  1090. +             tdir.st_dev = pdir.st_dev;    /* DAG -- (safety) */
  1091.               do
  1092.               {
  1093.                   if ((dir = getdir(pdfd)) == 0)
  1094. ***************
  1095. *** 255,260
  1096.               {
  1097.                   if ((dir = getdir(pdfd)) == 0)
  1098.                   {
  1099.                       close(pdfd);
  1100.                       reset_dir();
  1101.                       error("pwd: read error in ..");
  1102.  
  1103. --- 341,349 -----
  1104.               {
  1105.                   if ((dir = getdir(pdfd)) == 0)
  1106.                   {
  1107. + #if JOBS
  1108. +                     closedir(pdfd);
  1109. + #else
  1110.                       close(pdfd);
  1111.                       reset_dir();
  1112.   #endif
  1113. ***************
  1114. *** 257,262
  1115.                   {
  1116.                       close(pdfd);
  1117.                       reset_dir();
  1118.                       error("pwd: read error in ..");
  1119.                   }
  1120.                   *(movstrn(dir->d_name, &name[i], DIRSIZ)) = 0;
  1121.  
  1122. --- 346,352 -----
  1123.   #else
  1124.                       close(pdfd);
  1125.                       reset_dir();
  1126. + #endif
  1127.                       error("pwd: read error in ..");
  1128.                   }
  1129.   #if JOBS
  1130. ***************
  1131. *** 259,264
  1132.                       reset_dir();
  1133.                       error("pwd: read error in ..");
  1134.                   }
  1135.                   *(movstrn(dir->d_name, &name[i], DIRSIZ)) = 0;
  1136.                   stat(name, &tdir);
  1137.               }        
  1138.  
  1139. --- 349,357 -----
  1140.   #endif
  1141.                       error("pwd: read error in ..");
  1142.                   }
  1143. + #if JOBS
  1144. +                 movstr(dir->d_name, &name[i]);
  1145. + #else
  1146.                   *(movstrn(dir->d_name, &name[i], DIRSIZ)) = 0;
  1147.   #endif
  1148.                   stat(name, &tdir);
  1149. ***************
  1150. *** 260,265
  1151.                       error("pwd: read error in ..");
  1152.                   }
  1153.                   *(movstrn(dir->d_name, &name[i], DIRSIZ)) = 0;
  1154.                   stat(name, &tdir);
  1155.               }        
  1156.               while(tdir.st_ino != cdir.st_ino || tdir.st_dev != cdir.st_dev);
  1157.  
  1158. --- 353,359 -----
  1159.                   movstr(dir->d_name, &name[i]);
  1160.   #else
  1161.                   *(movstrn(dir->d_name, &name[i], DIRSIZ)) = 0;
  1162. + #endif
  1163.                   stat(name, &tdir);
  1164.               }        
  1165.               while(tdir.st_ino != cdir.st_ino || tdir.st_dev != cdir.st_dev);
  1166. ***************
  1167. *** 264,269
  1168.               }        
  1169.               while(tdir.st_ino != cdir.st_ino || tdir.st_dev != cdir.st_dev);
  1170.           }
  1171.           close(pdfd);
  1172.           reset_dir();
  1173.   
  1174.  
  1175. --- 358,366 -----
  1176.               }        
  1177.               while(tdir.st_ino != cdir.st_ino || tdir.st_dev != cdir.st_dev);
  1178.           }
  1179. + #if JOBS
  1180. +         closedir(pdfd);
  1181. + #else
  1182.           close(pdfd);
  1183.           reset_dir();
  1184.   #endif
  1185. ***************
  1186. *** 266,271
  1187.           }
  1188.           close(pdfd);
  1189.           reset_dir();
  1190.   
  1191.           for (i = 0; i < DIRSIZ; i++)
  1192.               if (dir->d_name[i] == 0)
  1193.  
  1194. --- 363,369 -----
  1195.   #else
  1196.           close(pdfd);
  1197.           reset_dir();
  1198. + #endif
  1199.   
  1200.   #if JOBS
  1201.           i = dir->d_namlen;
  1202. ***************
  1203. *** 267,272
  1204.           close(pdfd);
  1205.           reset_dir();
  1206.   
  1207.           for (i = 0; i < DIRSIZ; i++)
  1208.               if (dir->d_name[i] == 0)
  1209.                   break;
  1210.  
  1211. --- 365,373 -----
  1212.           reset_dir();
  1213.   #endif
  1214.   
  1215. + #if JOBS
  1216. +         i = dir->d_namlen;
  1217. + #else
  1218.           for (i = 0; i < DIRSIZ; i++)
  1219.               if (dir->d_name[i] == 0)
  1220.                   break;
  1221. ***************
  1222. *** 270,275
  1223.           for (i = 0; i < DIRSIZ; i++)
  1224.               if (dir->d_name[i] == 0)
  1225.                   break;
  1226.   
  1227.           if (i > cwdindex - 1)
  1228.                   error(longpwd);
  1229.  
  1230. --- 371,377 -----
  1231.           for (i = 0; i < DIRSIZ; i++)
  1232.               if (dir->d_name[i] == 0)
  1233.                   break;
  1234. + #endif
  1235.   
  1236.           if (i > cwdindex - 1)
  1237.                   error(longpwd);
  1238. ***************
  1239. *** 284,287
  1240.           if (dot<dotdots) 
  1241.               error(longpwd);
  1242.       }
  1243.   }
  1244.  
  1245. --- 386,419 -----
  1246.           if (dot<dotdots) 
  1247.               error(longpwd);
  1248.       }
  1249. + }
  1250. + #if !defined(SYMLINK) && defined(JOBS)
  1251. + 
  1252. + /* The following chdir() interface is used to outwit symbolic links. */
  1253. + 
  1254. + int
  1255. + cwdir( dir )                /* attempt a full-pathname chdir */
  1256. +     char        *dir;        /* name to feed to chdir() */
  1257. +     {
  1258. +     char        savname[MAXPWD];    /* saved cwdname[] */
  1259. +     register int    retval;        /* chdir() return value */
  1260. + 
  1261. +     (void)movstr( cwdname, savname );    /* save current name */
  1262. + 
  1263. +     cwd( dir );            /* adjust cwdname[] */
  1264. + 
  1265. +     if ( (retval = chdir( cwdname )) < 0 )
  1266. +         (void)movstr( savname, cwdname );    /* restore name */
  1267. + 
  1268. +     return retval;
  1269. +     }
  1270. + #endif
  1271. + 
  1272. + char *
  1273. + retcwd()
  1274. + {
  1275. +     if (didpwd == FALSE)
  1276. +         pwd ();
  1277. +     
  1278. +     return (cwdname);
  1279.   }
  1280. :::::::: service.c :::::::
  1281. *** ../orig.u/service.c    Wed May 15 17:08:28 1985
  1282. --- service.c    Wed May 29 15:54:16 1985
  1283. ***************
  1284. *** 8,13
  1285.   
  1286.   #include    "defs.h"
  1287.   #include    <errno.h>
  1288.   
  1289.   #define ARGMK    01
  1290.   
  1291.  
  1292. --- 8,17 -----
  1293.   
  1294.   #include    "defs.h"
  1295.   #include    <errno.h>
  1296. + #if JOBS
  1297. + extern int    errno;
  1298. + #include    "/usr/include/sys/wait.h"
  1299. + #endif
  1300.   
  1301.   #define ARGMK    01
  1302.   
  1303. ***************
  1304. *** 24,29
  1305.       struct ionod    *iop;
  1306.       int        save;
  1307.   {
  1308.       register char    *ion;
  1309.       register int    iof, fd;
  1310.       int        ioufd;
  1311.  
  1312. --- 28,34 -----
  1313.       struct ionod    *iop;
  1314.       int        save;
  1315.   {
  1316. +     extern long    lseek();    /* DAG -- bug fix (was missing) */
  1317.       register char    *ion;
  1318.       register int    iof, fd;
  1319.       int        ioufd;
  1320. ***************
  1321. *** 70,75
  1322.                   else
  1323.                       fd = dup(fd);
  1324.               }
  1325.               else if ((iof & IOPUT) == 0)
  1326.                   fd = chkopen(ion);
  1327.               else if (flags & rshflg)
  1328.  
  1329. --- 75,85 -----
  1330.                   else
  1331.                       fd = dup(fd);
  1332.               }
  1333. +             else if (iof & IORDW)
  1334. +             {
  1335. +                 if ((fd = open(ion, 2)) < 0)
  1336. +                     failed(ion, badopen);
  1337. +             }
  1338.               else if ((iof & IOPUT) == 0)
  1339.                   fd = chkopen(ion);
  1340.               else if (flags & rshflg)
  1341. ***************
  1342. *** 145,150
  1343.        */
  1344.       register char    *scanp = path;
  1345.       register char    *argp = locstak();
  1346.   
  1347.       while (*scanp && *scanp != COLON)
  1348.           *argp++ = *scanp++;
  1349.  
  1350. --- 155,162 -----
  1351.        */
  1352.       register char    *scanp = path;
  1353.       register char    *argp = locstak();
  1354. +     char    *save = argp;
  1355. +     char    *cp;
  1356.   
  1357.       while (*scanp && *scanp != COLON)
  1358.           *argp++ = *scanp++;
  1359. ***************
  1360. *** 148,153
  1361.   
  1362.       while (*scanp && *scanp != COLON)
  1363.           *argp++ = *scanp++;
  1364.       if (scanp != path)
  1365.           *argp++ = '/';
  1366.       if (*scanp == COLON)
  1367.  
  1368. --- 160,172 -----
  1369.   
  1370.       while (*scanp && *scanp != COLON)
  1371.           *argp++ = *scanp++;
  1372. +     *argp = '\0';
  1373. +     /* try a tilde expansion */
  1374. +     if (*save == SQUIGGLE && (cp = homedir (save + 1)) != nullstr)
  1375. +     {
  1376. +         movstr (cp, save);
  1377. +         argp = save + length (save) - 1;
  1378. +     }
  1379.       if (scanp != path)
  1380.           *argp++ = '/';
  1381.       if (*scanp == COLON)
  1382. ***************
  1383. *** 232,237
  1384.           if (input)
  1385.               close(input);
  1386.           input = chkopen(p);
  1387.       
  1388.   #ifdef ACCT
  1389.           preacct(p);    /* reset accounting */
  1390.  
  1391. --- 251,271 -----
  1392.           if (input)
  1393.               close(input);
  1394.           input = chkopen(p);
  1395. + #if JOBS
  1396. +         /* don't try to interpret directories etc. */
  1397. +         {
  1398. + #include    <sys/types.h>
  1399. + #include    <sys/stat.h>
  1400. +             struct stat    sbuf;
  1401. + 
  1402. +             if (fstat(input, &sbuf) == 0
  1403. +                 && (sbuf.st_mode&S_IFMT) != S_IFREG)
  1404. +             {
  1405. +                 close (input);
  1406. +                 goto def;    /* badexec unless other found */
  1407. +             }
  1408. +         }
  1409. + #endif
  1410.       
  1411.   #ifdef ACCT
  1412.           preacct(p);    /* reset accounting */
  1413. ***************
  1414. *** 254,259
  1415.           failed(p, txtbsy);
  1416.   
  1417.       default:
  1418.           xecmsg = badexec;
  1419.       case ENOENT:
  1420.           return(prefix);
  1421.  
  1422. --- 288,296 -----
  1423.           failed(p, txtbsy);
  1424.   
  1425.       default:
  1426. + #if JOBS
  1427. +     def:
  1428. + #endif
  1429.           xecmsg = badexec;
  1430.       case ENOENT:
  1431.           return(prefix);
  1432. ***************
  1433. *** 268,273
  1434.   static int    pwlist[MAXP];
  1435.   static int    pwc;
  1436.   
  1437.   postclr()
  1438.   {
  1439.       register int    *pw = pwlist;
  1440.  
  1441. --- 305,355 -----
  1442.   static int    pwlist[MAXP];
  1443.   static int    pwc;
  1444.   
  1445. + #if JOBS
  1446. + static int    *wf_pwlist;
  1447. + static int    wf_pwc;
  1448. + 
  1449. + void
  1450. + set_wfence()
  1451. + {
  1452. +     wf_pwlist = &pwlist[pwc];
  1453. +     wf_pwc = 0;
  1454. + }
  1455. + 
  1456. + BOOL
  1457. + unpost(pcsid)
  1458. +     int    pcsid;
  1459. + {
  1460. +     register int    *pw = pwlist;
  1461. + 
  1462. +     if (pcsid)
  1463. +     {
  1464. +         while (pw <= &pwlist[pwc])
  1465. +         {
  1466. +             if (pcsid == *pw)
  1467. +             {
  1468. +                 if (pw >= wf_pwlist)
  1469. +                     wf_pwc--;
  1470. +                 else
  1471. +                     wf_pwlist--;
  1472. +                 while (pw <= &pwlist[pwc])
  1473. +                 {
  1474. +                     *pw = pw[1];
  1475. +                     pw++;
  1476. +                 }
  1477. +                 pw[pwc] = 0;
  1478. +                 pwc--;
  1479. +                 return TRUE;
  1480. +             }
  1481. +             pw++;
  1482. +         }
  1483. +         return FALSE;
  1484. +     }
  1485. +     else
  1486. +         return TRUE;
  1487. + }
  1488. + #endif
  1489. + 
  1490.   postclr()
  1491.   {
  1492.       register int    *pw = pwlist;
  1493. ***************
  1494. *** 273,278
  1495.       register int    *pw = pwlist;
  1496.   
  1497.       while (pw <= &pwlist[pwc])
  1498.           *pw++ = 0;
  1499.       pwc = 0;
  1500.   }
  1501.  
  1502. --- 355,364 -----
  1503.       register int    *pw = pwlist;
  1504.   
  1505.       while (pw <= &pwlist[pwc])
  1506. +     {
  1507. + #if JOBS
  1508. +         j_child_clear(*pw);
  1509. + #endif
  1510.           *pw++ = 0;
  1511.       }
  1512.       pwc = 0;
  1513. ***************
  1514. *** 274,279
  1515.   
  1516.       while (pw <= &pwlist[pwc])
  1517.           *pw++ = 0;
  1518.       pwc = 0;
  1519.   }
  1520.   
  1521.  
  1522. --- 360,366 -----
  1523.           j_child_clear(*pw);
  1524.   #endif
  1525.           *pw++ = 0;
  1526. +     }
  1527.       pwc = 0;
  1528.   }
  1529.   
  1530. ***************
  1531. *** 285,291
  1532.       if (pcsid)
  1533.       {
  1534.           while (*pw)
  1535. !             pw++;
  1536.           if (pwc >= MAXP - 1)
  1537.               pw--;
  1538.           else
  1539.  
  1540. --- 372,383 -----
  1541.       if (pcsid)
  1542.       {
  1543.           while (*pw)
  1544. ! #if JOBS
  1545. !             if (pcsid == *pw)
  1546. !                 return;
  1547. !             else
  1548. ! #endif
  1549. !                 pw++;
  1550.           if (pwc >= MAXP - 1)
  1551.               pw--;
  1552.           else
  1553. ***************
  1554. *** 289,294
  1555.           if (pwc >= MAXP - 1)
  1556.               pw--;
  1557.           else
  1558.               pwc++;
  1559.           *pw = pcsid;
  1560.       }
  1561.  
  1562. --- 381,387 -----
  1563.           if (pwc >= MAXP - 1)
  1564.               pw--;
  1565.           else
  1566. +         {
  1567.               pwc++;
  1568.   #if JOBS
  1569.               wf_pwc++;
  1570. ***************
  1571. *** 290,295
  1572.               pw--;
  1573.           else
  1574.               pwc++;
  1575.           *pw = pcsid;
  1576.       }
  1577.   }
  1578.  
  1579. --- 383,392 -----
  1580.           else
  1581.           {
  1582.               pwc++;
  1583. + #if JOBS
  1584. +             wf_pwc++;
  1585. + #endif
  1586. +         }
  1587.           *pw = pcsid;
  1588.       }
  1589.   }
  1590. ***************
  1591. *** 297,302
  1592.   await(i, bckg)
  1593.   int    i, bckg;
  1594.   {
  1595.       int    rc = 0, wx = 0;
  1596.       int    w;
  1597.       int    ipwc = pwc;
  1598.  
  1599. --- 394,404 -----
  1600.   await(i, bckg)
  1601.   int    i, bckg;
  1602.   {
  1603. + #if JOBS
  1604. + #include    "/usr/include/sys/time.h"
  1605. + #include    "/usr/include/sys/resource.h"
  1606. +     struct rusage    ru;
  1607. + #endif
  1608.       int    rc = 0, wx = 0;
  1609.       int    w;
  1610.       int    ipwc = pwc;
  1611. ***************
  1612. *** 300,305
  1613.       int    rc = 0, wx = 0;
  1614.       int    w;
  1615.       int    ipwc = pwc;
  1616.   
  1617.       post(i);
  1618.       while (pwc)
  1619.  
  1620. --- 402,409 -----
  1621.       int    rc = 0, wx = 0;
  1622.       int    w;
  1623.       int    ipwc = pwc;
  1624. + #if JOBS
  1625. +     BOOL    update_only = i == -2;
  1626.   
  1627.       if (update_only)
  1628.           i = -1;
  1629. ***************
  1630. *** 301,307
  1631.       int    w;
  1632.       int    ipwc = pwc;
  1633.   
  1634. !     post(i);
  1635.       while (pwc)
  1636.       {
  1637.           register int    p;
  1638.  
  1639. --- 405,418 -----
  1640.   #if JOBS
  1641.       BOOL    update_only = i == -2;
  1642.   
  1643. !     if (update_only)
  1644. !         i = -1;
  1645. !     if ((flags&jobflg) == 0 || i != -1)
  1646. ! #endif
  1647. !         post(i);
  1648. ! #if JOBS
  1649. !     while (pwc || (flags&jobflg))
  1650. ! #else
  1651.       while (pwc)
  1652.   #endif
  1653.       {
  1654. ***************
  1655. *** 303,308
  1656.   
  1657.       post(i);
  1658.       while (pwc)
  1659.       {
  1660.           register int    p;
  1661.           register int    sig;
  1662.  
  1663. --- 414,420 -----
  1664.       while (pwc || (flags&jobflg))
  1665.   #else
  1666.       while (pwc)
  1667. + #endif
  1668.       {
  1669.           register int    p;
  1670.           register int    sig;
  1671. ***************
  1672. *** 310,315
  1673.           int    found = 0;
  1674.   
  1675.           {
  1676.               register int    *pw = pwlist;
  1677.   
  1678.               p = wait(&w);
  1679.  
  1680. --- 422,428 -----
  1681.           int    found = 0;
  1682.   
  1683.           {
  1684. + #ifndef JOBS
  1685.               register int    *pw = pwlist;
  1686.   #endif
  1687.   
  1688. ***************
  1689. *** 311,316
  1690.   
  1691.           {
  1692.               register int    *pw = pwlist;
  1693.   
  1694.               p = wait(&w);
  1695.               if (wasintr)
  1696.  
  1697. --- 424,430 -----
  1698.           {
  1699.   #ifndef JOBS
  1700.               register int    *pw = pwlist;
  1701. + #endif
  1702.   
  1703.   #if JOBS
  1704.               if (i == 0 && (flags&jobflg) && wf_pwc == 0)
  1705. ***************
  1706. *** 312,317
  1707.           {
  1708.               register int    *pw = pwlist;
  1709.   
  1710.               p = wait(&w);
  1711.               if (wasintr)
  1712.               {
  1713.  
  1714. --- 426,447 -----
  1715.               register int    *pw = pwlist;
  1716.   #endif
  1717.   
  1718. + #if JOBS
  1719. +             if (i == 0 && (flags&jobflg) && wf_pwc == 0)
  1720. +                 break;
  1721. +             if ((pwc == 0 && (flags&jobflg)) || update_only)
  1722. +             {
  1723. +                 if ((p = wait3(&w, WUNTRACED|WNOHANG, &ru)) == 0)
  1724. +                 {
  1725. +                     unpost (i);
  1726. +                     break;
  1727. +                 }
  1728. +                 if (pwc == 0 && p == -1)
  1729. +                     break;
  1730. +             }
  1731. +             else
  1732. +                 p = wait3(&w, WUNTRACED, &ru);
  1733. + #else
  1734.               p = wait(&w);
  1735.   #endif
  1736.               if (wasintr)
  1737. ***************
  1738. *** 313,318
  1739.               register int    *pw = pwlist;
  1740.   
  1741.               p = wait(&w);
  1742.               if (wasintr)
  1743.               {
  1744.                   wasintr = 0;
  1745.  
  1746. --- 443,449 -----
  1747.                   p = wait3(&w, WUNTRACED, &ru);
  1748.   #else
  1749.               p = wait(&w);
  1750. + #endif
  1751.               if (wasintr)
  1752.               {
  1753.                   wasintr = 0;
  1754. ***************
  1755. *** 321,326
  1756.                       break;
  1757.                   }
  1758.               }
  1759.               while (pw <= &pwlist[ipwc])
  1760.               {
  1761.                   if (*pw == p)
  1762.  
  1763. --- 452,462 -----
  1764.                       break;
  1765.                   }
  1766.               }
  1767. + 
  1768. + #if JOBS
  1769. +             if (unpost(p))
  1770. +                 found++;
  1771. + #else
  1772.               while (pw <= &pwlist[ipwc])
  1773.               {
  1774.                   if (*pw == p)
  1775. ***************
  1776. *** 332,337
  1777.                   else
  1778.                       pw++;
  1779.               }
  1780.           }
  1781.           if (p == -1)
  1782.           {
  1783.  
  1784. --- 468,474 -----
  1785.                   else
  1786.                       pw++;
  1787.               }
  1788. + #endif
  1789.           }
  1790.           if (p == -1)
  1791.           {
  1792. ***************
  1793. *** 337,342
  1794.           {
  1795.               if (bckg)
  1796.               {
  1797.                   register int *pw = pwlist;
  1798.   
  1799.                   while (pw <= &pwlist[ipwc] && i != *pw)
  1800.  
  1801. --- 474,483 -----
  1802.           {
  1803.               if (bckg)
  1804.               {
  1805. + #if JOBS
  1806. +                 j_child_clear(i);
  1807. +                 unpost(i);
  1808. + #else
  1809.                   register int *pw = pwlist;
  1810.   
  1811.                   while (pw <= &pwlist[ipwc] && i != *pw)
  1812. ***************
  1813. *** 346,351
  1814.                       *pw = 0;
  1815.                       pwc--;
  1816.                   }
  1817.               }
  1818.               continue;
  1819.           }
  1820.  
  1821. --- 487,493 -----
  1822.                       *pw = 0;
  1823.                       pwc--;
  1824.                   }
  1825. + #endif
  1826.               }
  1827.               continue;
  1828.           }
  1829. ***************
  1830. *** 354,360
  1831.           {
  1832.               if (sig == 0177)    /* ptrace! return */
  1833.               {
  1834. -                 prs("ptrace: ");
  1835.                   sig = w_hi;
  1836.               }
  1837.               if (sysmsg[sig])
  1838.  
  1839. --- 496,501 -----
  1840.           {
  1841.               if (sig == 0177)    /* ptrace! return */
  1842.               {
  1843.                   sig = w_hi;
  1844.   #if JOBS
  1845.                   if ((flags&jobflg) &&
  1846. ***************
  1847. *** 356,361
  1848.               {
  1849.                   prs("ptrace: ");
  1850.                   sig = w_hi;
  1851.               }
  1852.               if (sysmsg[sig])
  1853.               {
  1854.  
  1855. --- 497,512 -----
  1856.               if (sig == 0177)    /* ptrace! return */
  1857.               {
  1858.                   sig = w_hi;
  1859. + #if JOBS
  1860. +                 if ((flags&jobflg) &&
  1861. +                     (sig == SIGSTOP || sig == SIGTSTP ||
  1862. +                      sig == SIGTTOU || sig == SIGTTIN))
  1863. +                 {
  1864. +                     j_child_stop(p, sig);
  1865. +                     goto j_bypass;
  1866. +                 }
  1867. + #endif
  1868. +                 prs("ptrace: ");
  1869.               }
  1870.               if (sysmsg[sig])
  1871.               {
  1872. ***************
  1873. *** 371,376
  1874.               }
  1875.               newline();
  1876.           }
  1877.           if (rc == 0 && found != 0)
  1878.               rc = (sig ? sig | SIGFLG : w_hi);
  1879.           wx |= w;
  1880.  
  1881. --- 522,558 -----
  1882.               }
  1883.               newline();
  1884.           }
  1885. + #if JOBS
  1886. +         if (flags&infoflg)
  1887. +         {
  1888. +             register int    k;
  1889. +             long        l;
  1890. + 
  1891. +             prc('[');
  1892. +             l = ru.ru_utime.tv_sec * 1000000L + ru.ru_utime.tv_usec
  1893. +               + ru.ru_stime.tv_sec * 1000000L + ru.ru_stime.tv_usec;
  1894. +             prn((int)(l / 1000000));    /* integral seconds */
  1895. +             k = (int)(l % 1000000L) / 1000;    /* thousandths */
  1896. +             prc('.');
  1897. +             if (k < 100)
  1898. +                 prc('0');
  1899. +             if (k < 10)
  1900. +                 prc('0');
  1901. +             prn(k);
  1902. +             blank();
  1903. +             prn((int)ru.ru_inblock);
  1904. +             blank();
  1905. +             prn((int)ru.ru_oublock);
  1906. +             blank();
  1907. +             prn((int)ru.ru_minflt);
  1908. +             blank();
  1909. +             prn((int)ru.ru_majflt);
  1910. +             prc(']');
  1911. +             newline();
  1912. +         }
  1913. +         j_child_die(p);
  1914. +     j_bypass:
  1915. + #endif
  1916.           if (rc == 0 && found != 0)
  1917.               rc = (sig ? sig | SIGFLG : w_hi);
  1918.           wx |= w;
  1919. :::::::: setbrk.c :::::::
  1920. No differences encountered
  1921. :::::::: sh.mk :::::::
  1922. *** ../orig.u/sh.mk    Wed May 15 17:08:30 1985
  1923. --- sh.mk    Wed May 29 16:28:26 1985
  1924. ***************
  1925. *** 5,11
  1926.   ROOT=
  1927.   INS = /etc/install -n $(ROOT)/bin
  1928.   INSDIR =
  1929. ! CFLAGS = -O -DNICE -DACCT -DNICEVAL=4
  1930.   LDFLAGS = -n -s
  1931.   
  1932.   OFILES = setbrk.o blok.o stak.o cmd.o fault.o main.o word.o string.o\
  1933.  
  1934. --- 5,11 -----
  1935.   ROOT=
  1936.   INS = /etc/install -n $(ROOT)/bin
  1937.   INSDIR =
  1938. ! CFLAGS = -O -DNICE -DNICEVAL=4 -DJOBS
  1939.   LDFLAGS = -n -s
  1940.   
  1941.   OFILES = setbrk.o blok.o stak.o cmd.o fault.o main.o word.o string.o\
  1942. ***************
  1943. *** 10,15
  1944.   
  1945.   OFILES = setbrk.o blok.o stak.o cmd.o fault.o main.o word.o string.o\
  1946.   name.o args.o xec.o service.o error.o io.o print.o macro.o expand.o\
  1947.   ctype.o msg.o test.o defs.o echo.o hash.o hashserv.o pwd.o func.o
  1948.   
  1949.   all: sh
  1950.  
  1951. --- 10,17 -----
  1952.   
  1953.   OFILES = setbrk.o blok.o stak.o cmd.o fault.o main.o word.o string.o\
  1954.   name.o args.o xec.o service.o error.o io.o print.o macro.o expand.o\
  1955. + history.o homedir.o \
  1956. + jobs.o signal.o ulimit.o \
  1957.   ctype.o msg.o test.o defs.o echo.o hash.o hashserv.o pwd.o func.o
  1958.   
  1959.   all: sh
  1960. ***************
  1961. *** 20,34
  1962.   $(OFILES):    defs.h $(FRC)
  1963.   
  1964.   ctype.o:    ctype.h
  1965. !         if [ "${_ID_}" ];\
  1966. !         then \
  1967. !             $(CC) $(CFLAGS) -c ctype.c; \
  1968. !         elif [ "${_SH_}" ]; \
  1969. !         then \
  1970. !             CC=$(CC) AS=$(AS) $(_SH_) ./:fix ctype; \
  1971. !         else \
  1972. !             CC=$(CC) AS=$(AS) sh ./:fix ctype; \
  1973. !         fi
  1974.   
  1975.   xec.o:        xec.c
  1976.       set +e; if u370;\
  1977.  
  1978. --- 22,32 -----
  1979.   $(OFILES):    defs.h $(FRC)
  1980.   
  1981.   ctype.o:    ctype.h
  1982. !         $(CC) $(CFLAGS) -S ctype.c
  1983. !         sed '/^[     ]*\.data/s/data/text/' < ctype.s > x.s
  1984. !         mv x.s ctype.s
  1985. !         $(AS) ctype.s -o ctype.o
  1986. !         rm ctype.s
  1987.   
  1988.   xec.o:        xec.c
  1989.       set +e; if u370;\
  1990. ***************
  1991. *** 55,69
  1992.   
  1993.   
  1994.   msg.o:        msg.c $(FRC)
  1995. !         if [ "${_ID_}" ];\
  1996. !         then \
  1997. !             $(CC) $(CFLAGS) -c msg.c; \
  1998. !         elif [ "${_SH_}" ]; \
  1999. !         then \
  2000. !             CC=$(CC) AS=$(AS) $(_SH_) ./:fix msg; \
  2001. !         else \
  2002. !             CC=$(CC) AS=$(AS) sh ./:fix msg; \
  2003. !         fi
  2004.   
  2005.   test:
  2006.         rtest $(TESTDIR)/sh
  2007.  
  2008. --- 53,63 -----
  2009.   
  2010.   
  2011.   msg.o:        msg.c $(FRC)
  2012. !         $(CC) $(CFLAGS) -S msg.c
  2013. !         sed '/^[     ]*\.data/s/data/text/' < msg.s > x.s
  2014. !         mv x.s msg.s
  2015. !         $(AS) msg.s -o msg.o
  2016. !         rm msg.s
  2017.   
  2018.   test:
  2019.         rtest $(TESTDIR)/sh
  2020. :::::::: stak.c :::::::
  2021. No differences encountered
  2022. :::::::: stak.h :::::::
  2023. No differences encountered
  2024. :::::::: string.c :::::::
  2025. No differences encountered
  2026. :::::::: sym.h :::::::
  2027. *** ../orig.u/sym.h    Wed May 15 17:08:32 1985
  2028. --- sym.h    Sun May 19 16:37:20 1985
  2029. ***************
  2030. *** 45,47
  2031.   #define ESCAPE    '\\'
  2032.   #define BRACE    '{'
  2033.   #define COMCHAR '#'
  2034.  
  2035. --- 45,48 -----
  2036.   #define ESCAPE    '\\'
  2037.   #define BRACE    '{'
  2038.   #define COMCHAR '#'
  2039. + #define PERCENT '%'    /* DAG -- useful addition */
  2040. :::::::: test.c :::::::
  2041. *** ../orig.u/test.c    Wed May 15 17:08:33 1985
  2042. --- test.c    Mon May 20 15:57:01 1985
  2043. ***************
  2044. *** 126,131
  2045.           if (eq(a, "-k"))
  2046.               return(ftype(nxtarg(0), S_ISVTX));
  2047.           if (eq(a, "-p"))
  2048.               return(filtyp(nxtarg(0),S_IFIFO));
  2049.              if (eq(a, "-s"))
  2050.               return(fsizep(nxtarg(0)));
  2051.  
  2052. --- 126,134 -----
  2053.           if (eq(a, "-k"))
  2054.               return(ftype(nxtarg(0), S_ISVTX));
  2055.           if (eq(a, "-p"))
  2056. + #if JOBS && !defined(pyr)
  2057. + #define    S_IFIFO        S_IFSOCK    /* fifo - map to socket on 4.2BSD */
  2058. + #endif
  2059.               return(filtyp(nxtarg(0),S_IFIFO));
  2060.              if (eq(a, "-s"))
  2061.               return(fsizep(nxtarg(0)));
  2062. :::::::: timeout.h :::::::
  2063. No differences encountered
  2064. :::::::: word.c :::::::
  2065. *** ../orig.u/word.c    Wed May 15 17:08:34 1985
  2066. --- word.c    Thu Jun  6 14:37:41 1985
  2067. ***************
  2068. *** 19,24
  2069.       struct argnod    *arg = (struct argnod *)locstak();
  2070.       register char    *argp = arg->argval;
  2071.       int        alpha = 1;
  2072.   
  2073.       wdnum = 0;
  2074.       wdset = 0;
  2075.  
  2076. --- 19,25 -----
  2077.       struct argnod    *arg = (struct argnod *)locstak();
  2078.       register char    *argp = arg->argval;
  2079.       int        alpha = 1;
  2080. +     char        *save;
  2081.   
  2082.       wdnum = 0;
  2083.       wdset = 0;
  2084. ***************
  2085. *** 23,28
  2086.       wdnum = 0;
  2087.       wdset = 0;
  2088.   
  2089.       while (1)
  2090.       {
  2091.           while (c = nextc(0), space(c))        /* skipc() */
  2092.  
  2093. --- 24,30 -----
  2094.       wdnum = 0;
  2095.       wdset = 0;
  2096.   
  2097. +     catcheof = TRUE;
  2098.       while (1)
  2099.       {
  2100.           while (c = nextc(0), space(c))        /* skipc() */
  2101. ***************
  2102. *** 38,43
  2103.               break;    /* out of comment - white space loop */
  2104.           }
  2105.       }
  2106.       if (!eofmeta(c))
  2107.       {
  2108.           do
  2109.  
  2110. --- 40,46 -----
  2111.               break;    /* out of comment - white space loop */
  2112.           }
  2113.       }
  2114. +     save = argp;    /* save start of word */
  2115.       if (!eofmeta(c))
  2116.       {
  2117.           do
  2118. ***************
  2119. *** 69,74
  2120.                               chkpr();
  2121.                       }
  2122.                   }
  2123.               }
  2124.           } while ((c = nextc(0), !eofmeta(c)));
  2125.           argp = endstak(argp);
  2126.  
  2127. --- 72,93 -----
  2128.                               chkpr();
  2129.                       }
  2130.                   }
  2131. +                 else if (c == SQUIGGLE &&
  2132. +                         validtilde (save, argp))
  2133. +                 {
  2134. +                     char *name, *home;
  2135. + 
  2136. +                     name = argp;
  2137. +                     while ((c = nextc(0)) != '/' &&
  2138. +                             !eofmeta(c))
  2139. +                         *name++ = c;
  2140. +                     peekc = c;
  2141. +                     *name = '\0';
  2142. +                     home = homedir (argp);
  2143. +                     if(*home)
  2144. +                         movstr (home, --argp);
  2145. +                     argp += length (argp) - 1;
  2146. +                 }
  2147.               }
  2148.           } while ((c = nextc(0), !eofmeta(c)));
  2149.           argp = endstak(argp);
  2150. ***************
  2151. *** 117,122
  2152.               wdval = EOFSYM;
  2153.           if (iopend && eolchar(c))
  2154.           {
  2155.               copy(iopend);
  2156.               iopend = 0;
  2157.           }
  2158.  
  2159. --- 136,144 -----
  2160.               wdval = EOFSYM;
  2161.           if (iopend && eolchar(c))
  2162.           {
  2163. +             int histon = (flags&nohistflg) == 0;
  2164. + 
  2165. +             flags |= nohistflg;    /* no history for here docs */
  2166.               copy(iopend);
  2167.               if (histon)        /* turn history back on */
  2168.                   flags &= ~nohistflg;
  2169. ***************
  2170. *** 118,123
  2171.           if (iopend && eolchar(c))
  2172.           {
  2173.               copy(iopend);
  2174.               iopend = 0;
  2175.           }
  2176.       }
  2177.  
  2178. --- 140,147 -----
  2179.   
  2180.               flags |= nohistflg;    /* no history for here docs */
  2181.               copy(iopend);
  2182. +             if (histon)        /* turn history back on */
  2183. +                 flags &= ~nohistflg;
  2184.               iopend = 0;
  2185.           }
  2186.       }
  2187. ***************
  2188. *** 121,126
  2189.               iopend = 0;
  2190.           }
  2191.       }
  2192.       reserv = FALSE;
  2193.       return(wdval);
  2194.   }
  2195.  
  2196. --- 145,151 -----
  2197.               iopend = 0;
  2198.           }
  2199.       }
  2200. +     catcheof = FALSE;
  2201.       reserv = FALSE;
  2202.       return(wdval);
  2203.   }
  2204. ***************
  2205. *** 157,162
  2206.   
  2207.   readc()
  2208.   {
  2209.       register char    c;
  2210.       register int    len;
  2211.       register struct fileblk *f;
  2212.  
  2213. --- 182,188 -----
  2214.   
  2215.   readc()
  2216.   {
  2217. +     static int    eofcount = 0;    /* to break endless catcheof loop */
  2218.       register char    c;
  2219.       register int    len;
  2220.       register struct fileblk *f;
  2221. ***************
  2222. *** 200,209
  2223.       }
  2224.       else if ((len = readb()) <= 0)
  2225.       {
  2226. !         close(f->fdes);
  2227. !         f->fdes = -1;
  2228. !         c = EOF;
  2229. !         f->feof++;
  2230.       }
  2231.       else
  2232.       {
  2233.  
  2234. --- 226,260 -----
  2235.       }
  2236.       else if ((len = readb()) <= 0)
  2237.       {
  2238. !         if (catcheof
  2239. ! #if JOBS
  2240. !          && (flags&(ttyflg|prompt|dotflg)) == (ttyflg|prompt)
  2241. !          && ((flags&noeotflg) || j_finish(FALSE))
  2242. ! #else
  2243. !          && (flags&(ttyflg|prompt|noeotflg|dotflg)) == (ttyflg|prompt|noeotflg)
  2244. ! #endif
  2245. !          && ++eofcount < 10)    /* in case terminal is disconnected */
  2246. !         {
  2247. ! #if JOBS
  2248. !             if ((flags&(ttyflg|prompt|noeotflg))
  2249. !              == (ttyflg|prompt|noeotflg))
  2250. ! #endif
  2251. !                 prs ("use \"exit\"\n");
  2252. ! #if JOBS
  2253. !             /* else "there are stopped jobs" was printed */
  2254. ! #endif
  2255. !             c = NL;
  2256. !         }
  2257. !         else
  2258. !         {
  2259. !             close(f->fdes);
  2260. !             f->fdes = -1;
  2261. !             c = EOF;
  2262. !             f->feof++;
  2263. ! #if JOBS
  2264. !             j_finish(TRUE);
  2265. ! #endif
  2266. !         }
  2267.       }
  2268.       else
  2269.       {
  2270. ***************
  2271. *** 207,213
  2272.       }
  2273.       else
  2274.       {
  2275. !         f->fend = (f->fnxt = f->fbuf) + len;
  2276.           goto retry;
  2277.       }
  2278.       return(c);
  2279.  
  2280. --- 258,265 -----
  2281.       }
  2282.       else
  2283.       {
  2284. !         f->fend = f->fnxt + len;
  2285. !         eofcount = 0;
  2286.           goto retry;
  2287.       }
  2288.       return(c);
  2289. ***************
  2290. *** 214,220
  2291.   }
  2292.   
  2293.   static
  2294. ! readb()
  2295.   {
  2296.       register struct fileblk *f = standin;
  2297.       register int    len;
  2298.  
  2299. --- 266,272 -----
  2300.   }
  2301.   
  2302.   static
  2303. ! readblock ()    /* ADR -- changed the name */
  2304.   {
  2305.       register struct fileblk *f = standin;
  2306.       register int    len;
  2307. ***************
  2308. *** 234,237
  2309.           }
  2310.       } while ((len = read(f->fdes, f->fbuf, f->fsiz)) < 0 && trapnote);
  2311.       return(len);
  2312.   }
  2313.  
  2314. --- 286,486 -----
  2315.           }
  2316.       } while ((len = read(f->fdes, f->fbuf, f->fsiz)) < 0 && trapnote);
  2317.       return(len);
  2318. + }
  2319. + 
  2320. + /* readb --- read a block from the outside world, and history process it */
  2321. + 
  2322. + /*
  2323. +  * In BSD systems, using the literal next capability of the tty driver, it
  2324. +  * is actually possible to put a newline in the middle of the input line,
  2325. +  * and then hit return, so that the shell sees two lines of input.
  2326. +  *
  2327. +  * As a design decision, if there is a \n in the middle of what we've read
  2328. +  * from a terminal, treat the commands as two separately typed commands. I.e.
  2329. +  *
  2330. +  *    echo hi ^J echo there
  2331. +  *
  2332. +  * is the same as
  2333. +  *
  2334. +  *    echo hi
  2335. +  *    echo there
  2336. +  *
  2337. +  * The major reason for doing it this way is that the history mechanism knows
  2338. +  * that a \n is the end of a line.
  2339. +  *
  2340. +  * Finally, on USG systems, we just leave this code alone, since it won't
  2341. +  * get executed anyway.
  2342. +  */
  2343. + 
  2344. + /*
  2345. +  * In word.c, the readc() function keeps a pointer to what standin pointed to
  2346. +  * when readc first gets called.  Therefore, where standin points to can not 
  2347. +  * not change across calls to readb().  To get around this, we change the
  2348. +  * contents of the structure pointed to by standin, saving and restoring
  2349. +  * it as necessary.
  2350. +  */
  2351. + 
  2352. + #define LARGEBUF    (HISTSIZE / 2)    /* size of expanded history */
  2353. + 
  2354. + static
  2355. + readb()
  2356. + {
  2357. +     int ilen, i, j;
  2358. +     char ibuf[BUFSIZ];    /* input into scratch area, pass to history */
  2359. +     static char expansion[LARGEBUF];
  2360. +     static int moreinbuf = FALSE;
  2361. +     static int saved_ilen = 0;
  2362. +     static int start_here = 0;
  2363. +     static struct fileblk *f = 0;
  2364. +     auto int gotoutofbuf = 0;
  2365. + 
  2366. +     if (expanded)    /* just did a history substitution */
  2367. +         expanded = 0;
  2368. + 
  2369. +     if ((flags & nohistflg) || (flags & prompt) == 0 || ! isatty (input)
  2370. +             || standin->fstak != 0)
  2371. +     {
  2372. +         ilen = readblock ();
  2373. +         if (ilen > 0)
  2374. +             standin->fnxt = standin->fbuf;
  2375. +         return (ilen);
  2376. +         /* not doing history expansion at all */
  2377. +     }
  2378. + 
  2379. +     if (f == 0)
  2380. +         f = standin;
  2381. + 
  2382. +     ilen = 0;
  2383. + 
  2384. +     /*
  2385. +      * First, if there was more stuff in the last buffer, go and get it.
  2386. +      * If not get some more from the outside world.
  2387. +      *
  2388. +      * Then, make sure we've read up to a newline.
  2389. +      * This is basically in case someone has done something bizarre
  2390. +      * like 'stty raw', and input is coming in one character at a time.
  2391. +      *
  2392. +      * We use a heuristic.  If amount read is just 1, keep reading till
  2393. +      * we get a newline.  Else, read in a complete line from the terminal.
  2394. +      * Once we're in raw mode, can't reset it until a newline is typed.
  2395. +      *
  2396. +      * If not reading one character at a time, then do the stuff for
  2397. +      * embedded newlines.
  2398. +      */
  2399. + 
  2400. +     if (moreinbuf)
  2401. +     {
  2402. +         for (i = 0, j = start_here; f->fbuf[j] != NL && j < saved_ilen; i++, j++)
  2403. +             ibuf[i] = f->fbuf[j];
  2404. + 
  2405. + #ifdef notdef
  2406. +         if (f->fbuf[j] != NL)
  2407. +         {
  2408. +             prs ("internal i/o error C in readb\n");
  2409. +             return (0);
  2410. +         }
  2411. + #endif
  2412. + 
  2413. +         if (f->fbuf[j] == NL)
  2414. +             ibuf[i++] = NL;
  2415. +         ibuf[i] = '\0';
  2416. +         ilen = i;
  2417. +         /* embedded newline */
  2418. +         moreinbuf = (++j < saved_ilen - 1);
  2419. +         if (moreinbuf)
  2420. +             start_here = j;    /* where to start next time */
  2421. +         gotoutofbuf = 1;
  2422. +     }
  2423. +     else    /* wasn't an embedded \n last time */
  2424. +     {
  2425. +         ilen = readblock ();
  2426. +     
  2427. +         if (ilen <= 0)    /* EOF or error */
  2428. +             return (ilen);
  2429. + 
  2430. +         if (ilen == 1)    /* either in raw mode, or an empty line */
  2431. +         {
  2432. +             i = 0;
  2433. +             ibuf[i++] = f->fbuf[0];
  2434. +             if (f->fbuf[0] == NL)
  2435. +             {
  2436. +                 ibuf[i] = '\0';
  2437. +                 goto dohist;
  2438. +             }
  2439. + 
  2440. +             while ((ilen = readblock()) > 0)
  2441. +             {
  2442. +                 if (ilen != 1)
  2443. +                 {
  2444. +                     prs ("internal i/o error A in readb\n");
  2445. +                     return (0);
  2446. +                 }
  2447. +                 ibuf[i++] = f->fbuf[0];
  2448. +                 if (f->fbuf[0] == NL)
  2449. +                 {
  2450. +                     ibuf[i] = '\0';
  2451. +                     break;    /* while */
  2452. +                 }
  2453. +             }
  2454. +             ilen = i;
  2455. +             gotoutofbuf = TRUE;
  2456. +             /* force code below to use collected string */
  2457. +         }
  2458. +         else
  2459. +         {
  2460. +             /* reading bunches of characters at once */
  2461. +             for (i = 0; f->fbuf[i] != NL && i < ilen; i++)
  2462. +                 ibuf[i] = f->fbuf[i];
  2463. + 
  2464. + #ifdef notdef
  2465. +             if (f->fbuf[i] != NL)
  2466. +             {
  2467. +                 prs ("internal i/o error B in readb\n");
  2468. +                 return (0);
  2469. +             }
  2470. + #endif
  2471. + 
  2472. +             ibuf[i++] = NL;
  2473. +             ibuf[i] = '\0';
  2474. +             /* ilen was set by readblock() */
  2475. +             /* embedded newline */
  2476. +             moreinbuf = (i < ilen - 1);
  2477. +             if (moreinbuf)
  2478. +             {
  2479. +                 saved_ilen = ilen;
  2480. +                 start_here = i;
  2481. +                 /* where to start next time */
  2482. +                 gotoutofbuf = 1;
  2483. +             }
  2484. +         }
  2485. +     }
  2486. + 
  2487. + dohist:
  2488. +     /* quick heuristic */
  2489. +     if (! gotoutofbuf && ilen == 1 && f->fbuf[0] == NL)
  2490. +     {
  2491. +         f->fnxt = f->fbuf;
  2492. +         return (ilen);
  2493. +     }
  2494. + 
  2495. +     if (histsub (ibuf, expansion, sizeof expansion))
  2496. +     {
  2497. +         int olen = length (expansion) - 1;
  2498. +         if (! expanded && ! gotoutofbuf)
  2499. +         {
  2500. +             standin->fnxt = standin->fbuf;
  2501. +             return (ilen);
  2502. +         }
  2503. +         /* else
  2504. +             expanded == TRUE or from buffer */
  2505. +         standin->fnxt = expansion;
  2506. +         return (olen);
  2507. +     }
  2508. +     else
  2509. +     {
  2510. +         /* hist expansion failed, return an empty line */
  2511. +         standin->fnxt = standin->fbuf;
  2512. +         standin->fbuf[0] = NL;
  2513. +         return (1);
  2514. +     }
  2515.   }
  2516. :::::::: xec.c :::::::
  2517. *** ../orig.u/xec.c    Wed May 15 17:08:37 1985
  2518. --- xec.c    Wed Jun  5 11:11:18 1985
  2519. ***************
  2520. *** 27,32
  2521.        */
  2522.       register struct trenod    *t;
  2523.       char        *sav = savstak();
  2524.   
  2525.       sigchk();
  2526.       if (!errorflg)
  2527.  
  2528. --- 27,42 -----
  2529.        */
  2530.       register struct trenod    *t;
  2531.       char        *sav = savstak();
  2532. + #if pyr
  2533. +     auto int change_univ = FALSE;
  2534. +     auto int new_univ = 0;
  2535. +     /*
  2536. +      * univesrses run from 1 to NUMUNIV: We start out at 0
  2537. +      * and increment new_univ in the switch for internal
  2538. +      * commands, below.  new_univ must *not* be assigned to, directly
  2539. +      * or via side effects, any place else.
  2540. +      */
  2541. + #endif
  2542.   
  2543.       sigchk();
  2544.       if (!errorflg)
  2545. ***************
  2546. *** 109,114
  2547.                       if (flags & execpr)
  2548.                           execprint(com);
  2549.   
  2550.                       if (comtype == NOTFOUND)
  2551.                       {
  2552.                           pos = hashdata(cmdhash);
  2553.  
  2554. --- 119,130 -----
  2555.                       if (flags & execpr)
  2556.                           execprint(com);
  2557.   
  2558. +                     /*
  2559. +                      * fix a bug which caused the shell
  2560. +                      * to do not do a second command if
  2561. +                      * the first was not found. (bug fix
  2562. +                      * from USENET)
  2563. +                      */
  2564.                       if (comtype == NOTFOUND)
  2565.                       {
  2566.                           char *errstr;
  2567. ***************
  2568. *** 111,116
  2569.   
  2570.                       if (comtype == NOTFOUND)
  2571.                       {
  2572.                           pos = hashdata(cmdhash);
  2573.                           if (pos == 1)
  2574.                               failed(*com, notfound);
  2575.  
  2576. --- 127,134 -----
  2577.                        */
  2578.                       if (comtype == NOTFOUND)
  2579.                       {
  2580. +                         char *errstr;
  2581. + 
  2582.                           pos = hashdata(cmdhash);
  2583.                           if (pos == 1)
  2584.                               errstr = notfound;
  2585. ***************
  2586. *** 113,119
  2587.                       {
  2588.                           pos = hashdata(cmdhash);
  2589.                           if (pos == 1)
  2590. !                             failed(*com, notfound);
  2591.                           else if (pos == 2)
  2592.                               failed(*com, badexec);
  2593.                           else
  2594.  
  2595. --- 131,137 -----
  2596.   
  2597.                           pos = hashdata(cmdhash);
  2598.                           if (pos == 1)
  2599. !                             errstr = notfound;
  2600.                           else if (pos == 2)
  2601.                               errstr = badexec;
  2602.                           else
  2603. ***************
  2604. *** 115,121
  2605.                           if (pos == 1)
  2606.                               failed(*com, notfound);
  2607.                           else if (pos == 2)
  2608. !                             failed(*com, badexec);
  2609.                           else
  2610.                               failed(*com, badperm);
  2611.                           break;
  2612.  
  2613. --- 133,139 -----
  2614.                           if (pos == 1)
  2615.                               errstr = notfound;
  2616.                           else if (pos == 2)
  2617. !                             errstr = badexec;
  2618.                           else
  2619.                               errstr = badperm;
  2620.                           prp();
  2621. ***************
  2622. *** 117,123
  2623.                           else if (pos == 2)
  2624.                               failed(*com, badexec);
  2625.                           else
  2626. !                             failed(*com, badperm);
  2627.                           break;
  2628.                       }
  2629.   
  2630.  
  2631. --- 135,147 -----
  2632.                           else if (pos == 2)
  2633.                               errstr = badexec;
  2634.                           else
  2635. !                             errstr = badperm;
  2636. !                         prp();
  2637. !                         prs_cntl(*com);
  2638. !                         prs (colon);
  2639. !                         prs (errstr);
  2640. !                         newline();
  2641. !                         exitval = 1;
  2642.                           break;
  2643.                       }
  2644.   
  2645. ***************
  2646. *** 148,153
  2647.                                   if ((f = pathopen(getpath(a1), a1)) < 0)    
  2648.                                       failed(a1, notfound);    
  2649.                                   else    
  2650.                                       execexp(0, f);    
  2651.                               }    
  2652.                               break;    
  2653.  
  2654. --- 172,181 -----
  2655.                                   if ((f = pathopen(getpath(a1), a1)) < 0)    
  2656.                                       failed(a1, notfound);    
  2657.                                   else    
  2658. +                                 {
  2659. +                                     int    savedot = flags&dotflg;
  2660. + 
  2661. +                                     flags |= dotflg;
  2662.                                       execexp(0, f);    
  2663.                                       flags &= ~dotflg;
  2664.                                       flags |= savedot;
  2665. ***************
  2666. *** 149,154
  2667.                                       failed(a1, notfound);    
  2668.                                   else    
  2669.                                       execexp(0, f);    
  2670.                               }    
  2671.                               break;    
  2672.                   
  2673.  
  2674. --- 177,185 -----
  2675.   
  2676.                                       flags |= dotflg;
  2677.                                       execexp(0, f);    
  2678. +                                     flags &= ~dotflg;
  2679. +                                     flags |= savedot;
  2680. +                                 }
  2681.                               }    
  2682.                               break;    
  2683.                   
  2684. ***************
  2685. *** 163,169
  2686.                                   prc_buff(NL);    
  2687.                               }    
  2688.                               break;    
  2689. !                 
  2690.                           case SYSEXIT:    
  2691.                               flags |= forked;    /* force exit */    
  2692.                               exitsh(a1 ? stoi(a1) : retval);
  2693.  
  2694. --- 194,200 -----
  2695.                                   prc_buff(NL);    
  2696.                               }    
  2697.                               break;    
  2698. ! 
  2699.                           case SYSEXIT:    
  2700.   #if JOBS
  2701.                               if (j_finish(FALSE))
  2702. ***************
  2703. *** 165,170
  2704.                               break;    
  2705.                   
  2706.                           case SYSEXIT:    
  2707.                               flags |= forked;    /* force exit */    
  2708.                               exitsh(a1 ? stoi(a1) : retval);
  2709.                   
  2710.  
  2711. --- 196,207 -----
  2712.                               break;    
  2713.   
  2714.                           case SYSEXIT:    
  2715. + #if JOBS
  2716. +                             if (j_finish(FALSE))
  2717. +                                 break;
  2718. + #endif
  2719. +                             histsave (histfnod.namval);
  2720. +                             /* save before setting flag */
  2721.                               flags |= forked;    /* force exit */    
  2722.   
  2723.                               exitsh(a1 ? stoi(a1) : retval);
  2724. ***************
  2725. *** 166,171
  2726.                   
  2727.                           case SYSEXIT:    
  2728.                               flags |= forked;    /* force exit */    
  2729.                               exitsh(a1 ? stoi(a1) : retval);
  2730.                   
  2731.                           case SYSNULL:    
  2732.  
  2733. --- 203,209 -----
  2734.                               histsave (histfnod.namval);
  2735.                               /* save before setting flag */
  2736.                               flags |= forked;    /* force exit */    
  2737. + 
  2738.                               exitsh(a1 ? stoi(a1) : retval);
  2739.                   
  2740.                           case SYSNULL:    
  2741. ***************
  2742. *** 248,256
  2743.                               }    
  2744.           
  2745.   #ifdef RES    /* Research includes login as part of the shell */    
  2746. !         
  2747. !                         case SYSLOGIN:    
  2748. !                             oldsigs();    
  2749.                               execa(com, -1);
  2750.                               done();    
  2751.   #else    
  2752.  
  2753. --- 286,296 -----
  2754.                               }    
  2755.           
  2756.   #ifdef RES    /* Research includes login as part of the shell */    
  2757. ! 
  2758. !                         case SYSLOGIN:
  2759. !                             histsave (histfnod.namval);
  2760. !                             flags |= forked;    /* DAG -- bug fix (force bad exec to terminate shell) */
  2761. !                             oldsigs();
  2762.                               execa(com, -1);
  2763.                               done();
  2764.   #else
  2765. ***************
  2766. *** 252,260
  2767.                           case SYSLOGIN:    
  2768.                               oldsigs();    
  2769.                               execa(com, -1);
  2770. !                             done();    
  2771. ! #else    
  2772. !             
  2773.                           case SYSNEWGRP:    
  2774.                               if (flags & rshflg)    
  2775.                                   failed(com[0], restricted);    
  2776.  
  2777. --- 292,299 -----
  2778.                               flags |= forked;    /* DAG -- bug fix (force bad exec to terminate shell) */
  2779.                               oldsigs();
  2780.                               execa(com, -1);
  2781. !                             done();
  2782. ! #else
  2783.                           case SYSNEWGRP:    
  2784.                               if (flags & rshflg)    
  2785.                                   failed(com[0], restricted);    
  2786. ***************
  2787. *** 260,265
  2788.                                   failed(com[0], restricted);    
  2789.                               else    
  2790.                               {    
  2791.                                   flags |= forked;    /* force bad exec to terminate shell */    
  2792.                                   oldsigs();    
  2793.                                   execa(com, -1);
  2794.  
  2795. --- 299,305 -----
  2796.                                   failed(com[0], restricted);    
  2797.                               else    
  2798.                               {    
  2799. +                                 histsave (histfnod.namval);
  2800.                                   flags |= forked;    /* force bad exec to terminate shell */    
  2801.                                   oldsigs();    
  2802.                                   execa(com, -1);
  2803. ***************
  2804. *** 266,272
  2805.                                   done();    
  2806.                               }    
  2807.           
  2808. ! #endif    
  2809.           
  2810.                           case SYSCD:    
  2811.                               if (flags & rshflg)    
  2812.  
  2813. --- 306,312 -----
  2814.                                   done();    
  2815.                               }    
  2816.           
  2817. ! #endif
  2818.           
  2819.                           case SYSCD:    
  2820.                               if (flags & rshflg)    
  2821. ***************
  2822. *** 273,278
  2823.                                   failed(com[0], restricted);    
  2824.                               else if ((a1 && *a1) || (a1 == 0 && (a1 = homenod.namval)))    
  2825.                               {    
  2826.                                   char *cdpath;    
  2827.                                   char *dir;    
  2828.                                   int f;    
  2829.  
  2830. --- 313,319 -----
  2831.                                   failed(com[0], restricted);    
  2832.                               else if ((a1 && *a1) || (a1 == 0 && (a1 = homenod.namval)))    
  2833.                               {    
  2834. +                                 register char *safe;    /* DAG -- added (see note, below) */
  2835.                                   char *cdpath;    
  2836.                                   char *dir;    
  2837.                                   int f;    
  2838. ***************
  2839. *** 279,286
  2840.           
  2841.                                   if ((cdpath = cdpnod.namval) == 0 ||    
  2842.                                        *a1 == '/' ||    
  2843. !                                      cf(a1, ".") == 0 ||    
  2844. !                                      cf(a1, "..") == 0 ||    
  2845.                                        (*a1 == '.' && (*(a1+1) == '/' || *(a1+1) == '.' && *(a1+2) == '/')))    
  2846.                                       cdpath = nullstr;    
  2847.           
  2848.  
  2849. --- 320,327 -----
  2850.           
  2851.                                   if ((cdpath = cdpnod.namval) == 0 ||    
  2852.                                        *a1 == '/' ||    
  2853. !                                      cf(a1, ".") == 0 ||
  2854. !                                      cf(a1, "..") == 0 ||
  2855.                                        (*a1 == '.' && (*(a1+1) == '/' || *(a1+1) == '.' && *(a1+2) == '/')))    
  2856.                                       cdpath = nullstr;    
  2857.           
  2858. ***************
  2859. *** 284,289
  2860.                                        (*a1 == '.' && (*(a1+1) == '/' || *(a1+1) == '.' && *(a1+2) == '/')))    
  2861.                                       cdpath = nullstr;    
  2862.           
  2863.                                   do    
  2864.                                   {    
  2865.                                       dir = cdpath;    
  2866.  
  2867. --- 325,337 -----
  2868.                                        (*a1 == '.' && (*(a1+1) == '/' || *(a1+1) == '.' && *(a1+2) == '/')))    
  2869.                                       cdpath = nullstr;    
  2870.           
  2871. + /* DAG -- catpath() leaves the trial directory above the top of the "stack".
  2872. +     This is too dangerous; systems using directory access routines may
  2873. +     alloc() storage and clobber the string.  Therefore I have changed the
  2874. +     code to alloc() a safe place to put the trial strings.  Most of the
  2875. +     changes involved replacing "curstak()" with "safe".
  2876. + */                                safe = alloc((unsigned)(length(cdpath) + length(a1)));    /* DAG -- added */
  2877. + 
  2878.                                   do    
  2879.                                   {    
  2880.                                       dir = cdpath;    
  2881. ***************
  2882. *** 288,293
  2883.                                   {    
  2884.                                       dir = cdpath;    
  2885.                                       cdpath = catpath(cdpath,a1);    
  2886.                                   }    
  2887.                                   while ((f = (chdir(curstak()) < 0)) && cdpath);
  2888.           
  2889.  
  2890. --- 336,342 -----
  2891.                                   {    
  2892.                                       dir = cdpath;    
  2893.                                       cdpath = catpath(cdpath,a1);    
  2894. +                                     (void)movstr(curstak(),safe);    /* DAG -- added (see note, above) */
  2895.                                   }    
  2896.   #if !defined(SYMLINK) && defined(JOBS)
  2897.                                   while ((f = (cwdir(safe) < 0)) && cdpath);    /* DAG */
  2898. ***************
  2899. *** 289,295
  2900.                                       dir = cdpath;    
  2901.                                       cdpath = catpath(cdpath,a1);    
  2902.                                   }    
  2903. !                                 while ((f = (chdir(curstak()) < 0)) && cdpath);
  2904.           
  2905.                                   if (f)    
  2906.                                       failed(a1, baddir);    
  2907.  
  2908. --- 338,348 -----
  2909.                                       cdpath = catpath(cdpath,a1);    
  2910.                                       (void)movstr(curstak(),safe);    /* DAG -- added (see note, above) */
  2911.                                   }    
  2912. ! #if !defined(SYMLINK) && defined(JOBS)
  2913. !                                 while ((f = (cwdir(safe) < 0)) && cdpath);    /* DAG */
  2914. ! #else
  2915. !                                 while ((f = (chdir(safe) < 0)) && cdpath);    /* DAG */
  2916. ! #endif
  2917.           
  2918.                                   if (f)    
  2919.                                   {
  2920. ***************
  2921. *** 292,297
  2922.                                   while ((f = (chdir(curstak()) < 0)) && cdpath);
  2923.           
  2924.                                   if (f)    
  2925.                                       failed(a1, baddir);    
  2926.                                   else 
  2927.                                   {
  2928.  
  2929. --- 345,352 -----
  2930.   #endif
  2931.           
  2932.                                   if (f)    
  2933. +                                 {
  2934. +                                     free(safe);    /* DAG -- added (see note, above) */
  2935.                                       failed(a1, baddir);    
  2936.                                   }
  2937.                                   else 
  2938. ***************
  2939. *** 293,298
  2940.           
  2941.                                   if (f)    
  2942.                                       failed(a1, baddir);    
  2943.                                   else 
  2944.                                   {
  2945.                                       cwd(curstak());
  2946.  
  2947. --- 348,354 -----
  2948.                                   {
  2949.                                       free(safe);    /* DAG -- added (see note, above) */
  2950.                                       failed(a1, baddir);    
  2951. +                                 }
  2952.                                   else 
  2953.                                   {
  2954.   #if defined(SYMLINK) || !defined(JOBS)
  2955. ***************
  2956. *** 295,301
  2957.                                       failed(a1, baddir);    
  2958.                                   else 
  2959.                                   {
  2960. !                                     cwd(curstak());
  2961.                                       if (cf(nullstr, dir) &&    
  2962.                                           *dir != ':' &&    
  2963.                                            any('/', curstak()) &&    
  2964.  
  2965. --- 351,359 -----
  2966.                                   }
  2967.                                   else 
  2968.                                   {
  2969. ! #if defined(SYMLINK) || !defined(JOBS)
  2970. !                                     cwd(safe);    /* DAG */
  2971. ! #endif
  2972.                                       if (cf(nullstr, dir) &&    
  2973.                                           *dir != ':' &&    
  2974.                                            any('/', safe) &&    /* DAG */
  2975. ***************
  2976. *** 298,304
  2977.                                       cwd(curstak());
  2978.                                       if (cf(nullstr, dir) &&    
  2979.                                           *dir != ':' &&    
  2980. !                                          any('/', curstak()) &&    
  2981.                                            flags & prompt)    
  2982.                                       {    
  2983.                                           prs_buff(curstak());    
  2984.  
  2985. --- 356,362 -----
  2986.   #endif
  2987.                                       if (cf(nullstr, dir) &&    
  2988.                                           *dir != ':' &&    
  2989. !                                          any('/', safe) &&    /* DAG */
  2990.                                            flags & prompt)    
  2991.                                           cwdprint();    /* DAG -- improvement */
  2992.                                       free(safe);    /* DAG -- added (see note, above) */
  2993. ***************
  2994. *** 300,309
  2995.                                           *dir != ':' &&    
  2996.                                            any('/', curstak()) &&    
  2997.                                            flags & prompt)    
  2998. !                                     {    
  2999. !                                         prs_buff(curstak());    
  3000. !                                         prc_buff(NL);    
  3001. !                                     }
  3002.                                   }
  3003.                                   zapcd();
  3004.                               }    
  3005.  
  3006. --- 358,365 -----
  3007.                                           *dir != ':' &&    
  3008.                                            any('/', safe) &&    /* DAG */
  3009.                                            flags & prompt)    
  3010. !                                         cwdprint();    /* DAG -- improvement */
  3011. !                                     free(safe);    /* DAG -- added (see note, above) */
  3012.                                   }
  3013.                                   zapcd();
  3014.                               }    
  3015. ***************
  3016. *** 452,458
  3017.                                   if (command == 1 || command == 4)    
  3018.                                   {    
  3019.                                       prl(i);    
  3020. !                                     prc_buff('\n');    
  3021.                                   }    
  3022.                                   break;    
  3023.                               }                
  3024.  
  3025. --- 508,514 -----
  3026.                                   if (command == 1 || command == 4)    
  3027.                                   {    
  3028.                                       prl(i);    
  3029. !                                     prc_buff(NL);    
  3030.                                   }    
  3031.                                   break;    
  3032.                               }                
  3033. ***************
  3034. *** 478,486
  3035.                                   prc_buff(NL);    
  3036.                               }    
  3037.                               break;    
  3038. !         
  3039. ! #endif    
  3040. !         
  3041.                           case SYSTST:
  3042.                               exitval = test(argn, com);
  3043.                               break;
  3044.  
  3045. --- 534,540 -----
  3046.                                   prc_buff(NL);    
  3047.                               }    
  3048.                               break;    
  3049. ! 
  3050.                           case SYSTST:
  3051.                               exitval = test(argn, com);
  3052.                               break;
  3053. ***************
  3054. *** 484,489
  3055.                           case SYSTST:
  3056.                               exitval = test(argn, com);
  3057.                               break;
  3058.   
  3059.                           case SYSECHO:
  3060.                               exitval = echo(argn, com);
  3061.  
  3062. --- 538,544 -----
  3063.                           case SYSTST:
  3064.                               exitval = test(argn, com);
  3065.                               break;
  3066. + #endif    /* RES (DAG -- bug fix: SYSTST not in RES) */
  3067.   
  3068.                           case SYSECHO:
  3069.                               exitval = echo(argn, com);
  3070. ***************
  3071. *** 548,553
  3072.                               }
  3073.                               break;
  3074.   
  3075.                           default:    
  3076.                               prs_buff("unknown builtin\n");
  3077.                           }    
  3078.  
  3079. --- 603,675 -----
  3080.                               }
  3081.                               break;
  3082.   
  3083. + #if JOBS
  3084. +                         case SYSJOBS:
  3085. + 
  3086. +                             j_print();
  3087. +                             break;
  3088. + 
  3089. +                         case SYSFG:
  3090. + 
  3091. +                             j_resume(a1, FALSE);
  3092. +                             break;
  3093. + 
  3094. +                         case SYSBG:
  3095. + 
  3096. +                             j_resume(a1, TRUE);
  3097. +                             break;
  3098. + 
  3099. +                         case SYSSUSPEND:
  3100. +                             exitval = 1;
  3101. +                             if (getppid() == 1)
  3102. +                                 prs ("cannot suspend a login shell\n");    /* yet ... */
  3103. +                             else
  3104. +                             {
  3105. +                                 exitval = 0;
  3106. +                                 kill (getpid(), SIGSTOP);
  3107. +                             }
  3108. +                             break;
  3109. + #endif
  3110. + 
  3111. + #if pyr
  3112. +                         /*
  3113. +                          * UCB is Universe 2
  3114. +                          * ATT is Universe 1
  3115. +                          * new_univ == 0
  3116. +                          */
  3117. +                         case SYSUCB:
  3118. +                             new_univ++;
  3119. +                             /* fall thru */
  3120. +                         case SYSATT:
  3121. +                             new_univ++;
  3122. +                             if (argn > 1)
  3123. +                             {
  3124. +                                 change_univ = TRUE;
  3125. +                                 com++;
  3126. +                                 goto doit;
  3127. +                             }
  3128. +                             else
  3129. +                             {
  3130. +                                 setuniverse (cur_univ = new_univ);
  3131. +                                 univnod.namflg &= ~N_RDONLY;
  3132. +                                 assign (& univnod, univ_name[cur_univ - 1]);
  3133. +                                 attrib ((& univnod), N_RDONLY);
  3134. +                                 break;
  3135. +                             }
  3136. +                         
  3137. +                         case SYSUNIVERSE:
  3138. +                             if (eq(com[1], "-l"))
  3139. +                                 prs_buff (univ_longname[cur_univ - 1]);
  3140. +                             else
  3141. +                                 prs_buff (univ_name[cur_univ - 1]);
  3142. +                             prc_buff (NL);
  3143. +                             break;
  3144. + #endif
  3145. + 
  3146. +                         case SYSHISTORY:
  3147. +                             exitval = history (argn, com);
  3148. +                             break;
  3149. + 
  3150.                           default:    
  3151.                               prs_buff("unknown builtin\n");
  3152.                           }    
  3153. ***************
  3154. *** 586,591
  3155.               }
  3156.   
  3157.           case TFORK:
  3158.               exitval = 0;
  3159.               if (execflg && (treeflgs & (FAMP | FPOU)) == 0)
  3160.                   parent = 0;
  3161.  
  3162. --- 708,716 -----
  3163.               }
  3164.   
  3165.           case TFORK:
  3166. + #if pyr
  3167. +         doit:
  3168. + #endif
  3169.               exitval = 0;
  3170.               if (execflg && (treeflgs & (FAMP | FPOU)) == 0)
  3171.                   parent = 0;
  3172. ***************
  3173. *** 625,630
  3174.                       alarm(forkcnt);
  3175.                       pause(); 
  3176.                   }
  3177.               }
  3178.               if (parent)
  3179.               {
  3180.  
  3181. --- 750,759 -----
  3182.                       alarm(forkcnt);
  3183.                       pause(); 
  3184.                   }
  3185. + #if JOBS
  3186. +                 if (parent == 0)
  3187. +                     j_top_level = FALSE;
  3188. + #endif
  3189.               }
  3190.               if (parent)
  3191.               {
  3192. ***************
  3193. *** 633,638
  3194.                    * it may or may not wait for the child
  3195.                    */
  3196.                   if (treeflgs & FPRS && flags & ttyflg)
  3197.                   {
  3198.                       prn(parent);
  3199.                       newline();
  3200.  
  3201. --- 762,770 -----
  3202.                    * it may or may not wait for the child
  3203.                    */
  3204.                   if (treeflgs & FPRS && flags & ttyflg)
  3205. + #if JOBS
  3206. +                 if ((flags&jobflg) == 0)
  3207. + #endif
  3208.                   {
  3209.                       prn(parent);
  3210.                       newline();
  3211. ***************
  3212. *** 639,644
  3213.                   }
  3214.                   if (treeflgs & FPCL)
  3215.                       closepipe(pf1);
  3216.                   if ((treeflgs & (FAMP | FPOU)) == 0)
  3217.                       await(parent, 0);
  3218.                   else if ((treeflgs & FAMP) == 0)
  3219.  
  3220. --- 771,779 -----
  3221.                   }
  3222.                   if (treeflgs & FPCL)
  3223.                       closepipe(pf1);
  3224. + #if JOBS
  3225. +                 j_child_post(parent, treeflgs&FAMP, treeflgs&FPIN, t);
  3226. + #endif
  3227.                   if ((treeflgs & (FAMP | FPOU)) == 0)
  3228.                   {
  3229.                       await(parent, 0);
  3230. ***************
  3231. *** 640,645
  3232.                   if (treeflgs & FPCL)
  3233.                       closepipe(pf1);
  3234.                   if ((treeflgs & (FAMP | FPOU)) == 0)
  3235.                       await(parent, 0);
  3236.                   else if ((treeflgs & FAMP) == 0)
  3237.                       post(parent);
  3238.  
  3239. --- 775,781 -----
  3240.                   j_child_post(parent, treeflgs&FAMP, treeflgs&FPIN, t);
  3241.   #endif
  3242.                   if ((treeflgs & (FAMP | FPOU)) == 0)
  3243. +                 {
  3244.                       await(parent, 0);
  3245.   #if JOBS
  3246.                       j_reset_pg();
  3247. ***************
  3248. *** 641,646
  3249.                       closepipe(pf1);
  3250.                   if ((treeflgs & (FAMP | FPOU)) == 0)
  3251.                       await(parent, 0);
  3252.                   else if ((treeflgs & FAMP) == 0)
  3253.                       post(parent);
  3254.                   else
  3255.  
  3256. --- 777,786 -----
  3257.                   if ((treeflgs & (FAMP | FPOU)) == 0)
  3258.                   {
  3259.                       await(parent, 0);
  3260. + #if JOBS
  3261. +                     j_reset_pg();
  3262. + #endif
  3263. +                 }
  3264.                   else if ((treeflgs & FAMP) == 0)
  3265.                       post(parent);
  3266.                   else
  3267. ***************
  3268. *** 650,655
  3269.               }
  3270.               else    /* this is the forked branch (child) of execute */
  3271.               {
  3272.                   flags |= forked;
  3273.                   fiotemp  = 0;
  3274.   
  3275.  
  3276. --- 790,805 -----
  3277.               }
  3278.               else    /* this is the forked branch (child) of execute */
  3279.               {
  3280. + #if pyr
  3281. +                 if (change_univ)
  3282. +                 {
  3283. +                     setuniverse (new_univ);
  3284. +                     univnod.namflg &= ~N_RDONLY;
  3285. +                     assign (& univnod, univ_name[cur_univ - 1]);
  3286. +                     attrib ((& univnod), N_RDONLY);
  3287. +                 }
  3288. + #endif
  3289. + 
  3290.                   flags |= forked;
  3291.                   fiotemp  = 0;
  3292.   
  3293. ***************
  3294. *** 674,679
  3295.                    */
  3296.                   oldsigs();
  3297.                   if (treeflgs & FINT)
  3298.                   {
  3299.                       signal(SIGINT, 1);
  3300.                       signal(SIGQUIT, 1);
  3301.  
  3302. --- 824,832 -----
  3303.                    */
  3304.                   oldsigs();
  3305.                   if (treeflgs & FINT)
  3306. + #if JOBS
  3307. +                 if ((flags&jobflg) == 0)
  3308. + #endif
  3309.                   {
  3310.                       signal(SIGINT, SIG_IGN);    /* DAG */
  3311.                       signal(SIGQUIT, SIG_IGN);    /* DAG */
  3312. ***************
  3313. *** 675,682
  3314.                   oldsigs();
  3315.                   if (treeflgs & FINT)
  3316.                   {
  3317. !                     signal(SIGINT, 1);
  3318. !                     signal(SIGQUIT, 1);
  3319.   
  3320.   #ifdef NICE
  3321.                       nice(NICEVAL);
  3322.  
  3323. --- 828,835 -----
  3324.                   if ((flags&jobflg) == 0)
  3325.   #endif
  3326.                   {
  3327. !                     signal(SIGINT, SIG_IGN);    /* DAG */
  3328. !                     signal(SIGQUIT, SIG_IGN);    /* DAG */
  3329.   
  3330.   #ifdef NICE
  3331.                       nice(NICEVAL);
  3332. ***************
  3333. *** 700,705
  3334.                    * default std input for &
  3335.                    */
  3336.                   if (treeflgs & FINT && ioset == 0)
  3337.                       rename(chkopen(devnull), 0);
  3338.                   /*
  3339.                    * io redirection
  3340.  
  3341. --- 853,861 -----
  3342.                    * default std input for &
  3343.                    */
  3344.                   if (treeflgs & FINT && ioset == 0)
  3345. + #if JOBS
  3346. +                 if ((flags&jobflg) == 0)
  3347. + #endif
  3348.                       rename(chkopen(devnull), 0);
  3349.                   /*
  3350.                    * io redirection
  3351.  
  3352.