home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1994 March / Source_Code_CD-ROM_Walnut_Creek_March_1994.iso / compsrcs / misc / volume29 / pdksh / patch03d < prev    next >
Encoding:
Text File  |  1992-04-25  |  35.9 KB  |  1,449 lines
  1. Newsgroups: comp.sources.misc
  2. From: sjg@zen.void.oz.au (Simon J. Gerraty)
  3. Subject:  v29i086:  pdksh - Public Domain Korn Shell, v4, Patch03d/5
  4. Message-ID: <1992Apr26.041615.22389@sparky.imd.sterling.com>
  5. X-Md4-Signature: 05de8910a6b1d539c342b4b5ca831059
  6. Date: Sun, 26 Apr 1992 04:16:15 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: sjg@zen.void.oz.au (Simon J. Gerraty)
  10. Posting-number: Volume 29, Issue 86
  11. Archive-name: pdksh/patch03d
  12. Environment: UNIX
  13. Patch-To: pdksh: Volume 25, Issue 47-55
  14.  
  15. *** /dev/null    Sat Apr 25 07:00:06 1992
  16. --- sh/proto.h    Sat Apr 25 18:29:12 1992
  17. ***************
  18. *** 0 ****
  19. --- 1,234 ----
  20. + /*
  21. +  * prototypes for PD-KSH
  22. +  * originally generated using "cproto.c 3.5 92/04/11 19:28:01 cthuang "
  23. +  * $Id: proto.h,v 1.1 1992/04/25 08:29:02 sjg Exp $
  24. +  */
  25. + #ifndef ARGS
  26. + #if defined(__STDC__) || defined(__cplusplus)
  27. + #define ARGS(s) s
  28. + #else
  29. + #define ARGS(s) ()
  30. + #endif
  31. + #endif
  32. + 
  33. + /* alloc.c */
  34. + Area *    ainit         ARGS((Area *ap));
  35. + void     afreeall     ARGS((Area *ap));
  36. + void *    alloc         ARGS((size_t size, Area *ap));
  37. + void *    aresize         ARGS((void *ptr, size_t size, Area *ap));
  38. + void     afree         ARGS((void *ptr, Area *ap));
  39. + /* c_ksh.c */
  40. + int     c_hash         ARGS((char **wp));
  41. + int     c_cd         ARGS((char **wp));
  42. + int     c_print         ARGS((char **wp));
  43. + int     c_whence     ARGS((char **wp));
  44. + int     c_typeset     ARGS((char **wp));
  45. + int     c_alias         ARGS((char **wp));
  46. + int     c_unalias     ARGS((char **wp));
  47. + int     c_let         ARGS((char **wp));
  48. + int     c_jobs         ARGS((char **wp));
  49. + int     c_fgbg         ARGS((char **wp));
  50. + int     c_kill         ARGS((char **wp));
  51. + int     c_bind         ARGS((char **wp));
  52. + /* c_sh.c */
  53. + int     c_label         ARGS((char **wp));
  54. + int     c_shift         ARGS((char **wp));
  55. + int     c_umask         ARGS((char **wp));
  56. + int     c_dot         ARGS((char **wp));
  57. + int     c_wait         ARGS((char **wp));
  58. + int     c_read         ARGS((char **wp));
  59. + int     c_eval         ARGS((char **wp));
  60. + int     c_trap         ARGS((char **wp));
  61. + void     setsig         ARGS((struct trap *p, void (*f)()));
  62. + int     c_return     ARGS((char **wp));
  63. + int     c_brkcont     ARGS((char **wp));
  64. + int     c_exit         ARGS((char **wp));
  65. + int     c_set         ARGS((char **wp));
  66. + int     c_unset         ARGS((char **wp));
  67. + int     c_ulimit     ARGS((char **wp));
  68. + int     c_times         ARGS((char **wp));
  69. + int     timex         ARGS((struct op *t, int f));
  70. + int     c_exec         ARGS((char **wp));
  71. + int     c_builtin     ARGS((char **wp));
  72. + /* c_test.c */
  73. + int     c_test         ARGS((char **wp));
  74. + int     oexpr         ARGS((int n));
  75. + int     aexpr         ARGS((int n));
  76. + int     nexpr         ARGS((int n));
  77. + int     primary         ARGS((int n));
  78. + int     filstat         ARGS((char *nm, int mode));
  79. + int     t_lex         ARGS((char *s));
  80. + int     newerf         ARGS((char *f1, char *f2));
  81. + int     olderf         ARGS((char *f1, char *f2));
  82. + int     equalf         ARGS((char *f1, char *f2));
  83. + /* do_ulimit.c */
  84. + int     do_ulimit     ARGS((char *a1, char *a2));
  85. + /* edit.c */
  86. + int     x_read         ARGS((int fd, char *buf, size_t len));
  87. + int     x_getc         ARGS((void));
  88. + void     x_flush         ARGS((void));
  89. + void     x_adjust     ARGS((void));
  90. + void     x_putc         ARGS((int c));
  91. + void     x_puts         ARGS((char *s));
  92. + void     x_init         ARGS((void));
  93. + bool_t     x_mode         ARGS((bool_t onoff));
  94. + int     promptlen     ARGS((char *cp));
  95. + int     init_editmode     ARGS((void));
  96. + /* emacs.c */
  97. + int     x_emacs         ARGS((char *buf, size_t len));
  98. + void     x_redraw     ARGS((int limit));
  99. + void     x_bind         ARGS((char *a1, char *a2, int macro));
  100. + void     x_init_emacs     ARGS((void));
  101. + void     x_emacs_keys     ARGS((int erase, int kill, int werase, int intr, int quit));
  102. + char *    x_lastcp     ARGS((void));
  103. + /* eval.c */
  104. + char *    substitute     ARGS((char const *cp, int f));
  105. + char **    eval         ARGS((char **ap, int f));
  106. + char *    evalstr         ARGS((char *cp, int f));
  107. + /* exec.c */
  108. + int     execute         ARGS((struct op *t, volatile int flags));
  109. + int     shcomexec     ARGS((char **wp));
  110. + int     define         ARGS((char *name, struct op *t));
  111. + int     builtin         ARGS((char *name, int (*func)()));
  112. + struct tbl *    findcom     ARGS((char *name, int insert));
  113. + int     flushcom     ARGS((int all));
  114. + char *    search         ARGS((char *name, char *path, int mode));
  115. + /* expr.c */
  116. + void     evalerr         ARGS((char *err));
  117. + long     evaluate     ARGS((const char *expr));
  118. + /* getopts.c */
  119. + void     resetopts     ARGS((void));
  120. + int     c_getopts     ARGS((char **wp));
  121. + /* history.c */
  122. + int     c_fc          ARGS((register char **wp));
  123. + void     histbackup     ARGS((void));
  124. + void     histsave     ARGS((char *cmd));
  125. + char **    histget          ARGS((char *str));
  126. + char *    histrpl          ARGS((char *s, char *pat, char *rep, int global));
  127. + void     hist_init     ARGS((Source *s));
  128. + void     hist_finish     ARGS((void));
  129. + char **    histpos          ARGS((void));
  130. + int     histN          ARGS((void));
  131. + int     histnum          ARGS((int n));
  132. + char *    findhist     ARGS((int start, int fwd, char *str));
  133. + /* io.c */
  134. + int     errorf         ARGS((const char *fmt, ...));
  135. + int     shellf         ARGS((const char *fmt, ...));
  136. + void     fopenshf     ARGS((int fd));
  137. + void     flushshf     ARGS((int fd));
  138. + int     savefd         ARGS((int fd));
  139. + void     restfd         ARGS((int fd, int ofd));
  140. + void     openpipe     ARGS((int *pv));
  141. + void     closepipe     ARGS((int *pv));
  142. + struct temp *    maketemp ARGS((Area *ap));
  143. + /* jobs.c */
  144. + void     j_init         ARGS((void));
  145. + void     j_exit         ARGS((void));
  146. + void     j_change     ARGS((void));
  147. + int     exchild         ARGS((struct op *t, int flags));
  148. + int     waitlast     ARGS((void));
  149. + int     j_reapchld     ARGS((void));
  150. + int     j_reap         ARGS((void));
  151. + int     waitfor         ARGS((int job));
  152. + void     j_kill         ARGS((int job, int sig));
  153. + int     j_resume     ARGS((int job, int bg));
  154. + void     j_jobs         ARGS((void));
  155. + void     j_notify     ARGS((void));
  156. + int     j_lookup     ARGS((char *cp));
  157. + int     j_stopped     ARGS((void));
  158. + /* lex.c */
  159. + int     yylex         ARGS((int cf));
  160. + int     gethere         ARGS((void));
  161. + void     yyerror         ARGS((const char *msg));
  162. + Source * pushs         ARGS((int type));
  163. + int     pprompt         ARGS((char *cp));
  164. + /* mail.c */
  165. + void     mcheck         ARGS((void));
  166. + void     mbset         ARGS((char *p));
  167. + void     mpset         ARGS((char *mptoparse));
  168. + void     mprint         ARGS((void));
  169. + /* main.c */
  170. + int     main         ARGS((int argc, char **argv, char **envp));
  171. + int     include         ARGS((char *name));
  172. + #if 0
  173. + int     command         ARGS((char *comm));
  174. + #endif
  175. + int     shell         ARGS((Source *s));
  176. + void     leave         ARGS((int rv));
  177. + int     error         ARGS((void));
  178. + int     unwind         ARGS((void));
  179. + int     newenv         ARGS((int type));
  180. + int     quitenv         ARGS((void));
  181. + void     aerror         ARGS((Area *ap, const char *msg));
  182. + /* misc.c */
  183. + void     setctypes     ARGS((/* const */ char *s, int t));
  184. + void     initctypes     ARGS((void));
  185. + char *    ulton         ARGS((unsigned long n, int base));
  186. + char *    strsave         ARGS((char *s, Area *ap));
  187. + int     option         ARGS((const char *n));
  188. + char *    getoptions     ARGS((void));
  189. + void     printoptions     ARGS((void));
  190. + int     getn         ARGS((char *as));
  191. + char *    strerror     ARGS((int i));
  192. + int     gmatch         ARGS((char *s, char *p));
  193. + void     qsortp         ARGS((void **base, size_t n, int (*f)()));
  194. + int     qsort1         ARGS((void **base, void **lim, int (*f)()));
  195. + int     xstrcmp         ARGS((void *p1, void *p2));
  196. + void     cleanpath     ARGS((char *pwd, char *dir, char *clean));
  197. + /* syn.c */
  198. + int     yyparse         ARGS((void));
  199. + int     keywords     ARGS((void));
  200. + struct op * compile     ARGS((Source *s));
  201. + /* table.c */
  202. + unsigned int     hash     ARGS((char *n));
  203. + void     tinit         ARGS((struct table *tp, Area *ap));
  204. + struct tbl *    tsearch     ARGS((struct table *tp, char *n, unsigned int h));
  205. + struct tbl *    tenter     ARGS((struct table *tp, char *n, unsigned int h));
  206. + void     tdelete         ARGS((struct tbl *p));
  207. + void     twalk         ARGS((struct table *tp));
  208. + struct tbl *    tnext     ARGS((void));
  209. + struct tbl **    tsort     ARGS((struct table *tp));
  210. + /* trace.c */
  211. + /* trap.c */
  212. + Trap *    gettrap         ARGS((char *name));
  213. + void     trapsig         ARGS((int i));
  214. + int     runtraps     ARGS((void));
  215. + int     runtrap         ARGS((Trap *p));
  216. + int     cleartraps     ARGS((void));
  217. + int     ignoresig     ARGS((int i));
  218. + int     restoresigs     ARGS((void));
  219. + /* tree.c */
  220. + void     ptree         ARGS((struct op *t, FILE *f));
  221. + int     pioact         ARGS((FILE *f, struct ioword *iop));
  222. + int     fptreef         ARGS((FILE *f, char *fmt, ...));
  223. + int     snptreef     ARGS((char *s, int n, char *fmt, ...));
  224. + struct op *    tcopy     ARGS((struct op *t, Area *ap));
  225. + char *    wdcopy         ARGS((char *wp, Area *ap));
  226. + char *    wdscan         ARGS((char *wp, int c));
  227. + void     tfree         ARGS((struct op *t, Area *ap));
  228. + /* var.c */
  229. + void     newblock     ARGS((void));
  230. + void     popblock     ARGS((void));
  231. + struct tbl *    global     ARGS((char *n));
  232. + struct tbl *    local     ARGS((char *n));
  233. + char *    strval         ARGS((struct tbl *vp));
  234. + long     intval         ARGS((struct tbl *vp));
  235. + void     setstr         ARGS((struct tbl *vq, char *s));
  236. + struct tbl *    strint     ARGS((struct tbl *vq, struct tbl *vp));
  237. + void     setint         ARGS((struct tbl *vq, long n));
  238. + int     import         ARGS((char *thing));
  239. + struct tbl *    typeset     ARGS((char *var, int set, int clr));
  240. + void     unset         ARGS((struct tbl *vp));
  241. + int     isassign     ARGS((char *s));
  242. + char **    makenv         ARGS((void));
  243. + /* version.c */
  244. + /* vi.c */
  245. + void     vi_reset     ARGS((char *buf, int len));
  246. + int     vi_hook         ARGS((int ch));
  247. + int     save_cbuf     ARGS((void));
  248. + int     restore_cbuf     ARGS((void));
  249. + int     x_vi         ARGS((char *buf, size_t len));
  250. + int     getch         ARGS((void));
  251. + char **    globstr         ARGS((char *stuff));
  252. + 
  253. + 
  254. *** sh/sh.h.old    Sat Apr 25 17:44:32 1992
  255. --- sh/sh.h    Sat Apr 25 18:32:35 1992
  256. ***************
  257. *** 2,8 ****
  258.    * Public Domain Bourne/Korn shell
  259.    */
  260.   
  261. ! /* $Id: sh.h,v 3.3 89/03/27 15:46:34 egisin Exp $ */
  262.   
  263.   #include "config.h"
  264.   
  265. --- 2,8 ----
  266.    * Public Domain Bourne/Korn shell
  267.    */
  268.   
  269. ! /* $Id: sh.h,v 1.3 1992/04/25 08:29:52 sjg Exp $ */
  270.   
  271.   #include "config.h"
  272.   
  273. ***************
  274. *** 16,33 ****
  275.   #endif
  276.   
  277.   /* some people object to this use of __STDC__ */
  278. ! #ifndef Void
  279. ! #if __STDC__
  280.   #define    ARGS(args)    args    /* prototype declaration */
  281. - #define    Void    void        /* generic pointer */
  282. - #define    Const    const        /* constant data */
  283. - #define    Volatile volatile    /* you know */
  284.   #else
  285.   #define    ARGS(args)    ()    /* K&R declaration */
  286. ! #define    Void    char
  287. ! #define    Const    
  288. ! #define    Volatile 
  289.   #endif
  290.   #endif
  291.   
  292.   #ifdef _ULTRIX            /* Ultrix 2.x gets dup2 wrong */
  293. --- 16,30 ----
  294.   #endif
  295.   
  296.   /* some people object to this use of __STDC__ */
  297. ! #ifdef __STDC__
  298.   #define    ARGS(args)    args    /* prototype declaration */
  299.   #else
  300.   #define    ARGS(args)    ()    /* K&R declaration */
  301. ! #ifdef VOID
  302. ! #define    void    VOID
  303.   #endif
  304. + #define    const    
  305. + #define    volatile 
  306.   #endif
  307.   
  308.   #ifdef _ULTRIX            /* Ultrix 2.x gets dup2 wrong */
  309. ***************
  310. *** 63,69 ****
  311. --- 60,68 ----
  312.   Extern    int    kshpid;        /* $$, shell pid */
  313.   Extern    int    exstat;        /* exit status */
  314.   Extern    int    async;        /* $!, last &'d pid */
  315. + Extern    volatile int sigchld_caught;    /* count of dead children */
  316.   
  317. + 
  318.   /*
  319.    * Area-based allocation built on malloc/free
  320.    */
  321. ***************
  322. *** 76,90 ****
  323.   #define    APERM    &aperm
  324.   #define    ATEMP    &e.area
  325.   
  326. - Area   *ainit ARGS((Area *ap));        /* initialize Area */
  327. - void    afreeall ARGS((Area *ap));    /* free Area's contents */
  328. - void    ashrink ARGS((Area *ap));    /* unimplimented */
  329. - void    aerror ARGS((Area *ap, const char *msg)); /* error handler */
  330. - 
  331. - Void   *alloc ARGS((size_t size, Area *ap)); /* alloc object from Area */
  332. - Void   *aresize ARGS((Void *ptr, size_t size, Area *ap)); /* shrink object */
  333. - void    afree ARGS((Void *ptr, Area *ap)); /* free ojbect in Area */
  334. - 
  335.   /*
  336.    * parsing & execution environment
  337.    */
  338. --- 75,80 ----
  339. ***************
  340. *** 133,139 ****
  341.   #define    FLAG(c)    (1 + c - 'a')    /* map char to flags index */
  342.   #define    FLAGS    32
  343.   Extern    char flag [FLAGS];
  344. ! int    option ARGS((Const char *name));
  345.   char   *getoptions ARGS((void));
  346.   void    printoptions ARGS((void));
  347.   
  348. --- 123,129 ----
  349.   #define    FLAG(c)    (1 + c - 'a')    /* map char to flags index */
  350.   #define    FLAGS    32
  351.   Extern    char flag [FLAGS];
  352. ! int    option ARGS((const char *name));
  353.   char   *getoptions ARGS((void));
  354.   void    printoptions ARGS((void));
  355.   
  356. ***************
  357. *** 142,148 ****
  358.   /*
  359.    * other functions
  360.    */
  361. ! char * substitute ARGS((char Const *, int));
  362.   char   *search();
  363.   struct tbl *findcom();
  364.   char   *strsave ARGS((char *, Area *));
  365. --- 132,138 ----
  366.   /*
  367.    * other functions
  368.    */
  369. ! char * substitute ARGS((char const *, int));
  370.   char   *search();
  371.   struct tbl *findcom();
  372.   char   *strsave ARGS((char *, Area *));
  373. ***************
  374. *** 149,155 ****
  375.   char   *ulton ARGS((unsigned long n, int base));
  376.   int    xstrcmp();
  377.   void    qsortp ARGS((void **base, size_t n, int (*compare)(void *, void *)));
  378. ! long    evaluate ARGS((Const char *expr));
  379.   void    resetopts();
  380.   void    histsave();
  381.   void    histlist();
  382. --- 139,145 ----
  383.   char   *ulton ARGS((unsigned long n, int base));
  384.   int    xstrcmp();
  385.   void    qsortp ARGS((void **base, size_t n, int (*compare)(void *, void *)));
  386. ! long    evaluate ARGS((const char *expr));
  387.   void    resetopts();
  388.   void    histsave();
  389.   void    histlist();
  390. ***************
  391. *** 197,204 ****
  392.   #define    stdout    shf[1]        /* standard output */
  393.   #define    shlout    shf[2]        /* shell output */
  394.   
  395. ! int    shellf ARGS((Const char *fmt, ...)); /* fprintf(shlout, ); */
  396. ! int    errorf ARGS((Const char *fmt, ...)); /* fprintf(shlout, ); error(); */
  397.   
  398.   /*
  399.    * IO control
  400. --- 187,194 ----
  401.   #define    stdout    shf[1]        /* standard output */
  402.   #define    shlout    shf[2]        /* shell output */
  403.   
  404. ! int    shellf ARGS((const char *fmt, ...)); /* fprintf(shlout, ); */
  405. ! int    errorf ARGS((const char *fmt, ...)); /* fprintf(shlout, ); error(); */
  406.   
  407.   /*
  408.    * IO control
  409. ***************
  410. *** 208,214 ****
  411.   int    savefd ARGS((int fd));    /* save user fd */
  412.   void    restfd ARGS((int fd, int ofd));
  413.   void    openpipe ARGS((int [2]));
  414. ! void    closepipe ARGS((int [2]));;
  415.   
  416.   /*
  417.    * trap handlers
  418. --- 198,204 ----
  419.   int    savefd ARGS((int fd));    /* save user fd */
  420.   void    restfd ARGS((int fd, int ofd));
  421.   void    openpipe ARGS((int [2]));
  422. ! void    closepipe ARGS((int [2]));
  423.   
  424.   /*
  425.    * trap handlers
  426. ***************
  427. *** 218,224 ****
  428.       char   *name;        /* short name */
  429.       char   *mess;        /* descriptive name */
  430.       char   *trap;        /* trap command */
  431. !     int    Volatile set;    /* trap pending */
  432.       int    ourtrap;    /* not ignored (?) */
  433.       int    sig_dfl;    /* originally SIG_DFL */
  434.   } Trap;
  435. --- 208,214 ----
  436.       char   *name;        /* short name */
  437.       char   *mess;        /* descriptive name */
  438.       char   *trap;        /* trap command */
  439. !     int    volatile set;    /* trap pending */
  440.       int    ourtrap;    /* not ignored (?) */
  441.       int    sig_dfl;    /* originally SIG_DFL */
  442.   } Trap;
  443. ***************
  444. *** 229,238 ****
  445.   #ifdef    NSIG
  446.   #define    SIGNALS    NSIG
  447.   #else
  448.   #define    SIGNALS    32
  449.   #endif    /* NSIG */
  450.   
  451. ! Extern    int Volatile trap;    /* traps pending? */
  452.   extern    Trap    sigtraps[SIGNALS];
  453.   Trap    *gettrap ARGS((char *)); /* search for struct trap by number or name */
  454.   void    trapsig ARGS((int sig)); /* trap signal handler */
  455. --- 219,239 ----
  456.   #ifdef    NSIG
  457.   #define    SIGNALS    NSIG
  458.   #else
  459. + #ifdef    _MINIX
  460. + #define    SIGNALS    (_NSIG+1)    /* _NSIG is # of signals used, excluding 0. */
  461. + #else
  462.   #define    SIGNALS    32
  463. + #endif    /* _MINIX */
  464.   #endif    /* NSIG */
  465.   
  466. ! #ifdef USE_SIGACT            /* always use it? */
  467. ! #ifndef  SA_NOCLDSTOP
  468. ! # include "sigact.h"            /* use sjg's fake sigaction() */
  469. ! #endif
  470. ! Extern struct sigaction Sigact, Sigact_dfl, Sigact_ign, Sigact_trap;
  471. ! #endif
  472. ! 
  473. ! Extern    int volatile trap;    /* traps pending? */
  474.   extern    Trap    sigtraps[SIGNALS];
  475.   Trap    *gettrap ARGS((char *)); /* search for struct trap by number or name */
  476.   void    trapsig ARGS((int sig)); /* trap signal handler */
  477. ***************
  478. *** 248,263 ****
  479.   #define    C_IFS    0x80        /* $IFS */
  480.   
  481.   extern    char ctypes [];
  482.   void    initctypes ARGS((void));
  483. ! void    setctypes ARGS((Const char*, int type));
  484. ! 
  485.   #define    ctype(c, t)    !!(ctypes[(unsigned char)(c)]&(t))
  486.   #define    letter(c)    ctype(c, C_ALPHA)
  487.   #define    digit(c)    ctype(c, C_DIGIT)
  488.   #define    letnum(c)    ctype(c, C_ALPHA|C_DIGIT)
  489.   
  490.   /*
  491.    * 91-07-06 <sjg@sun0>
  492.    * use my simple debug tracing... 
  493.    */
  494.   #include "trace.h"
  495. --- 249,274 ----
  496.   #define    C_IFS    0x80        /* $IFS */
  497.   
  498.   extern    char ctypes [];
  499. + #if 0
  500.   void    initctypes ARGS((void));
  501. ! void    setctypes ARGS((const char*, int type));
  502. ! #endif
  503.   #define    ctype(c, t)    !!(ctypes[(unsigned char)(c)]&(t))
  504.   #define    letter(c)    ctype(c, C_ALPHA)
  505.   #define    digit(c)    ctype(c, C_DIGIT)
  506.   #define    letnum(c)    ctype(c, C_ALPHA|C_DIGIT)
  507.   
  508. + #include "table.h"
  509. + #include "tree.h"
  510. + #include "lex.h"
  511. + #include "proto.h"
  512. +   
  513.   /*
  514.    * 91-07-06 <sjg@sun0>
  515.    * use my simple debug tracing... 
  516.    */
  517.   #include "trace.h"
  518. + 
  519. + #ifndef fileno
  520. + #define fileno(p)    ((p)->_file)
  521. + #endif
  522. *** /dev/null    Sat Apr 25 07:00:06 1992
  523. --- sh/sigact.h    Sat Apr 25 01:05:25 1992
  524. ***************
  525. *** 0 ****
  526. --- 1,88 ----
  527. + /* NAME:
  528. +  *      sigact.h - sigaction et al
  529. +  *
  530. +  * SYNOPSIS:
  531. +  *      #include <signal.h>
  532. +  *      #ifndef  SA_NOCLDSTOP
  533. +  *      # include "sigact.h"
  534. +  *      #endif
  535. +  *
  536. +  * DESCRIPTION:
  537. +  *      This header is the interface to a fake sigaction(2) implementation.  
  538. +  *      Do NOT include this header unless your system does not 
  539. +  *      have a real sigaction(2) implementation.
  540. +  */
  541. + /*
  542. +  * $Log: sigact.h,v $
  543. +  * Revision 1.2  1992/04/24  15:04:11  sjg
  544. +  * now compiles with cc
  545. +  *
  546. +  * Revision 1.1  1992/04/24  12:01:38  sjg
  547. +  * Initial revision
  548. +  *
  549. +  */
  550. + 
  551. + #ifndef _SIGACT_H
  552. + #define _SIGACT_H
  553. + 
  554. + #ifndef ARGS
  555. + # if defined(__STDC__)
  556. + #   define ARGS(p) p
  557. + # else
  558. + #   define ARGS(p) ()
  559. + # endif
  560. + #endif
  561. + #ifndef __STDC__
  562. + # define volatile            /* can change without warning */
  563. + # define const                /* read only */
  564. + #endif
  565. + 
  566. + #ifndef SIGKILL
  567. + # include <signal.h>
  568. + #endif
  569. + #ifndef SA_NOCLDSTOP
  570. + /* sa_flags */
  571. + #define    SA_NOCLDSTOP    0x0001        /* don't send SIGCHLD on child stop */
  572. + #define SA_RESTART    0x0002        /* re-start I/O */
  573. + 
  574. + /* sigprocmask flags */
  575. + #define    SIG_BLOCK    0x0001
  576. + #define    SIG_UNBLOCK    0x0002
  577. + #define    SIG_SETMASK    0x0004
  578. + 
  579. + #ifndef __sys_stdtypes_h
  580. + typedef int sigset_t;
  581. + #endif
  582. + 
  583. + struct sigaction
  584. + {
  585. +   void        (*sa_handler)();
  586. +   sigset_t    sa_mask;
  587. +   int        sa_flags;
  588. + };
  589. + 
  590. + 
  591. + int    sigaction    ARGS(( int sig, struct sigaction *act, struct sigaction *oact ));
  592. + int    sigaddset    ARGS(( sigset_t *mask, int sig ));
  593. + int    sigdelset    ARGS(( sigset_t *mask, int sig ));
  594. + int    sigemptyset    ARGS(( sigset_t *mask ));
  595. + int    sigfillset    ARGS(( sigset_t *mask ));
  596. + int    sigismember    ARGS(( sigset_t *mask, int sig ));
  597. + int    sigpending    ARGS(( sigset_t *set ));
  598. + int    sigprocmask    ARGS(( int how, sigset_t *set, sigset_t *oldset ));
  599. + int    sigsuspend    ARGS(( sigset_t *mask ));
  600. + 
  601. + #ifndef sigmask
  602. + #define sigmask(m)    (1<<((m)-1))    /* convert SIGnum to mask */
  603. + #endif
  604. + #if !defined(NSIG) && defined(_NSIG)
  605. + # define NSIG _NSIG
  606. + #endif
  607. + #endif /* ! SA_NOCLDSTOP */
  608. + #endif /* _SIGACT_H */
  609. + /*
  610. +  * Local Variables:
  611. +  * version-control:t
  612. +  * comment-column:40
  613. +  * End:
  614. +  */
  615. *** /dev/null    Sat Apr 25 07:00:06 1992
  616. --- sh/sigact.c    Sat Apr 25 01:05:22 1992
  617. ***************
  618. *** 0 ****
  619. --- 1,297 ----
  620. + /* NAME:
  621. +  *      sigact.c - fake sigaction(2)
  622. +  *
  623. +  * SYNOPSIS:
  624. +  *      #include <signal.h>
  625. +  *      #ifndef  SA_NOCLDSTOP
  626. +  *      # include "sigact.h"
  627. +  *      #endif
  628. +  * 
  629. +  *      int sigaction(int sig, struct sigaction *act, 
  630. +  *                      struct sigaction *oact);
  631. +  *      int sigaddset(sigset_t *mask, int sig);
  632. +  *      int sigdelset(sigset_t *mask, int sig);
  633. +  *      int sigemptyset(sigset_t *mask);
  634. +  *      int sigfillset(sigset_t *mask);
  635. +  *      int sigismember(sigset_t *mask, int sig);
  636. +  *      int sigpending(sigset_t *set);
  637. +  *      int sigprocmask(int how, sigset_t *set, sigset_t *oldset);
  638. +  *      int sigsuspend(sigset_t *mask);
  639. +  *
  640. +  * DESCRIPTION:
  641. +  *      This is a fake sigaction implementation.  It uses 
  642. +  *      sigset(2) if available, otherwise it just uses 
  643. +  *      signal(2).  If it thinks sigaction(2) really exists it 
  644. +  *      compiles to almost nothing.
  645. +  *      
  646. +  *      The need for all this is the problems caused by mixing 
  647. +  *      signal handling routines in the one process.  This 
  648. +  *      module allows for a consistent POSIX compliant interface 
  649. +  *      to whatever is available.
  650. +  *
  651. +  * RETURN VALUE:
  652. +  *      0==success, -1==failure
  653. +  *
  654. +  * FILES:
  655. +  *      None.
  656. +  *
  657. +  * SEE ALSO:
  658. +  *      
  659. +  *
  660. +  * BUGS:
  661. +  *      Since we fake most of this, don't expect fancy usage to 
  662. +  *      work.
  663. +  *      
  664. +  * COPYRIGHT:
  665. +  *      @(#)Copyright (c) 1992 Simon J. Gerraty
  666. +  *
  667. +  *      This is free software.  It comes with NO WARRANTY.
  668. +  *      Permission to use, modify and distribute this source code 
  669. +  *      is granted subject to the following conditions.
  670. +  *      1/ that that the above copyright notice and this notice 
  671. +  *      are preserved in all copies and that due credit be given 
  672. +  *      to the author.  
  673. +  *      2/ that any changes to this code are clearly commented 
  674. +  *      as such so that the author does get blamed for bugs 
  675. +  *      other than his own.
  676. +  *      
  677. +  *      Please send copies of changes and bug-fixes to:
  678. +  *      sjg@zen.void.oz.au
  679. +  *
  680. +  */
  681. + #ifndef lint
  682. + static char  *RCSid = "$Id: sigact.c,v 1.2 1992/04/24 15:04:11 sjg Exp $";
  683. + #endif
  684. + /*
  685. +  * $Log: sigact.c,v $
  686. +  * Revision 1.2  1992/04/24  15:04:11  sjg
  687. +  * now compiles with cc
  688. +  *
  689. +  * Revision 1.1  1992/04/24  12:03:58  sjg
  690. +  * Initial revision
  691. +  *
  692. +  */
  693. + 
  694. + #include <signal.h>
  695. + 
  696. + #ifndef SA_NOCLDSTOP            /* no sigaction() */
  697. + 
  698. + /*
  699. +  * if we haven't been told,
  700. +  * try and guess what we should implement with.
  701. +  */
  702. + #if !defined(USE_SIGSET) && !defined(USE_SIGMASK) && !defined(USE_SIGNAL)
  703. + # if defined(sigmask) || defined(BSD) || defined(_BSD) && !defined(BSD41)
  704. + #   define USE_SIGMASK
  705. + # else
  706. + #   ifndef NO_SIGSET
  707. + #     define USE_SIGSET
  708. + #   else
  709. + #     define USE_SIGNAL
  710. + #   endif
  711. + # endif
  712. + #endif
  713. + /*
  714. +  * if we still don't know, we're in trouble
  715. +  */
  716. + #if !defined(USE_SIGSET) && !defined(USE_SIGMASK) && !defined(USE_SIGNAL)
  717. + #pragma error must know what to implement with
  718. + #endif
  719. + 
  720. + #include "sigact.h"
  721. + 
  722. + 
  723. + 
  724. + int
  725. + sigaction(sig, act, oact)
  726. +   int sig;
  727. +   struct sigaction *act, *oact;
  728. + {
  729. +   void (*oldh)();
  730. + 
  731. +   if (act)
  732. +   {
  733. + #ifdef USE_SIGSET
  734. +     oldh = sigset(sig, act->sa_handler);
  735. + #else
  736. +     oldh = signal(sig, act->sa_handler);
  737. + #endif
  738. +   }
  739. +   else
  740. +   {
  741. +     if (oact)
  742. +     {      
  743. + #ifdef USE_SIGSET
  744. +       oldh = sigset(sig, SIG_IGN);
  745. + #else
  746. +       oldh = signal(sig, SIG_IGN);
  747. + #endif
  748. +       if (oldh != SIG_IGN)
  749. +       {
  750. + #ifdef USE_SIGSET
  751. +     (void) sigset(sig, oldh);
  752. + #else
  753. +     (void) signal(sig, oldh);
  754. + #endif
  755. +       }
  756. +     }
  757. +   }
  758. +   if (oact)
  759. +   {
  760. +     oact->sa_handler = oldh;
  761. +   }
  762. +   return 0;                /* hey we're faking it */
  763. + }
  764. + 
  765. + int
  766. + sigaddset(mask, sig)
  767. +   sigset_t *mask;
  768. +   int sig;
  769. + {
  770. +   *mask |= sigmask(sig);
  771. +   return 0;
  772. + }
  773. + 
  774. + 
  775. + int
  776. + sigdelset(mask, sig)
  777. +   sigset_t *mask;
  778. +   int sig;
  779. + {
  780. +   *mask &= ~(sigmask(sig));
  781. +   return 0;
  782. + }
  783. + 
  784. + 
  785. + int
  786. + sigemptyset(mask)
  787. +   sigset_t *mask;
  788. + {
  789. +   *mask = 0;
  790. +   return 0;
  791. + }
  792. + 
  793. + 
  794. + int
  795. + sigfillset(mask)
  796. +   sigset_t *mask;
  797. + {
  798. +   register int i;
  799. +   
  800. +   for (i = 1; i < NSIG; i++)
  801. +     *mask |= sigmask(i);
  802. +   return 0;
  803. + }
  804. + 
  805. + 
  806. + int
  807. + sigismember(mask, sig)
  808. +   sigset_t *mask;
  809. +   int sig;
  810. + {
  811. +   return ((*mask) & sigmask(sig));
  812. + }
  813. + 
  814. + 
  815. + int
  816. + sigpending(set)
  817. +   sigset_t *set;
  818. + {
  819. +   return 0;
  820. + }
  821. + 
  822. + 
  823. + int
  824. + sigprocmask(how, set, oldset)
  825. +   int how;
  826. +   sigset_t *set, *oldset;
  827. + {
  828. + #ifdef USE_SIGSET
  829. +   register int i;
  830. + #endif
  831. +   sigset_t sm;
  832. + 
  833. + #ifdef USE_SIGMASK
  834. +   sm = sigblock(0);
  835. + #else
  836. +   sm = 0;
  837. + #endif
  838. +   
  839. +   if (oldset)
  840. +     *oldset = sm;    /* dangerous ? */
  841. +   if (set)
  842. +   {
  843. +     switch (how)
  844. +     {
  845. +     case SIG_BLOCK:
  846. +       sm |= *set;
  847. +       break;
  848. +     case SIG_UNBLOCK:
  849. +       sm &= ~(*set);
  850. +       break;
  851. +     case SIG_SETMASK:
  852. +       sm = *set;
  853. +       break;
  854. +     }
  855. + #ifdef USE_SIGMASK
  856. +     (void) sigsetmask(sm);
  857. + #else
  858. + # ifdef USE_SIGSET
  859. +     for (i = 1; i < NSIG; i++)
  860. +     {
  861. +       if (how == SIG_UNBLOCK)
  862. +       {
  863. +     if (*set & sigmask(i))
  864. +       sigrelse(i);
  865. +       }
  866. +       else
  867. +     if (sm & sigmask(i))
  868. +     {
  869. +       sighold(i);
  870. +     }
  871. +     }
  872. + # endif
  873. + #endif
  874. +   }
  875. +   return 0;
  876. + }
  877. + 
  878. + 
  879. + int
  880. + sigsuspend(mask)
  881. +   sigset_t *mask;
  882. + {
  883. + #ifdef USE_SETSIG
  884. +   int sig = SIGCHLD;            /* our default */
  885. +   
  886. +   /*
  887. +    * add as many tests as you think sensible, but
  888. +    * SIGALRM, and SIGCHLD are probably the most
  889. +    * common.
  890. +    */
  891. +   if (*mask & sigmask(SIGALRM))
  892. +     sig = SIGALRM;
  893. +   else
  894. +     if (*mask & sigmask(SIGPIPE))
  895. +       sig = SIGPIPE;
  896. +   sigpause(sig);
  897. + #else
  898. + # ifdef USE_SIGMASK
  899. +   sigpause(mask);
  900. + # else
  901. +   pause();
  902. + # endif
  903. + #endif
  904. +   return 0;
  905. + }
  906. + 
  907. + #endif /* ! SA_NOCLDSTOP */
  908. + 
  909. + 
  910. + /* This lot (for GNU-Emacs) goes at the end of the file. */
  911. + /* 
  912. +  * Local Variables:
  913. +  * version-control:t
  914. +  * comment-column:40
  915. +  * End:
  916. +  */
  917. *** sh/stdh.h.old    Sat Apr 25 17:44:33 1992
  918. --- sh/stdh.h    Mon Apr 20 22:54:46 1992
  919. ***************
  920. *** 23,39 ****
  921.    *
  922.    */
  923.   
  924. ! #ifndef Void
  925. ! # if defined(__STDC__) || defined(__GNUC__)
  926. ! #   define    ARGS(args)    args    /* prototype declaration */
  927. ! #   define    Void    void        /* generic pointer */
  928. ! #   define    Const    const        /* constant data */
  929. ! #   define    Volatile volatile    /* you know */
  930.   # else
  931. ! #   define    ARGS(args)    ()    /* K&R declaration */
  932. ! #   define    Void    char
  933. ! #   define    Const    
  934. ! #   define    Volatile 
  935.   # endif
  936.   #endif
  937.   
  938. --- 23,38 ----
  939.    *
  940.    */
  941.   
  942. ! #ifndef ARGS
  943. ! # ifdef __STDC__
  944. ! #   define ARGS(args) args
  945.   # else
  946. ! #   define ARGS(args) ()
  947. ! #   ifdef VOID
  948. ! #     define void VOID
  949. ! #   endif
  950. ! #   define const
  951. ! #   define volatile
  952.   # endif
  953.   #endif
  954.   
  955. ***************
  956. *** 54,59 ****
  957. --- 53,60 ----
  958.   /* just in case they have sys/stdtypes and don't know it
  959.    */
  960.   #   ifndef    __sys_stdtypes_h
  961. + #define _PID_T
  962. + #define _CLOCK_T
  963.   typedef int pid_t;
  964.   typedef long clock_t;
  965.   #   endif
  966. ***************
  967. *** 67,82 ****
  968.   # endif
  969.   /* just a useful subset of what stdlib.h would have
  970.    */
  971. ! extern char * getenv  ARGS((Const char *));
  972. ! extern Void * malloc  ARGS((size_t));
  973. ! extern int    free    ARGS((Void *));
  974.   extern int    exit    ARGS((int));
  975. - #endif /* NOSTDHDRS */
  976.   
  977.   /* these _should_ match ANSI */
  978. ! extern char * strstr  ARGS((Const char *, Const char *));
  979. ! extern Void * memmove ARGS((Void *, Const Void *, size_t));
  980. ! extern Void * memcpy  ARGS((Void *, Const Void *, size_t));
  981.     
  982.   
  983.   #ifndef offsetof
  984. --- 68,83 ----
  985.   # endif
  986.   /* just a useful subset of what stdlib.h would have
  987.    */
  988. ! extern char * getenv  ARGS((const char *));
  989. ! extern void * malloc  ARGS((size_t));
  990. ! extern int    free    ARGS((void *));
  991.   extern int    exit    ARGS((int));
  992.   
  993.   /* these _should_ match ANSI */
  994. ! extern char * strstr  ARGS((const char *, const char *));
  995. ! extern void * memmove ARGS((void *, const void *, size_t));
  996. ! extern void * memcpy  ARGS((void *, const void *, size_t));
  997. ! #endif /* NOSTDHDRS */
  998.     
  999.   
  1000.   #ifndef offsetof
  1001. ***************
  1002. *** 83,88 ****
  1003.   #define    offsetof(type,id) ((size_t)&((type*)NULL)->id)
  1004.   #endif
  1005.   
  1006. - #if defined(F_SETFD) && !defined(FD_CLEXEC)
  1007. - # define FD_CLEXEC 1
  1008. - #endif
  1009. --- 84,86 ----
  1010. *** sh/syn.c.old    Sat Apr 25 17:44:34 1992
  1011. --- sh/syn.c    Sat Apr 25 18:37:29 1992
  1012. ***************
  1013. *** 3,10 ****
  1014.    */
  1015.   
  1016.   #ifndef lint
  1017. ! static char *RCSid = "$Id: syn.c,v 3.3 89/03/27 15:51:51 egisin Exp $";
  1018. ! static char *sccs_id = "@(#)syn.c    1.2 91/11/22 22:53:52 (sjg)";
  1019.   #endif
  1020.   
  1021.   #include "stdh.h"
  1022. --- 3,9 ----
  1023.    */
  1024.   
  1025.   #ifndef lint
  1026. ! static char *RCSid = "$Id: syn.c,v 1.2 1992/04/25 08:33:28 sjg Exp $";
  1027.   #endif
  1028.   
  1029.   #include "stdh.h"
  1030. ***************
  1031. *** 11,30 ****
  1032.   #include <errno.h>
  1033.   #include <setjmp.h>
  1034.   #include "sh.h"
  1035. - #include "lex.h"
  1036. - #include "tree.h"
  1037. - #include "table.h"
  1038.   #include "expand.h"
  1039.   
  1040. ! static    void    zzerr();
  1041. ! static    struct    op *block(), *newtp();
  1042. ! static    struct    op *pipeline(), *andor(), *command();
  1043. ! static    struct    op *nested(), *c_list();
  1044. ! static    struct    op *dogroup(), *thenpart(), *casepart(), *caselist();
  1045. ! static    struct    op *elsepart();
  1046. ! static    char  **wordlist();
  1047. ! static    void    musthave();
  1048. ! static    struct ioword *synio(), *io();
  1049.   
  1050.   static    struct    op    *outtree; /* yyparse output */
  1051.   
  1052. --- 10,33 ----
  1053.   #include <errno.h>
  1054.   #include <setjmp.h>
  1055.   #include "sh.h"
  1056.   #include "expand.h"
  1057.   
  1058. ! static struct op *pipeline  ARGS((int cf));
  1059. ! static struct op *andor     ARGS((void));
  1060. ! static struct op *c_list    ARGS((void));
  1061. ! static struct ioword *synio ARGS((int cf));
  1062. ! static void     musthave    ARGS((int c, int cf));
  1063. ! static struct op *nested    ARGS((int type, int mark));
  1064. ! static struct op *command   ARGS((int cf));
  1065. ! static struct op *dogroup   ARGS((int onlydone));
  1066. ! static struct op *thenpart  ARGS((void));
  1067. ! static struct op *elsepart  ARGS((void));
  1068. ! static struct op *caselist  ARGS((void));
  1069. ! static struct op *casepart  ARGS((void));
  1070. ! static char **  wordlist    ARGS((void));
  1071. ! static struct op *block     ARGS((int type, struct op *t1, struct op *t2, char **wp));
  1072. ! static struct op *newtp     ARGS((int type));
  1073. ! static void     zzerr       ARGS((void));
  1074.   
  1075.   static    struct    op    *outtree; /* yyparse output */
  1076.   
  1077. ***************
  1078. *** 102,109 ****
  1079.       t = andor();
  1080.       if (t != NULL) {
  1081.           while ((c = token(0)) == ';' || c == '&' ||
  1082. !                (multiline || source->type == SSTRING
  1083. !                 || source->type == SALIAS) && c == '\n') {
  1084.               if (c == '&') {
  1085.                   if (tl)
  1086.                       tl->right = block(TASYNC, tl->right, NOBLOCK, NOWORDS);
  1087. --- 105,112 ----
  1088.       t = andor();
  1089.       if (t != NULL) {
  1090.           while ((c = token(0)) == ';' || c == '&' ||
  1091. !                ((multiline || source->type == SSTRING
  1092. !                 || (source->type == SALIAS)) && c == '\n')) {
  1093.               if (c == '&') {
  1094.                   if (tl)
  1095.                       tl->right = block(TASYNC, tl->right, NOBLOCK, NOWORDS);
  1096. ***************
  1097. *** 328,338 ****
  1098.       }
  1099.   
  1100.       if (iopn == 0) {
  1101. !         afree((Void*) iops, ATEMP);
  1102.           t->ioact = NULL;
  1103.       } else {
  1104.           iops[iopn++] = NULL;
  1105. !         aresize((Void*) iops, sizeofN(struct ioword *, iopn), ATEMP);
  1106.           t->ioact = iops;
  1107.       }
  1108.   
  1109. --- 331,341 ----
  1110.       }
  1111.   
  1112.       if (iopn == 0) {
  1113. !         afree((void*) iops, ATEMP);
  1114.           t->ioact = NULL;
  1115.       } else {
  1116.           iops[iopn++] = NULL;
  1117. !         aresize((void*) iops, sizeofN(struct ioword *, iopn), ATEMP);
  1118.           t->ioact = iops;
  1119.       }
  1120.   
  1121. ***************
  1122. *** 497,503 ****
  1123.       return (t);
  1124.   }
  1125.   
  1126. ! Const    struct res {
  1127.       char    *name;
  1128.       int    val;
  1129.   } restab[] = {
  1130. --- 500,506 ----
  1131.       return (t);
  1132.   }
  1133.   
  1134. ! const    struct res {
  1135.       char    *name;
  1136.       int    val;
  1137.   } restab[] = {
  1138. ***************
  1139. *** 523,529 ****
  1140.   
  1141.   keywords()
  1142.   {
  1143. !     register struct res Const *rp;
  1144.       register struct tbl *p;
  1145.   
  1146.       for (rp = restab; rp->name; rp++) {
  1147. --- 526,532 ----
  1148.   
  1149.   keywords()
  1150.   {
  1151. !     register struct res const *rp;
  1152.       register struct tbl *p;
  1153.   
  1154.       for (rp = restab; rp->name; rp++) {
  1155. *** sh/table.c.old    Sat Apr 25 17:44:34 1992
  1156. --- sh/table.c    Sat Apr 25 18:37:32 1992
  1157. ***************
  1158. *** 1,6 ****
  1159.   #ifndef lint
  1160. ! static char *RCSid = "$Id: table.c,v 3.2 89/03/27 15:51:58 egisin Exp $";
  1161. ! static char *sccs_id = "@(#)table.c    1.2 91/11/22 22:53:55 (sjg)";
  1162.   #endif
  1163.   
  1164.   /*
  1165. --- 1,5 ----
  1166.   #ifndef lint
  1167. ! static char *RCSid = "$Id: table.c,v 1.2 1992/04/25 08:33:28 sjg Exp $";
  1168.   #endif
  1169.   
  1170.   /*
  1171. ***************
  1172. *** 11,17 ****
  1173.   #include <errno.h>
  1174.   #include <setjmp.h>
  1175.   #include "sh.h"
  1176. - #include "table.h"
  1177.   
  1178.   #define    INIT_TBLS    8    /* initial table size (power of 2) */
  1179.   
  1180. --- 10,15 ----
  1181. ***************
  1182. *** 20,27 ****
  1183.       struct tbl **next;
  1184.   } tstate;
  1185.   
  1186. ! static void texpand();
  1187.   
  1188.   unsigned int
  1189.   hash(n)
  1190.       register char * n;
  1191. --- 18,27 ----
  1192.       struct tbl **next;
  1193.   } tstate;
  1194.   
  1195. ! static void     texpand     ARGS((struct table *tp, int nsize));
  1196. ! static int      tnamecmp    ARGS((void *p1, void *p2));
  1197.   
  1198. + 
  1199.   unsigned int
  1200.   hash(n)
  1201.       register char * n;
  1202. ***************
  1203. *** 70,76 ****
  1204.       for (i = 0; i < osize; i++)
  1205.           if ((tblp = otblp[i]) != NULL)
  1206.               if ((tblp->flag&DEFINED)) {
  1207. !                 for (p = &ntblp[hash(tblp->name) & tp->size-1];
  1208.                        *p != NULL; p--)
  1209.                       if (p == ntblp) /* wrap */
  1210.                           p += tp->size;
  1211. --- 70,77 ----
  1212.       for (i = 0; i < osize; i++)
  1213.           if ((tblp = otblp[i]) != NULL)
  1214.               if ((tblp->flag&DEFINED)) {
  1215. !                 for (p = &ntblp[hash(tblp->name) &
  1216. !                         (tp->size-1)];
  1217.                        *p != NULL; p--)
  1218.                       if (p == ntblp) /* wrap */
  1219.                           p += tp->size;
  1220. ***************
  1221. *** 77,85 ****
  1222.                   *p = tblp;
  1223.                   tp->free--;
  1224.               } else {
  1225. !                 afree((Void*)tblp, tp->areap);
  1226.               }
  1227. !     afree((Void*)otblp, tp->areap);
  1228.   }
  1229.   
  1230.   struct tbl *
  1231. --- 78,86 ----
  1232.                   *p = tblp;
  1233.                   tp->free--;
  1234.               } else {
  1235. !                 afree((void*)tblp, tp->areap);
  1236.               }
  1237. !     afree((void*)otblp, tp->areap);
  1238.   }
  1239.   
  1240.   struct tbl *
  1241. ***************
  1242. *** 94,100 ****
  1243.           return NULL;
  1244.   
  1245.       /* search for name in hashed table */
  1246. !     for (pp = &tp->tbls[h & tp->size-1]; (p = *pp) != NULL; pp--) {
  1247.           if (*p->name == *n && strcmp(p->name, n) == 0
  1248.               && (p->flag&DEFINED))
  1249.               return p;
  1250. --- 95,101 ----
  1251.           return NULL;
  1252.   
  1253.       /* search for name in hashed table */
  1254. !     for (pp = &tp->tbls[h & (tp->size-1)]; (p = *pp) != NULL; pp--) {
  1255.           if (*p->name == *n && strcmp(p->name, n) == 0
  1256.               && (p->flag&DEFINED))
  1257.               return p;
  1258. ***************
  1259. *** 118,124 ****
  1260.           texpand(tp, INIT_TBLS);
  1261.     Search:
  1262.       /* search for name in hashed table */
  1263. !     for (pp = &tp->tbls[h & tp->size-1]; (p = *pp) != NULL; pp--) {
  1264.           if (*p->name == *n && strcmp(p->name, n) == 0)
  1265.               return p;     /* found */
  1266.           if (pp == tp->tbls) /* wrap */
  1267. --- 119,125 ----
  1268.           texpand(tp, INIT_TBLS);
  1269.     Search:
  1270.       /* search for name in hashed table */
  1271. !     for (pp = &tp->tbls[h & (tp->size-1)]; (p = *pp) != NULL; pp--) {
  1272.           if (*p->name == *n && strcmp(p->name, n) == 0)
  1273.               return p;     /* found */
  1274.           if (pp == tp->tbls) /* wrap */
  1275. ***************
  1276. *** 174,180 ****
  1277.   
  1278.   static int
  1279.   tnamecmp(p1, p2)
  1280. !     Void *p1, *p2;
  1281.   {
  1282.       return strcmp(((struct tbl *)p1)->name, ((struct tbl *)p2)->name);
  1283.   }
  1284. --- 175,181 ----
  1285.   
  1286.   static int
  1287.   tnamecmp(p1, p2)
  1288. !     void *p1, *p2;
  1289.   {
  1290.       return strcmp(((struct tbl *)p1)->name, ((struct tbl *)p2)->name);
  1291.   }
  1292. ***************
  1293. *** 193,199 ****
  1294.           if ((*dp = *sp++) != NULL && ((*dp)->flag&DEFINED))
  1295.               dp++;
  1296.       i = dp - p;
  1297. !     qsortp((Void**)p, (size_t)i, tnamecmp);
  1298.       p[i] = NULL;
  1299.       return p;
  1300.   }
  1301. --- 194,200 ----
  1302.           if ((*dp = *sp++) != NULL && ((*dp)->flag&DEFINED))
  1303.               dp++;
  1304.       i = dp - p;
  1305. !     qsortp((void**)p, (size_t)i, tnamecmp);
  1306.       p[i] = NULL;
  1307.       return p;
  1308.   }
  1309. *** sh/table.h.old    Sat Apr 25 17:41:37 1992
  1310. --- sh/table.h    Sat Apr 25 18:37:35 1992
  1311. ***************
  1312. *** 1,4 ****
  1313. ! /* $Id: table.h,v 3.2 89/03/27 15:46:52 egisin Exp $ */
  1314.   
  1315.   /*
  1316.    * generic hashed associative table for commands and variables.
  1317. --- 1,4 ----
  1318. ! /* $Id: table.h,v 1.2 1992/04/25 08:33:28 sjg Exp $ */
  1319.   
  1320.   /*
  1321.    * generic hashed associative table for commands and variables.
  1322. ***************
  1323. *** 80,86 ****
  1324.       char   *name;
  1325.       int  (*func)();
  1326.   };
  1327. ! Extern Const struct builtin shbuiltins [], kshbuiltins [];
  1328.   
  1329.   /* var spec values */
  1330.   #define    V_NONE    0
  1331. --- 80,89 ----
  1332.       char   *name;
  1333.       int  (*func)();
  1334.   };
  1335. ! 
  1336. ! /* these really are externs! Look in table.c for them */
  1337. ! 
  1338. ! extern const struct builtin shbuiltins [], kshbuiltins [];
  1339.   
  1340.   /* var spec values */
  1341.   #define    V_NONE    0
  1342. *** sh/trace.c.old    Sat Apr 25 17:44:35 1992
  1343. --- sh/trace.c    Sun Apr 19 19:21:42 1992
  1344. ***************
  1345. *** 63,73 ****
  1346.   # define TRUE  1
  1347.   # define FALSE 0
  1348.   #endif
  1349. ! #ifndef _P_
  1350.   # if defined(__STDC__) || defined(PROTO)
  1351. ! #   define _P_(p) p
  1352.   # else
  1353. ! #   define _P_(p) ()
  1354.   # endif
  1355.   #endif
  1356.   
  1357. --- 63,73 ----
  1358.   # define TRUE  1
  1359.   # define FALSE 0
  1360.   #endif
  1361. ! #ifndef ARGS
  1362.   # if defined(__STDC__) || defined(PROTO)
  1363. ! #   define ARGS(p) p
  1364.   # else
  1365. ! #   define ARGS(p) ()
  1366.   # endif
  1367.   #endif
  1368.   
  1369. ***************
  1370. *** 85,91 ****
  1371.    * RETURN VALUE:
  1372.    *      None
  1373.    */
  1374. ! extern char * _CDECL strdup    _P_((char *s));
  1375.     
  1376.   #ifdef __STDC__
  1377.   # include <stdarg.h>
  1378. --- 85,91 ----
  1379.    * RETURN VALUE:
  1380.    *      None
  1381.    */
  1382. ! extern char * _CDECL strdup    ARGS((char *s));
  1383.     
  1384.   #ifdef __STDC__
  1385.   # include <stdarg.h>
  1386. ***************
  1387. *** 109,115 ****
  1388.   checkpoint(va_alist)
  1389.     va_dcl
  1390.   {
  1391. !   extern char *getenv    _P_((char *var));
  1392.     char *fmt;
  1393.     int c;
  1394.     va_list arg_ptr;
  1395. --- 109,115 ----
  1396.   checkpoint(va_alist)
  1397.     va_dcl
  1398.   {
  1399. !   extern char *getenv    ARGS((char *var));
  1400.     char *fmt;
  1401.     int c;
  1402.     va_list arg_ptr;
  1403. *** sh/trace.h.old    Sat Apr 25 17:44:35 1992
  1404. --- sh/trace.h    Sun Apr 19 19:21:43 1992
  1405. ***************
  1406. *** 33,43 ****
  1407.   # define TRUE  1
  1408.   # define FALSE 0
  1409.   #endif
  1410. ! #ifndef _P_
  1411.   # if defined(__STDC__) || defined(PROTO)
  1412. ! #   define _P_(p) p
  1413.   # else
  1414. ! #   define _P_(p) ()
  1415.   # endif
  1416.   #endif
  1417.   
  1418. --- 33,43 ----
  1419.   # define TRUE  1
  1420.   # define FALSE 0
  1421.   #endif
  1422. ! #ifndef ARGS
  1423.   # if defined(__STDC__) || defined(PROTO)
  1424. ! #   define ARGS(p) p
  1425.   # else
  1426. ! #   define ARGS(p) ()
  1427.   # endif
  1428.   #endif
  1429.   
  1430. ***************
  1431. *** 71,77 ****
  1432.   EXTERN char * _CDECL    Trace_log;
  1433.   EXTERN int _CDECL     Trace_level;
  1434.   
  1435. ! void _CDECL checkpoint    _P_((char *fmt, ...));
  1436.   
  1437.   /*
  1438.    * This macro takes a variabel number of args. 
  1439. --- 71,77 ----
  1440.   EXTERN char * _CDECL    Trace_log;
  1441.   EXTERN int _CDECL     Trace_level;
  1442.   
  1443. ! void _CDECL checkpoint    ARGS((char *fmt, ...));
  1444.   
  1445.   /*
  1446.    * This macro takes a variabel number of args. 
  1447.  
  1448. exit 0 # Just in case...
  1449.