home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2266 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  45.0 KB
  1. From: netnews@netcom.UUCP (USENET Administration)
  2. Newsgroups: alt.sources
  3. Subject: Public Domain Korn Shell - Part.02 of 7
  4. Message-ID: <18607@netcom.UUCP>
  5. Date: 12 Dec 90 11:35:35 GMT
  6.  
  7. #!/bin/sh
  8. # This is part 02 of ksh-pd
  9. # ============= src/lex.h ==============
  10. if test ! -d 'src'; then
  11.     echo 'x - creating directory src'
  12.     mkdir 'src'
  13. fi
  14. if test -f 'src/lex.h' -a X"$1" != X"-c"; then
  15.     echo 'x - skipping src/lex.h (File already exists)'
  16. else
  17. echo 'x - extracting src/lex.h (Text)'
  18. sed 's/^X//' << 'SHAR_EOF' > 'src/lex.h' &&
  19. X/*
  20. X * Source input, lexer and parser
  21. X */
  22. X
  23. X/* $Header: /tmp/egisin/src/RCS/lex.h,v 3.2 88/12/17 21:40:07 egisin Exp $ */
  24. X
  25. X#define    IDENT    64
  26. X
  27. Xtypedef struct source Source;
  28. Xstruct source {
  29. X    char   *str;        /* input pointer */
  30. X    int    type;        /* input type */
  31. X    union {
  32. X        char  **strv;    /* string [] */
  33. X        FILE   *file;    /* file */
  34. X        struct tbl *tblp; /* alias */
  35. X    } u;
  36. X    int    line;        /* line number */
  37. X    char   *file;        /* input file name */
  38. X    int    echo;        /* echo input to shlout */
  39. X    Source *next;        /* stacked source */
  40. X};
  41. X
  42. X/* Source.type values */
  43. X#define    SEOF    0        /* input EOF */
  44. X#define    STTY    1        /* terminal input */
  45. X#define    SFILE    2        /* file input */
  46. X#define    SSTRING    4        /* string */
  47. X#define    SWSTR    3        /* string without \n */
  48. X#define    SWORDS    5        /* string[] */
  49. X#define    SWORDSEP 8        /* string[] seperator */
  50. X#define    SALIAS    6        /* alias expansion */
  51. X#define    SHIST    7        /* history expansion */
  52. X
  53. XSource *pushs ARGS((int stype));     /* push Source */
  54. Xstruct op *compile ARGS((Source *s));    /* compile tree */
  55. X
  56. X/*
  57. X * states while lexing word
  58. X */
  59. X#define    SBASE    0        /* outside any lexical constructs */
  60. X#define    SWORD    6        /* implicit quoting for substitute() */
  61. X#define    SSQUOTE    1        /* inside '' */
  62. X#define    SDQUOTE    2        /* inside "" */
  63. X#define    SBRACE    3        /* inside ${} */
  64. X#define    SPAREN    4        /* inside $() */
  65. X#define    SBQUOTE    5        /* inside `` */
  66. X
  67. XExtern    int    multiline;    /* \n changed to ; */
  68. X
  69. Xtypedef union {
  70. X    int    i;
  71. X    char   *cp;
  72. X    char  **wp;
  73. X    struct op *o;
  74. X    struct ioword *iop;
  75. X} YYSTYPE;
  76. X
  77. X#define    LWORD    256
  78. X#define    LOGAND    257
  79. X#define    LOGOR    258
  80. X#define    BREAK    259
  81. X#define    IF    260
  82. X#define    THEN    261
  83. X#define    ELSE    262
  84. X#define    ELIF    263
  85. X#define    FI    264
  86. X#define    CASE    265
  87. X#define    ESAC    266
  88. X#define    FOR    267
  89. X#define    WHILE    268
  90. X#define    UNTIL    269
  91. X#define    DO    270
  92. X#define    DONE    271
  93. X#define    IN    272
  94. X#define    FUNCTION 273
  95. X#define    TIME    274
  96. X#define    REDIR    275
  97. X#define    MPAREN    276        /* () */
  98. X#define    YYERRCODE 300
  99. X
  100. X/* flags to yylex */
  101. X#define    CONTIN    BIT(0)        /* skip new lines to complete command */
  102. X#define    ONEWORD    BIT(1)        /* single word for substitute() */
  103. X#define    ALIAS    BIT(2)        /* recognize alias */
  104. X#define    KEYWORD    BIT(3)        /* recognize keywords */
  105. X
  106. X#define    SYNTAXERR    zzerr()
  107. X#define    HERES    10        /* max << in line */
  108. X
  109. XExtern    char    line [LINE+1];    /* input line */
  110. XExtern    Source *source;        /* yyparse/yylex source */
  111. XExtern    YYSTYPE    yylval;        /* result from yylex */
  112. XExtern    int    yynerrs;
  113. XExtern    struct ioword *heres [HERES], **herep;
  114. XExtern    char    ident [IDENT+1];
  115. X
  116. Xextern    int    yylex ARGS((int flags));
  117. Xextern    void    yyerror ARGS((Const char *msg));
  118. X
  119. X#define    HISTORY    100        /* size of saved history */
  120. X
  121. Xextern    char   *history [HISTORY];    /* saved commands */
  122. Xextern    char  **histptr;    /* last history item */
  123. Xextern    int    histpush;    /* number of pushed fc commands */
  124. X
  125. SHAR_EOF
  126. true || echo 'restore of src/lex.h failed'
  127. fi
  128. # ============= src/tree.h ==============
  129. if test -f 'src/tree.h' -a X"$1" != X"-c"; then
  130.     echo 'x - skipping src/tree.h (File already exists)'
  131. else
  132. echo 'x - extracting src/tree.h (Text)'
  133. sed 's/^X//' << 'SHAR_EOF' > 'src/tree.h' &&
  134. X/*
  135. X * command trees for compile/execute
  136. X */
  137. X
  138. X/* $Header: /tmp/egisin/src/RCS/tree.h,v 3.2 88/12/17 21:40:31 egisin Exp $ */
  139. X
  140. X#define    NOBLOCK    ((struct op *)NULL)
  141. X#define    NOWORD    ((char *)NULL)
  142. X#define    NOWORDS    ((char **)NULL)
  143. X
  144. X/*
  145. X * Description of a command or an operation on commands.
  146. X */
  147. Xstruct op {
  148. X    int    type;            /* operation type, see below */
  149. X    char  **args;            /* arguments to a command */
  150. X    char  **vars;            /* variable assignments */
  151. X    struct ioword    **ioact;    /* IO actions (eg, < > >>) */
  152. X    struct op *left, *right;     /* descendents */
  153. X    char   *str;        /* identifier for case and for (use vars[0]) */
  154. X};
  155. X
  156. X/* Tree.type values */
  157. X#define    TEOF    0
  158. X#define    TCOM    1        /* command */
  159. X#define    TPAREN    2        /* (c-list) */
  160. X#define    TPIPE    3        /* a | b */
  161. X#define    TLIST    4        /* a [&;] b */
  162. X#define    TOR    5        /* || */
  163. X#define    TAND    6        /* && */
  164. X#define    TFOR    7
  165. X#define    TCASE    9
  166. X#define    TIF    10
  167. X#define    TWHILE    11
  168. X#define    TUNTIL    12
  169. X#define    TELIF    13
  170. X#define    TPAT    14        /* pattern in case */
  171. X#define    TBRACE    15        /* {c-list} */
  172. X#define    TASYNC    16        /* c & */
  173. X#define    TFUNCT    17        /* function name { command; } */
  174. X#define    TTIME    18        /* time pipeline */
  175. X#define    TEXEC    19        /* fork/exec eval'd TCOM */
  176. X
  177. X/*
  178. X * prefix codes for words in command tree
  179. X */
  180. X#define    EOS    0        /* end of string */
  181. X#define    CHAR    1        /* unquoted character */
  182. X#define    QCHAR    2        /* quoted character */
  183. X#define    COMSUB    3        /* $() substitution (0 terminated) */
  184. X#define    OQUOTE    4        /* opening " or ' */
  185. X#define    CQUOTE    5        /* closing " or ' */
  186. X#define    OSUBST    6        /* opening ${ substitution */
  187. X#define    CSUBST    7        /* closing } of above */
  188. X
  189. X/*
  190. X * IO redirection
  191. X */
  192. Xstruct ioword {
  193. X    short    unit;    /* unit affected */
  194. X    short    flag;    /* action (below) */
  195. X    char   *name;    /* file name */
  196. X};
  197. X
  198. X/* ioword.flag - type of redirection */
  199. X#define    IOTYPE    0xF        /* type: bits 0:3 */
  200. X#define    IOREAD    0x1        /* < */
  201. X#define    IOWRITE    0x2        /* > */
  202. X#define    IORDWR    0x3        /* <>: todo */
  203. X#define    IOHERE    0x4        /* << (here file) */
  204. X#define    IOCAT    0x5        /* >> */
  205. X#define    IODUP    0x6        /* <&/>& */
  206. X#define    IOEVAL    BIT(4)        /* expand in << */
  207. X#define    IOSKIP    BIT(5)        /* <<-, skip ^\t* */
  208. X#define    IOCLOB    BIT(6)        /* >!, override -o noclob */
  209. X
  210. X/* values for E_LOOP longjmp */
  211. X#define    LBREAK    1
  212. X#define    LCONTIN    2
  213. X
  214. X/* execute/exchild flags */
  215. X#define    XEXEC    BIT(0)        /* execute without forking */
  216. X#define    XFORK    BIT(5)        /* fork before executing */
  217. X#define    XBGND    BIT(1)        /* command & */
  218. X#define    XPIPEI    BIT(2)        /* input is pipe */
  219. X#define    XPIPEO    BIT(3)        /* output is pipe */
  220. X#define    XPIPE    (XPIPEI|XPIPEO)    /* member of pipe */
  221. X#define    XXCOM    BIT(4)        /* dup2 xcomfd to 1 */
  222. X
  223. X/*
  224. X * flags to control expansion of words
  225. X */
  226. X#define    DOBLANK    BIT(1)        /* perform blank interpretation */
  227. X#define    DOGLOB    BIT(2)        /* expand [?* */
  228. X#define    DOPAT    BIT(3)        /* quote *?[ */
  229. X#define    DOTILDE    BIT(5)        /* expand ~ */
  230. X
  231. X/* job.c: job control primatives */
  232. Xint    execute ARGS((struct op *, int flags));    /* execute tree */
  233. Xint    exchild ARGS((struct op *, int flags));    /* execute tree as child */
  234. Xint    waitfor ARGS((int job));         /* wait for job completion */
  235. Xint    waitlast ARGS((void));            /* wait for last job */
  236. X
  237. X/* eval.c: word expansion */
  238. Xchar  **eval ARGS((char **wv, int flag));     /* expand words */
  239. Xchar   *evalstr ARGS((char *wp, int flags));    /* expand word */
  240. Xchar   *substitute ARGS((Const char *s, int flags)); /* compile and expand string */
  241. X
  242. X/* tree.c: command trees */
  243. Xvoid    ptree ARGS((struct op *t, FILE *f));    /* print tree */
  244. Xchar   *wdscan ARGS((char *wp, int c));        /* scan word for prefix */
  245. Xchar   *wdcopy ARGS((char *wp, Area *));    /* copy word */
  246. Xstruct op *tcopy ARGS((struct op *t, Area *));    /* copy tree */
  247. Xvoid    tfree ARGS((struct op *t, Area *));    /* free tree */
  248. X
  249. SHAR_EOF
  250. true || echo 'restore of src/tree.h failed'
  251. fi
  252. # ============= src/tty.h ==============
  253. if test -f 'src/tty.h' -a X"$1" != X"-c"; then
  254.     echo 'x - skipping src/tty.h (File already exists)'
  255. else
  256. echo 'x - extracting src/tty.h (Text)'
  257. sed 's/^X//' << 'SHAR_EOF' > 'src/tty.h' &&
  258. X/*
  259. X    tty.h -- centralized definitions for a variety of terminal interfaces
  260. X
  261. X    created by DPK, Oct. 1986
  262. X
  263. X    last edit:    30-Jul-1987    D A Gwyn
  264. X*/
  265. X
  266. X#if _BSD_SYSV            /* BRL UNIX System V emulation */
  267. X#include <termio.h>    /* includes <sys/_ioctl.h> */
  268. X#ifndef NTTYDISC
  269. X#define    TIOCGETD    _IOR( 't', 0, int )
  270. X#define    TIOCSETD    _IOW( 't', 1, int )
  271. X#define    NTTYDISC    2
  272. X#endif
  273. X#ifndef TIOCSTI
  274. X#define    TIOCSTI        _IOW( 't', 114, char )
  275. X#endif
  276. X#ifndef TIOCSPGRP
  277. X#define    TIOCSPGRP    _IOW( 't', 118, int )
  278. X#endif
  279. X#else    /* !_BSD_SYSV */
  280. X#if _BSD
  281. X#include <sys/ioctl.h>
  282. X#else
  283. X#include <termio.h>
  284. X#endif
  285. X#endif    /* _BSD_SYSV */
  286. SHAR_EOF
  287. true || echo 'restore of src/tty.h failed'
  288. fi
  289. # ============= src/version.c ==============
  290. if test -f 'src/version.c' -a X"$1" != X"-c"; then
  291.     echo 'x - skipping src/version.c (File already exists)'
  292. else
  293. echo 'x - extracting src/version.c (Text)'
  294. sed 's/^X//' << 'SHAR_EOF' > 'src/version.c' &&
  295. X/*
  296. X * value of $KSH_VERSION
  297. X */
  298. X
  299. Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/version.c,v 3.2 88/12/14 20:10:41 egisin Exp $";
  300. X
  301. X#include <stddef.h>
  302. X#include <setjmp.h>
  303. X#include "sh.h"
  304. X
  305. Xchar ksh_version [] =
  306. X    "KSH_VERSION=@(#) PD alpha $Revision: 3.2 $ $Date: 88/12/14 20:10:41 $";
  307. X
  308. X/***
  309. X$Log:    version.c,v $
  310. XRevision 3.2  88/12/14  20:10:41  egisin
  311. Xmany fixes
  312. X
  313. XRevision 3.1  88/11/03  09:18:36  egisin
  314. Xalpha distribution
  315. X
  316. XRevision 1.3  88/10/20  17:34:03  egisin
  317. Xadded @(#) to ksh_version
  318. X
  319. XRevision 1.2  88/09/27  19:01:58  egisin
  320. Xfix version.c
  321. X
  322. XRevision 1.1  88/09/27  18:59:06  egisin
  323. XInitial revision
  324. X***/
  325. X
  326. SHAR_EOF
  327. true || echo 'restore of src/version.c failed'
  328. fi
  329. # ============= src/main.c ==============
  330. if test -f 'src/main.c' -a X"$1" != X"-c"; then
  331.     echo 'x - skipping src/main.c (File already exists)'
  332. else
  333. echo 'x - extracting src/main.c (Text)'
  334. sed 's/^X//' << 'SHAR_EOF' > 'src/main.c' &&
  335. X/*
  336. X * startup, main loop, enviroments and error handling
  337. X */
  338. X
  339. Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/main.c,v 3.2 88/12/17 19:56:54 egisin Exp $";
  340. X
  341. X#define    Extern                /* define Externs in sh.h */
  342. X
  343. X#include <stddef.h>
  344. X#include <stdlib.h>
  345. X#include <stdio.h>
  346. X#include <string.h>
  347. X#include <unistd.h>
  348. X#include <fcntl.h>
  349. X#include <signal.h>
  350. X#include <errno.h>
  351. X#include <setjmp.h>
  352. X#include "sh.h"
  353. X#include "lex.h"
  354. X#include "tree.h"
  355. X#include "table.h"
  356. X
  357. X/*
  358. X * global data
  359. X */
  360. X
  361. XArea    aperm;
  362. X
  363. Xstatic    void    reclaim ARGS((void));
  364. X
  365. X/*
  366. X * shell initialization
  367. X */
  368. X
  369. Xstatic    char    initifs [] = "IFS= \t\n"; /* must be R/W */
  370. X
  371. Xstatic    Const    char   initsubs [] = 
  372. X  "${SHELL:=/bin/sh} ${PATH:=/bin:/usr/bin:.} ${HOME:=/} ${PS1:=$ } ${PS2:=> }";
  373. X
  374. Xstatic    Const    char *initcoms [] = {
  375. X    "cd", ".", NULL,        /* set up $PWD */
  376. X    "typeset", "-x", "SHELL", "PATH", "HOME", NULL,
  377. X    "typeset", "-r", "PWD", "OLDPWD", NULL,
  378. X    "typeset", "-i", "SECONDS=0", "OPTIND", NULL,
  379. X    "alias",
  380. X      "integer=typeset -i", "pwd=print -r \"$PWD\"",
  381. X      "history=fc -l", "r=fc -s", "nohup=nohup ",
  382. X      "login=exec login", "newgrp=exec newgrp",
  383. X      "type=whence -v", "functions=typeset -f",
  384. X      "echo=print", "true=:", "false=let", "[=\\[", NULL,
  385. X    NULL
  386. X};
  387. X
  388. Xmain(argc, argv, envp)
  389. X    int argc;
  390. X    register char **argv;
  391. X    char **envp;
  392. X{
  393. X    register int i;
  394. X    register char *arg;
  395. X    int cflag = 0, qflag = 0;
  396. X    char *name;
  397. X    register Source *s;
  398. X    register struct block *l = &globals;
  399. X    register char **wp0, **wp;
  400. X    extern char ksh_version [];
  401. X
  402. X    ainit(&aperm);        /* initialize permanent Area */
  403. X
  404. X    /* set up base enviroment */
  405. X    e.type = E_NONE;
  406. X    ainit(&e.area);
  407. X    e.loc = l;
  408. X    e.savefd = NULL;
  409. X    e.oenv = NULL;
  410. X
  411. X    initctypes();
  412. X
  413. X    /* open file streams for fd's 0,1,2 */
  414. X    fopenshf(0);    fopenshf(1);    fopenshf(2);
  415. X
  416. X    /* set up variable and command dictionaries */
  417. X    newblock();        /* set up global l->vars and l->funs */
  418. X    tinit(&commands, APERM);
  419. X    tinit(&builtins, APERM);
  420. X    tinit(&lexicals, APERM);
  421. X    tinit(&homedirs, APERM);
  422. X
  423. X    /* import enviroment */
  424. X    if (envp != NULL)
  425. X        for (wp = envp; *wp != NULL; wp++)
  426. X            import(*wp);
  427. X
  428. X    typeset(initifs, 0, 0);    /* for security */
  429. X    typeset(ksh_version, 0, 0); /* RDONLY */
  430. X
  431. X    /* define shell keywords */
  432. X    keywords();
  433. X
  434. X    /* define built-in commands */
  435. X    for (i = 0; shbuiltins[i].name != NULL; i++)
  436. X        builtin(shbuiltins[i].name, shbuiltins[i].func);
  437. X    for (i = 0; kshbuiltins[i].name != NULL; i++)
  438. X        builtin(kshbuiltins[i].name, kshbuiltins[i].func);
  439. X
  440. X    /* assign default shell variable values */
  441. X    substitute(initsubs, 0);
  442. X    /* execute initialization statements */
  443. X    for (wp0 = (char**) initcoms; *wp0 != NULL; wp0 = wp+1) {
  444. X        /* copy because the alias initializers are readonly */
  445. X        for (wp = wp0; *wp != NULL; wp++)
  446. X            *wp = strsave(*wp, ATEMP);
  447. X        shcomexec(wp0);
  448. X    }
  449. X    afreeall(ATEMP);
  450. X
  451. X    if (geteuid() == 0)
  452. X        setstr(global("PS1"), "# ");
  453. X
  454. X    s = pushs(SFILE);
  455. X    s->u.file = stdin;
  456. X    cflag = 0;
  457. X    name = *argv++;
  458. X
  459. X    /* what a bloody mess */
  460. X    if (--argc >= 1) {
  461. X        if (argv[0][0] == '-' && argv[0][1] != '\0') {
  462. X            for (arg = argv[0]+1; *arg; arg++)
  463. X                switch (*arg) {
  464. X                  case 'c':
  465. X                    cflag = 1;
  466. X                    if (--argc > 0) {
  467. X                        s->type = SSTRING;
  468. X                        s->str = *++argv;
  469. X                    }
  470. X                    break;
  471. X    
  472. X                  case 'q':
  473. X                    qflag = 1;
  474. X                    break;
  475. X
  476. X                  default:
  477. X                    if (*arg>='a' && *arg<='z')
  478. X                        flag[FLAG(*arg)]++;
  479. X                }
  480. X        } else {
  481. X            argv--;
  482. X            argc++;
  483. X        }
  484. X        if (s->type == SFILE && --argc > 0) {
  485. X            if ((s->u.file = fopen(*++argv, "r")) == NULL)
  486. X                errorf("%s: cannot open\n", *argv);
  487. X            s->file = *argv;
  488. X            fileno(s->u.file) = savefd(fileno(s->u.file));
  489. X            setvbuf(s->u.file, (char *)NULL, _IOFBF, BUFSIZ);
  490. X        }
  491. X    }
  492. X
  493. X    if (s->type == SFILE) {
  494. X        if (fileno(s->u.file) == 0)
  495. X            flag[FSTDIN] = 1;
  496. X        if (isatty(0) && isatty(1) && !cflag)
  497. X            flag[FTALKING] = 1;
  498. X        if (flag[FTALKING] && flag[FSTDIN])
  499. X            s->type = STTY;
  500. X    }
  501. X    if (s->type == STTY) {
  502. X        ttyfd = fcntl(0, F_DUPFD, FDBASE);
  503. X        (void) fcntl(ttyfd, F_SETFD, FD_CLEXEC);
  504. X#if EDIT
  505. X        x_init();
  506. X#endif
  507. X    }
  508. X
  509. X    /* initialize job control */
  510. X    j_init();
  511. X
  512. X    if (!qflag)
  513. X        ignoresig(SIGQUIT);
  514. X
  515. X    l->argv = argv;
  516. X    l->argc = argc;
  517. X    l->argv[0] = name;
  518. X    resetopts();
  519. X
  520. X    if (name[0] == '-') {
  521. X        flag[FTALKING] = 1;
  522. X        (void) include("/etc/profile");
  523. X        (void) include(".profile");
  524. X    }
  525. X
  526. X    /* include $ENV */
  527. X    arg = substitute(strval(global("ENV")), DOTILDE);
  528. X    if (*arg != '\0')
  529. X        (void) include(arg);
  530. X
  531. X    if (flag[FTALKING]) {
  532. X        signal(SIGTERM, trapsig);
  533. X        ignoresig(SIGINT);
  534. X    } else
  535. X        flag[FHASHALL] = 1;
  536. X
  537. X#if JOBS            /* todo: could go before includes? */
  538. X    if (s->type == STTY) {
  539. X        flag[FMONITOR] = 1;
  540. X        j_change();
  541. X    }
  542. X#endif
  543. X
  544. X    argc = shell(s);
  545. X    leave(argc);
  546. X}
  547. X
  548. Xint
  549. Xinclude(name)
  550. X    register char *name;
  551. X{
  552. X    register FILE *f;
  553. X    register Source *s;
  554. X
  555. X    if (strcmp(name, "-") != 0) {
  556. X        f = fopen(name, "r");
  557. X        if (f == NULL)
  558. X            return 0;
  559. X        /* todo: the savefd doesn't get popped */
  560. X        fileno(f) = savefd(fileno(f)); /* questionable */
  561. X        setvbuf(f, (char *)NULL, _IOFBF, BUFSIZ);
  562. X    } else
  563. X        f = stdin;
  564. X    s = pushs(SFILE);
  565. X    s->u.file = f;
  566. X    s->file = name;
  567. X    /*return*/ shell(s);
  568. X    if (f != stdin)
  569. X        fclose(f);
  570. X    return 1;
  571. X}
  572. X
  573. Xint
  574. Xcommand(comm)
  575. X    register char *comm;
  576. X{
  577. X    register Source *s;
  578. X
  579. X    s = pushs(SSTRING);
  580. X    s->str = comm;
  581. X    return shell(s);
  582. X}
  583. X
  584. X/*
  585. X * run the commands from the input source, returning status.
  586. X */
  587. Xint
  588. Xshell(s)
  589. X    Source *s;        /* input source */
  590. X{
  591. X    struct op *t;
  592. X    Volatile int attempts = 13;
  593. X
  594. X    newenv(E_PARSE);
  595. X    e.interactive = 1;
  596. X    exstat = 0;
  597. X    if (setjmp(e.jbuf)) {
  598. X        /*shellf("<unwind>");*/
  599. X        if (trap)    /* pending SIGINT */
  600. X            shellf("\n");
  601. X        sigtraps[SIGINT].set = 0;
  602. X    }
  603. X
  604. X    while (1) {
  605. X        if (trap)
  606. X            runtraps();
  607. X        if (flag[FTALKING])
  608. X            signal(SIGINT, trapsig);
  609. X
  610. X        if (s->next == NULL)
  611. X            s->echo = flag[FVERBOSE];
  612. X
  613. X        j_notify();
  614. X
  615. X        if (s->type == STTY)
  616. X            prompt = substitute(strval(global("PS1")), 0);
  617. X
  618. X        t = compile(s);
  619. X        if (t != NULL && t->type == TEOF)
  620. X            if (s->type == STTY && flag[FIGNEOF] && --attempts > 0)
  621. X                shellf("Use `exit'\n");
  622. X            else
  623. X                break;
  624. X        flushshf(2);    /* flush -v output */
  625. X
  626. X        if (!flag[FNOEXEC] || s->type == STTY)
  627. X            execute(t, 0);
  628. X
  629. X        reclaim();
  630. X    }
  631. X  Error:
  632. X    quitenv();
  633. X    return exstat;
  634. X}
  635. X
  636. Xvoid
  637. Xleave(rv)
  638. X    int rv;
  639. X{
  640. X    if (e.type == E_TCOM && e.oenv != NULL)    /* exec'd command */
  641. X        unwind();
  642. X    runtrap(&sigtraps[0]);
  643. X    j_exit();
  644. X    exit(rv);
  645. X    /* NOTREACHED */
  646. X}
  647. X
  648. Xerror()
  649. X{
  650. X    if (flag[FERREXIT] || !flag[FTALKING])
  651. X        leave(1);
  652. X    unwind();
  653. X}
  654. X
  655. X/* return to closest error handler or shell(), exit if none found */
  656. Xunwind()
  657. X{
  658. X    while (1)
  659. X        switch (e.type) {
  660. X          case E_NONE:
  661. X            leave(1);
  662. X            /* NOTREACHED */
  663. X          case E_PARSE:
  664. X            longjmp(e.jbuf, 1);
  665. X            /* NOTREACHED */
  666. X          case E_ERRH:
  667. X            longjmp(e.jbuf, 1);
  668. X            /* NOTREACHED */
  669. X          default:
  670. X            quitenv();
  671. X            break;
  672. X        }
  673. X}
  674. X
  675. Xnewenv(type)
  676. X{
  677. X    register struct env *ep;
  678. X
  679. X    ep = (struct env *) alloc(sizeof(*ep), ATEMP);
  680. X    *ep = e;
  681. X    ainit(&e.area);
  682. X    e.type = type;
  683. X    e.oenv = ep;
  684. X    e.savefd = NULL;
  685. X    e.temps = NULL;
  686. X}
  687. X
  688. Xquitenv()
  689. X{
  690. X    register struct env *ep;
  691. X    register int fd;
  692. X
  693. X    if ((ep = e.oenv) == NULL)
  694. X        exit(exstat);    /* exit child */
  695. X    if (e.loc != ep->loc)
  696. X        popblock();
  697. X    if (e.savefd != NULL)
  698. X        for (fd = 0; fd < NUFILE; fd++)
  699. X            restfd(fd, e.savefd[fd]);
  700. X    reclaim();
  701. X    e = *ep;
  702. X}
  703. X
  704. X/* remove temp files and free ATEMP Area */
  705. Xstatic void
  706. Xreclaim()
  707. X{
  708. X    register struct temp *tp;
  709. X
  710. X    for (tp = e.temps; tp != NULL; tp = tp->next)
  711. X        remove(tp->name);
  712. X    e.temps = NULL;
  713. X    afreeall(&e.area);
  714. X}
  715. X
  716. Xvoid
  717. Xaerror(ap, msg)
  718. X    Area *ap;
  719. X    Const char *msg;
  720. X{
  721. X    errorf("alloc internal error: %s\n", msg);
  722. X}
  723. X
  724. SHAR_EOF
  725. true || echo 'restore of src/main.c failed'
  726. fi
  727. # ============= src/misc.c ==============
  728. if test -f 'src/misc.c' -a X"$1" != X"-c"; then
  729.     echo 'x - skipping src/misc.c (File already exists)'
  730. else
  731. echo 'x - extracting src/misc.c (Text)'
  732. sed 's/^X//' << 'SHAR_EOF' > 'src/misc.c' &&
  733. X/*
  734. X * Miscellaneous functions
  735. X */
  736. X
  737. Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/misc.c,v 3.1 88/11/03 09:17:14 egisin Exp $";
  738. X
  739. X#include <stddef.h>
  740. X#include <limits.h>
  741. X#include <string.h>
  742. X#include <signal.h>
  743. X#include <errno.h>
  744. X#include <setjmp.h>
  745. X#include "sh.h"
  746. X#include "expand.h"
  747. X
  748. Xchar ctypes [UCHAR_MAX];    /* type bits for unsigned char */
  749. X
  750. X/*
  751. X * Fast character classes
  752. X */
  753. Xvoid
  754. Xsetctypes(s, t)
  755. X    register Const char *s;
  756. X    register int t;
  757. X{
  758. X    register int i;
  759. X
  760. X    if ((t&C_IFS)) {
  761. X        for (i = 0; i < UCHAR_MAX; i++)
  762. X            ctypes[i] &=~ C_IFS;
  763. X        ctypes[0] |= C_IFS; /* include \0 in C_IFS */
  764. X    }
  765. X    ctypes[(unsigned char) *s++] |= t;    /* allow leading \0 in string */
  766. X    while (*s != 0)
  767. X        ctypes[(unsigned char) *s++] |= t;
  768. X}
  769. X
  770. Xvoid
  771. Xinitctypes()
  772. X{
  773. X    register int c;
  774. X
  775. X    for (c = 'a'; c <= 'z'; c++)
  776. X        ctypes[c] |= C_ALPHA;
  777. X    for (c = 'A'; c <= 'Z'; c++)
  778. X        ctypes[c] |= C_ALPHA;
  779. X    ctypes['_'] |= C_ALPHA;
  780. X    setctypes("0123456789", C_DIGIT);
  781. X    setctypes("\0 \t\n|&;<>()", C_LEX1);
  782. X    setctypes("*@#!$-?", C_VAR1);
  783. X    setctypes("=-+?#%", C_SUBOP);
  784. X}
  785. X
  786. X/* convert unsigned long to base N string */
  787. X
  788. Xchar *
  789. Xulton(n, base)
  790. X    register unsigned long n;
  791. X    int base;
  792. X{
  793. X    register char *p;
  794. X    static char buf [20];
  795. X
  796. X    p = &buf[sizeof(buf)];
  797. X    *--p = '\0';
  798. X    do {
  799. X        *--p = "0123456789ABCDEF"[n%base];
  800. X        n /= base;
  801. X    } while (n != 0);
  802. X    return p;
  803. X}
  804. X
  805. Xchar *
  806. Xstrsave(s, ap)
  807. X    register char *s;
  808. X    Area *ap;
  809. X{
  810. X    return strcpy((char*) alloc((size_t)strlen(s)+1, ap), s);
  811. X}
  812. X
  813. Xstatic struct option {
  814. X    char *name;
  815. X    int flag;
  816. X} options[] = {
  817. X    {"allexport",    FEXPORT},
  818. X    {"bgnice",    FBGNICE},
  819. X#if EDIT
  820. X    {"emacs",    FEMACS},
  821. X#endif
  822. X    {"errexit",    FERREXIT},
  823. X    {"hashall",    FHASHALL},
  824. X    {"ignoreeof",    FIGNEOF},
  825. X    {"interactive",    FTALKING},
  826. X    {"keyword",    FKEYWORD},
  827. X    {"markdirs",    FMARKDIRS},
  828. X    {"monitor",    FMONITOR},
  829. X    {"noexec",    FNOEXEC},
  830. X    {"noglob",    FNOGLOB},
  831. X    {"nounset",    FNOUNSET},
  832. X    {"privileged",    FPRIVILEGED},
  833. X    {"stdin",    FSTDIN},
  834. X    {"trackall",    FHASHALL},
  835. X    {"verbose",    FVERBOSE},
  836. X    {"xtrace",    FXTRACE},
  837. X    {NULL,        0}
  838. X};    
  839. X
  840. X/*
  841. X * translate -o option into F* constant
  842. X */
  843. Xint
  844. Xoption(n)
  845. X    Const char *n;
  846. X{
  847. X    register struct option *op;
  848. X
  849. X    for (op = options; op->name != NULL; op++)
  850. X        if (strcmp(op->name, n) == 0)
  851. X            return op->flag;
  852. X    return 0;
  853. X}
  854. X
  855. Xchar *
  856. Xgetoptions()
  857. X{
  858. X    register int c;
  859. X    char m [26+1];
  860. X    register char *cp = m;
  861. X
  862. X    for (c = 'a'; c <= 'z'; c++)
  863. X        if (flag[FLAG(c)])
  864. X            *cp++ = (char) c;
  865. X    *cp = 0;
  866. X    return strsave(m, ATEMP);
  867. X}
  868. X
  869. Xvoid
  870. Xprintoptions()
  871. X{
  872. X    register struct option *op;
  873. X
  874. X    for (op = options; op->name != NULL; op++)
  875. X        if (flag[op->flag])
  876. X            shellf("%s ", op->name);
  877. X    shellf("\n");
  878. X}
  879. X    
  880. X/* atoi with error detection */
  881. X
  882. Xgetn(as)
  883. X    char *as;
  884. X{
  885. X    register char *s;
  886. X    register int n;
  887. X
  888. X    s = as;
  889. X    if (*s == '-')
  890. X        s++;
  891. X    for (n = 0; digit(*s); s++)
  892. X        n = (n*10) + (*s-'0');
  893. X    if (*s)
  894. X        errorf("%s: bad number\n", as);
  895. X    return (*as == '-') ? -n : n;
  896. X}
  897. X
  898. X/*
  899. X * stripped down strerror for kill and exec
  900. X */
  901. Xchar *
  902. Xstrerror(i)
  903. X    int i;
  904. X{
  905. X    switch (i) {
  906. X      case EINVAL:
  907. X        return "Invalid argument";
  908. X      case EACCES:
  909. X        return "Permission denied";
  910. X      case ESRCH:
  911. X        return "No such process";
  912. X      case EPERM:
  913. X        return "Not owner";
  914. X      case ENOENT:
  915. X        return "No such file or directory";
  916. X      case ENOTDIR:
  917. X        return "Not a directory";
  918. X      case ENOEXEC:
  919. X        return "Exec format error";
  920. X      case ENOMEM:
  921. X        return "Not enough memory";
  922. X      case E2BIG:
  923. X        return "Argument list too long";
  924. X      default:
  925. X        return "Unknown system error";
  926. X    }
  927. X}
  928. X
  929. Xxpexpand(xp)
  930. X    register XPtrV *xp;
  931. X{
  932. X    int n = XPsize(*xp);
  933. X    Void **vp;
  934. X    register Void **dvp, **svp;
  935. X
  936. X    vp = alloc(sizeofN(Void*, n*2), ATEMP);
  937. X    for (svp = xp->beg, dvp = vp; svp < xp->cur; )
  938. X        *dvp++ = *svp++;
  939. X    afree((Void*) xp->beg, ATEMP);
  940. X    xp->beg = vp;
  941. X    xp->cur = vp + n;
  942. X    xp->end = vp + n*2;
  943. X}
  944. X
  945. X/* -------- gmatch.c -------- */
  946. X
  947. X/*
  948. X * int gmatch(string, pattern)
  949. X * char *string, *pattern;
  950. X *
  951. X * Match a pattern as in sh(1).
  952. X * pattern character are prefixed with MAGIC by expand.
  953. X */
  954. X
  955. X#define    NOT    '!'    /* might use ^ */
  956. X
  957. Xstatic    char    *cclass ARGS((char *, int c));
  958. X
  959. Xint
  960. Xgmatch(s, p)
  961. X    register char *s, *p;
  962. X{
  963. X    register int sc, pc;
  964. X
  965. X    if (s == NULL || p == NULL)
  966. X        return 0;
  967. X    while ((pc = *p++) != 0) {
  968. X        sc = *s++;
  969. X        if (pc ==  MAGIC)
  970. X            switch (*p++) {
  971. X              case '[':
  972. X                if ((p = cclass(p, sc)) == NULL)
  973. X                    return (0);
  974. X                break;
  975. X
  976. X              case '?':
  977. X                if (sc == 0)
  978. X                    return (0);
  979. X                break;
  980. X
  981. X              case '*':
  982. X                s--;
  983. X                do {
  984. X                    if (*p == '\0' || gmatch(s, p))
  985. X                        return (1);
  986. X                } while (*s++ != '\0');
  987. X                return (0);
  988. X
  989. X            }
  990. X        else
  991. X            if (sc != pc)
  992. X                return 0;
  993. X    }
  994. X    return (*s == 0);
  995. X}
  996. X
  997. Xstatic char *
  998. Xcclass(p, sub)
  999. X    register char *p;
  1000. X    register int sub;
  1001. X{
  1002. X    register int c, d, not, found = 0;
  1003. X
  1004. X    if ((not = *p == NOT))
  1005. X        p++;
  1006. X    do {
  1007. X        if (*p == '\0')
  1008. X            return NULL;
  1009. X        c = *p;
  1010. X        if (p[1] == '-' && p[2] != ']') {
  1011. X            d = p[2];
  1012. X            p++;
  1013. X        } else
  1014. X            d = c;
  1015. X        if (c == sub || c <= sub && sub <= d)
  1016. X            found = 1;
  1017. X    } while (*++p != ']');
  1018. X
  1019. X    return (found != not) ? p+1 : NULL;
  1020. X}
  1021. X
  1022. X/* -------- qsort.c -------- */
  1023. X
  1024. X/*
  1025. X * quick sort of array of generic pointers to objects.
  1026. X */
  1027. X
  1028. Xvoid
  1029. Xqsortp(base, n, f)
  1030. X    Void **base;        /* base address */
  1031. X    size_t n;        /* elements */
  1032. X    int (*f)();        /* compare function */
  1033. X{
  1034. X    qsort1(base, base + n, f);
  1035. X}
  1036. X
  1037. X#define    swap2(a, b)    {\
  1038. X    register Void *t; t = *(a); *(a) = *(b); *(b) = t;\
  1039. X}
  1040. X#define    swap3(a, b, c)    {\
  1041. X    register Void *t; t = *(a); *(a) = *(c); *(c) = *(b); *(b) = t;\
  1042. X}
  1043. X
  1044. Xqsort1(base, lim, f)
  1045. X    Void **base, **lim;
  1046. X    int (*f)();
  1047. X{
  1048. X    register Void **i, **j;
  1049. X    register Void **lptr, **hptr;
  1050. X    size_t n;
  1051. X    int c;
  1052. X
  1053. X  top:
  1054. X    n = (lim - base) / 2;
  1055. X    if (n == 0)
  1056. X        return;
  1057. X    hptr = lptr = base+n;
  1058. X    i = base;
  1059. X    j = lim - 1;
  1060. X
  1061. X    for (;;) {
  1062. X        if (i < lptr) {
  1063. X            if ((c = (*f)(*i, *lptr)) == 0) {
  1064. X                lptr --;
  1065. X                swap2(i, lptr);
  1066. X                continue;
  1067. X            }
  1068. X            if (c < 0) {
  1069. X                i += 1;
  1070. X                continue;
  1071. X            }
  1072. X        }
  1073. X
  1074. X      begin:
  1075. X        if (j > hptr) {
  1076. X            if ((c = (*f)(*hptr, *j)) == 0) {
  1077. X                hptr ++;
  1078. X                swap2(hptr, j);
  1079. X                goto begin;
  1080. X            }
  1081. X            if (c > 0) {
  1082. X                if (i == lptr) {
  1083. X                    hptr ++;
  1084. X                    swap3(i, hptr, j);
  1085. X                    i = lptr += 1;
  1086. X                    goto begin;
  1087. X                }
  1088. X                swap2(i, j);
  1089. X                j -= 1;
  1090. X                i += 1;
  1091. X                continue;
  1092. X            }
  1093. X            j -= 1;
  1094. X            goto begin;
  1095. X        }
  1096. X
  1097. X        if (i == lptr) {
  1098. X            if (lptr-base >= lim-hptr) {
  1099. X                qsort1(hptr+1, lim, f);
  1100. X                lim = lptr;
  1101. X            } else {
  1102. X                qsort1(base, lptr, f);
  1103. X                base = hptr+1;
  1104. X            }
  1105. X            goto top;
  1106. X        }
  1107. X
  1108. X        lptr -= 1;
  1109. X        swap3(j, lptr, i);
  1110. X        j = hptr -= 1;
  1111. X    }
  1112. X}
  1113. X
  1114. Xint
  1115. Xxstrcmp(p1, p2)
  1116. X    Void *p1, *p2;
  1117. X{
  1118. X    return (strcmp((char *)p1, (char *)p2));
  1119. X}
  1120. X
  1121. SHAR_EOF
  1122. true || echo 'restore of src/misc.c failed'
  1123. fi
  1124. # ============= src/trap.c ==============
  1125. if test -f 'src/trap.c' -a X"$1" != X"-c"; then
  1126.     echo 'x - skipping src/trap.c (File already exists)'
  1127. else
  1128. echo 'x - extracting src/trap.c (Text)'
  1129. sed 's/^X//' << 'SHAR_EOF' > 'src/trap.c' &&
  1130. X/*
  1131. X * signal handling
  1132. X */
  1133. X
  1134. Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/trap.c,v 3.1 88/11/03 09:18:00 egisin Exp $";
  1135. X
  1136. X#include <stddef.h>
  1137. X#include <string.h>
  1138. X#include <errno.h>
  1139. X#include <signal.h>
  1140. X#include <setjmp.h>
  1141. X#include "sh.h"
  1142. X
  1143. XTrap sigtraps [SIGNALS] = {
  1144. X    {0,    "EXIT", "Signal 0"}, /* todo: belongs in e.loc->exit */
  1145. X    {SIGHUP, "HUP", "Hangup"},
  1146. X    {SIGINT, "INT", "Interrupt"},
  1147. X    {SIGQUIT, "QUIT", "Quit"},
  1148. X    {SIGILL, "ILL", "Illegal instruction"},
  1149. X    {SIGTRAP, "TRAP", "Trace trap"},
  1150. X    {SIGIOT, "IOT", "Abort"},
  1151. X    {SIGEMT, "EMT", "EMT trap"},
  1152. X    {SIGFPE, "FPE", "Floating exception"},
  1153. X    {SIGKILL, "KILL", "Killed"},
  1154. X    {SIGBUS, "BUS", "Bus error"},
  1155. X    {SIGSEGV, "SEGV", "Memory fault"},
  1156. X    {SIGSYS, "SYS", "Bad system call"},
  1157. X    {SIGPIPE, "PIPE", "Broken pipe"},
  1158. X    {SIGALRM, "ALRM", "Alarm clock"},
  1159. X    {SIGTERM, "TERM", "Terminated"},
  1160. X#if JOBS            /* todo: need to be more portable */
  1161. X    {SIGURG, "URG", "Urgent condition"}, /* BSDism */
  1162. X    {SIGSTOP, "STOP", "Stop (signal)"},
  1163. X    {SIGTSTP, "TSTP", "Stop"},
  1164. X    {SIGCONT, "CONT", "Continue"},
  1165. X    {SIGCHLD, "CHLD", "Waiting children"},
  1166. X    {SIGTTIN, "TTIN", "Stop (tty input)"},
  1167. X    {SIGTTOU, "TTOU", "Stop (tty output)"},
  1168. X#endif
  1169. X};
  1170. X
  1171. XTrap *
  1172. Xgettrap(name)
  1173. X    char *name;
  1174. X{
  1175. X    int i;
  1176. X    register Trap *p;
  1177. X
  1178. X    if (digit(*name)) {
  1179. X        i = getn(name);
  1180. X        return (0 <= i && i < SIGNALS) ? &sigtraps[getn(name)] : NULL;
  1181. X    }
  1182. X#if 0
  1183. X    if (strcmp("ERR", name) == 0)
  1184. X        return &e.loc->err;
  1185. X    if (strcmp("EXIT", name) == 0)
  1186. X        return &e.loc->exit;
  1187. X#endif
  1188. X    for (p = sigtraps, i = SIGNALS; --i >= 0; p++)
  1189. X        if (strcmp(p->name, name) == 0)
  1190. X            return p;
  1191. X    return NULL;
  1192. X}
  1193. X
  1194. X/*
  1195. X * trap signal handler
  1196. X */
  1197. Xvoid
  1198. Xtrapsig(i)
  1199. X    int i;
  1200. X{
  1201. X    trap = sigtraps[i].set = 1;
  1202. X    if (i == SIGINT && e.type == E_PARSE)
  1203. X        /* dangerous but necessary to deal with BSD silly signals */
  1204. X        longjmp(e.jbuf, 1);
  1205. X    (void) signal(i, trapsig); /* todo: use sigact */
  1206. X}
  1207. X
  1208. X/*
  1209. X * run any pending traps
  1210. X */
  1211. Xruntraps()
  1212. X{
  1213. X    int i;
  1214. X    register Trap *p;
  1215. X
  1216. X    for (p = sigtraps, i = SIGNALS; --i >= 0; p++)
  1217. X        if (p->set)
  1218. X            runtrap(p);
  1219. X    trap = 0;
  1220. X}
  1221. X
  1222. Xruntrap(p)
  1223. X    Trap *p;
  1224. X{
  1225. X    char *trapstr;
  1226. X
  1227. X    p->set = 0;
  1228. X    if ((trapstr = p->trap) == NULL)
  1229. X        if (p->signal == SIGINT)
  1230. X            unwind();    /* return to shell() */
  1231. X        else
  1232. X            return;
  1233. X    if (p->signal == 0)    /* ??? */
  1234. X        p->trap = 0;
  1235. X    command(trapstr);
  1236. X}
  1237. X 
  1238. X/* restore signals for children */
  1239. Xcleartraps()
  1240. X{
  1241. X    int i;
  1242. X    register Trap *p;
  1243. X
  1244. X    for (i = SIGNALS, p = sigtraps; --i >= 0; p++) {
  1245. X        p->set = 0;
  1246. X        if (p->ourtrap && signal(p->signal, SIG_IGN) != SIG_IGN)
  1247. X            (void) signal(p->signal, SIG_DFL);
  1248. X    }
  1249. X}
  1250. X
  1251. Xignoresig(i)
  1252. X    int i;
  1253. X{
  1254. X    if (signal(i, SIG_IGN) != SIG_IGN)
  1255. X        sigtraps[i].sig_dfl = 1;
  1256. X}
  1257. X
  1258. Xrestoresigs()
  1259. X{
  1260. X    int i;
  1261. X    register Trap *p;
  1262. X
  1263. X    for (p = sigtraps, i = SIGNALS; --i >= 0; p++)
  1264. X        if (p->sig_dfl) {
  1265. X            p->sig_dfl = 0;
  1266. X            (void) signal(p->signal, SIG_DFL);
  1267. X        }
  1268. X}
  1269. X
  1270. SHAR_EOF
  1271. true || echo 'restore of src/trap.c failed'
  1272. fi
  1273. # ============= src/alloc.c ==============
  1274. if test -f 'src/alloc.c' -a X"$1" != X"-c"; then
  1275.     echo 'x - skipping src/alloc.c (File already exists)'
  1276. else
  1277. echo 'x - extracting src/alloc.c (Text)'
  1278. sed 's/^X//' << 'SHAR_EOF' > 'src/alloc.c' &&
  1279. X/*
  1280. X * area-based allocation built on malloc/free
  1281. X */
  1282. X
  1283. Xstatic char *RCSid = "$Header";
  1284. X
  1285. X#include <stddef.h>
  1286. X#include <stdlib.h>
  1287. X#include <setjmp.h>
  1288. X#include "sh.h"
  1289. X
  1290. X#define    ICELLS    100        /* number of Cells in small Block */
  1291. X
  1292. Xtypedef union Cell Cell;
  1293. Xtypedef struct Block Block;
  1294. X
  1295. X/*
  1296. X * The Cells in a Block are organized as a set of objects.
  1297. X * Each object (pointed to by dp) begins with a size in (dp-1)->size,
  1298. X * followed with "size" data Cells.  Free objects are
  1299. X * linked together via dp->next.
  1300. X */
  1301. X
  1302. Xunion Cell {
  1303. X    size_t    size;
  1304. X    Cell   *next;
  1305. X    struct {int _;} junk;    /* alignment */
  1306. X};
  1307. X
  1308. Xstruct Block {
  1309. X    Block  *next;        /* list of Blocks in Area */
  1310. X    Cell   *free;        /* object free list */
  1311. X    Cell   *last;        /* &b.cell[size] */
  1312. X    Cell    cell [1];    /* [size] Cells for allocation */
  1313. X};
  1314. X
  1315. XBlock aempty = {&aempty, aempty.cell, aempty.cell};
  1316. X
  1317. X/* create empty Area */
  1318. XArea *
  1319. Xainit(ap)
  1320. X    register Area *ap;
  1321. X{
  1322. X    ap->free = &aempty;
  1323. X    return ap;
  1324. X}
  1325. X
  1326. X/* free all object in Area */
  1327. Xvoid
  1328. Xafreeall(ap)
  1329. X    register Area *ap;
  1330. X{
  1331. X    register Block *bp;
  1332. X
  1333. X    if (ap->free == NULL || ap->free == &aempty)
  1334. X        return;
  1335. X    for (bp = ap->free; ; bp = bp->next) {
  1336. X        free((Void*)bp);
  1337. X        if (bp->next == ap->free)
  1338. X            break;
  1339. X    }
  1340. X    ap->free = &aempty;
  1341. X}
  1342. X
  1343. X/* allocate object from Area */
  1344. XVoid *
  1345. Xalloc(size, ap)
  1346. X    size_t size;
  1347. X    register Area *ap;
  1348. X{
  1349. X    int cells, split;
  1350. X    register Block *bp;
  1351. X    register Cell *dp, *fp, *fpp;
  1352. X
  1353. X    if (size <= 0) {
  1354. X        aerror(ap, "allocate bad size");
  1355. X        return NULL;
  1356. X    }
  1357. X    cells = (unsigned)(size - 1) / sizeof(Cell) + 1;
  1358. X
  1359. X    /* find Cell large enough */
  1360. X    for (bp = ap->free; ; bp = bp->next) {
  1361. X        for (fpp = NULL, fp = bp->free;
  1362. X             fp != bp->last; fpp = fp, fp = fpp->next)
  1363. X            if ((fp-1)->size >= cells)
  1364. X                goto Found;
  1365. X
  1366. X        /* wrapped around Block list, create new Block */
  1367. X        if (bp == ap->free) {
  1368. X            bp = malloc(offsetof(Block, cell[ICELLS + cells]));
  1369. X            if (bp == NULL) {
  1370. X                aerror(ap, "cannot allocate");
  1371. X                return NULL;
  1372. X            }
  1373. X            if (ap->free == &aempty)
  1374. X                bp->next = bp;
  1375. X            else {
  1376. X                bp->next = ap->free->next;
  1377. X                ap->free->next = bp;
  1378. X            }
  1379. X            bp->last = bp->cell + ICELLS + cells;
  1380. X            fp = bp->free = bp->cell + 1; /* initial free list */
  1381. X            (fp-1)->size = ICELLS + cells - 1;
  1382. X            fp->next = bp->last;
  1383. X            fpp = NULL;
  1384. X            break;
  1385. X        }
  1386. X    }
  1387. X  Found:
  1388. X    ap->free = bp;
  1389. X    dp = fp;        /* allocated object */
  1390. X    split = (dp-1)->size - cells;
  1391. X    if (split < 0)
  1392. X        aerror(ap, "allocated object too small");
  1393. X    if (--split <= 0) {    /* allocate all */
  1394. X        fp = fp->next;
  1395. X    } else {        /* allocate head, free tail */
  1396. X        (fp-1)->size = cells;
  1397. X        fp += cells + 1;
  1398. X        (fp-1)->size = split;
  1399. X        fp->next = dp->next;
  1400. X    }
  1401. X    if (fpp == NULL)
  1402. X        bp->free = fp;
  1403. X    else
  1404. X        fpp->next = fp;
  1405. X    return (Void*) dp;
  1406. X}
  1407. X
  1408. X/* change size of object */
  1409. X/* todo: allow expansion */
  1410. XVoid *
  1411. Xaresize(ptr, size, ap)
  1412. X    register Void *ptr;
  1413. X    size_t size;
  1414. X    register Area *ap;
  1415. X{
  1416. X    int cells, split;
  1417. X    register Cell *dp = (Cell*)ptr;
  1418. X
  1419. X    if (size <= 0) {
  1420. X        aerror(ap, "allocate bad size");
  1421. X        return NULL;
  1422. X    }
  1423. X    cells = (unsigned)(size - 1) / sizeof(Cell) + 1;
  1424. X
  1425. X    split = (dp-1)->size - cells;
  1426. X    if (split < 0)
  1427. X        aerror(ap, "cannot resize larger");
  1428. X    if (--split <= 0)    /* cannot split */
  1429. X        ;
  1430. X    else {            /* shrink head, free tail */
  1431. X        (dp-1)->size = cells;
  1432. X        dp += cells + 1;
  1433. X        (dp-1)->size = split;
  1434. X        afree((Void*)dp, ap);
  1435. X    }
  1436. X
  1437. X    return (Void*) ptr;
  1438. X}
  1439. X
  1440. Xvoid
  1441. Xafree(ptr, ap)
  1442. X    Void *ptr;
  1443. X    register Area *ap;
  1444. X{
  1445. X    register Block *bp;
  1446. X    register Cell *fp, *fpp;
  1447. X    register Cell *dp = (Cell*)ptr;
  1448. X
  1449. X    /* find Block containing Cell */
  1450. X    for (bp = ap->free; ; bp = bp->next) {
  1451. X        if (bp->cell <= dp && dp < bp->last)
  1452. X            break;
  1453. X        if (bp->next == ap->free) {
  1454. X            aerror(ap, "freeing with invalid area");
  1455. X            return;
  1456. X        }
  1457. X    }
  1458. X
  1459. X    /* find position in free list */
  1460. X    for (fpp = NULL, fp = bp->free; fp < dp; fpp = fp, fp = fpp->next)
  1461. X        ;
  1462. X
  1463. X    if (fp == dp) {
  1464. X        aerror(ap, "freeing free object");
  1465. X        return;
  1466. X    }
  1467. X
  1468. X    /* join object with next */
  1469. X    if (dp + (dp-1)->size == fp-1) { /* adjacent */
  1470. X        (dp-1)->size += (fp-1)->size + 1;
  1471. X        dp->next = fp->next;
  1472. X    } else            /* non-adjacent */
  1473. X        dp->next = fp;
  1474. X
  1475. X    /* join previous with object */
  1476. X    if (fpp == NULL)
  1477. X        bp->free = dp;
  1478. X    else if (fpp + (fpp-1)->size == dp-1) { /* adjacent */
  1479. X        (fpp-1)->size += (dp-1)->size + 1;
  1480. X        fpp->next = dp->next;
  1481. X    } else            /* non-adjacent */
  1482. X        fpp->next = dp;
  1483. X}
  1484. X
  1485. X
  1486. X#if TEST_ALLOC
  1487. X
  1488. XArea a;
  1489. X
  1490. Xmain(int argc, char **argv) {
  1491. X    int i;
  1492. X    char *p [9];
  1493. X
  1494. X    ainit(&a);
  1495. X    for (i = 0; i < 9; i++) {
  1496. X        p[i] = alloc(124, &a);
  1497. X        printf("alloc: %x\n", p[i]);
  1498. X    }
  1499. X    for (i = 1; i < argc; i++)
  1500. X        afree(p[atoi(argv[i])], &a);
  1501. X    afreeall(&a);
  1502. X    return 0;
  1503. X}
  1504. X
  1505. Xvoid aerror(Area *ap, const char *msg) {
  1506. X    abort();
  1507. X}
  1508. X
  1509. X#endif
  1510. X
  1511. SHAR_EOF
  1512. true || echo 'restore of src/alloc.c failed'
  1513. fi
  1514. # ============= src/io.c ==============
  1515. if test -f 'src/io.c' -a X"$1" != X"-c"; then
  1516.     echo 'x - skipping src/io.c (File already exists)'
  1517. else
  1518. echo 'x - extracting src/io.c (Text)'
  1519. sed 's/^X//' << 'SHAR_EOF' > 'src/io.c' &&
  1520. X/*
  1521. X * shell buffered IO and formatted output
  1522. X */
  1523. X
  1524. Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/io.c,v 3.3 88/11/25 10:55:52 egisin Exp $";
  1525. X
  1526. X#include <stddef.h>
  1527. X#include <stdlib.h>
  1528. X#include <stdio.h>
  1529. X#include <errno.h>
  1530. X#include <unistd.h>
  1531. X#include <fcntl.h>
  1532. X#include <signal.h>
  1533. X#include <setjmp.h>
  1534. X#if __STDC__
  1535. X#include <stdarg.h>
  1536. X#else
  1537. X#include <varargs.h>
  1538. X#endif
  1539. X#include "sh.h"
  1540. X
  1541. X#if 0
  1542. X/* fputc with ^ escaping */
  1543. Xstatic void
  1544. Xfzotc(c, f)
  1545. X    register int c;
  1546. X    register FILE *f;
  1547. X{
  1548. X    if ((c&0x60) == 0) {        /* C0|C1 */
  1549. X        putc((c&0x80) ? '$' : '^', f);
  1550. X        putc((c&0x7F|0x40), f);
  1551. X    } else if ((c&0x7F) == 0x7F) {    /* DEL */
  1552. X        putc((c&0x80) ? '$' : '^', f);
  1553. X        putc('?', f);
  1554. X    } else
  1555. X        putc(c, f);
  1556. X}
  1557. X#endif
  1558. X
  1559. X/*
  1560. X * formatted output functions
  1561. X */
  1562. X
  1563. X/* shellf(...); error() */
  1564. Xint
  1565. X#if __STDC__
  1566. Xerrorf(Const char *fmt, ...) {
  1567. X#else
  1568. Xerrorf(va_alist) va_dcl
  1569. X{
  1570. X    char *fmt;
  1571. X#endif
  1572. X    va_list va;
  1573. X
  1574. X#if __STDC__
  1575. X    va_start(va, fmt);
  1576. X#else
  1577. X    va_start(va);
  1578. X    fmt = va_arg(va, char *);
  1579. X#endif
  1580. X    vfprintf(shlout, fmt, va);
  1581. X    va_end(va);
  1582. X    /*fflush(shlout);*/
  1583. X    error();
  1584. X}
  1585. X
  1586. X/* printf to shlout (stderr) */
  1587. Xint
  1588. X#if __STDC__
  1589. Xshellf(Const char *fmt, ...) {
  1590. X#else
  1591. Xshellf(va_alist) va_dcl
  1592. X{
  1593. X    char *fmt;
  1594. X#endif
  1595. X    va_list va;
  1596. X
  1597. X#if __STDC__
  1598. X    va_start(va, fmt);
  1599. X#else
  1600. X    va_start(va);
  1601. X    fmt = va_arg(va, char *);
  1602. X#endif
  1603. X    vfprintf(shlout, fmt, va);
  1604. X    va_end(va);
  1605. X    return 0;
  1606. X}
  1607. X
  1608. X/*
  1609. X * We have a stdio stream for any open shell file descriptors (0-9)
  1610. X */
  1611. XFILE *    shf [NUFILE];        /* map shell fd to FILE * */
  1612. X
  1613. X/* open stream for shell fd */
  1614. Xvoid
  1615. Xfopenshf(fd)
  1616. X    int fd;
  1617. X{
  1618. X    if (shf[fd] != NULL)
  1619. X        return;
  1620. X    if (fd <= 2)
  1621. X        _iob[fd]._flag = 0; /* re-use stdin, stdout, stderr */
  1622. X    shf[fd] = fdopen(fd, "r+");
  1623. X    if (shf[fd] == NULL)
  1624. X        return;
  1625. X    setvbuf(shf[fd], (char*)NULL, _IOFBF, (size_t)BUFSIZ);
  1626. X}
  1627. X
  1628. X/* flush stream assoc with fd */
  1629. X/* this must invalidate input and output buffers */
  1630. Xvoid
  1631. Xflushshf(fd)
  1632. X    int fd;
  1633. X{
  1634. X    if (shf[fd] != NULL) {
  1635. X        fseek(shf[fd], 0L, 1); /* V7 derived */
  1636. X        fflush(shf[fd]);    /* standard C */
  1637. X    }
  1638. X}
  1639. X
  1640. X/*
  1641. X * move fd from user space (0<=fd<10) to shell space (fd>=10)
  1642. X */
  1643. Xint
  1644. Xsavefd(fd)
  1645. X    int fd;
  1646. X{
  1647. X    int nfd;
  1648. X
  1649. X    if (fd < FDBASE) {
  1650. X        flushshf(fd);
  1651. X        nfd = fcntl(fd, F_DUPFD, FDBASE);
  1652. X        if (nfd < 0)
  1653. X            if (errno == EBADF)
  1654. X                return -1;
  1655. X            else
  1656. X                errorf("too many files open in shell\n");
  1657. X        (void) fcntl(nfd, F_SETFD, FD_CLEXEC);
  1658. X        close(fd);
  1659. X    } else
  1660. X        nfd = fd;
  1661. X    return nfd;
  1662. X}
  1663. X
  1664. Xvoid
  1665. Xrestfd(fd, ofd)
  1666. X    int fd, ofd;
  1667. X{
  1668. X    if (ofd == 0)        /* not saved (e.savefd) */
  1669. X        return;
  1670. X    flushshf(fd);
  1671. X    close(fd);
  1672. X    if (ofd < 0)        /* original fd closed */
  1673. X        return;
  1674. X    (void) fcntl(ofd, F_DUPFD, fd);
  1675. X    close(ofd);
  1676. X}
  1677. X
  1678. Xvoid
  1679. Xopenpipe(pv)
  1680. X    register int *pv;
  1681. X{
  1682. X    if (pipe(pv) < 0)
  1683. X        errorf("can't create pipe - try again\n");
  1684. X    pv[0] = savefd(pv[0]);
  1685. X    pv[1] = savefd(pv[1]);
  1686. X}
  1687. X
  1688. Xvoid
  1689. Xclosepipe(pv)
  1690. X    register int *pv;
  1691. X{
  1692. X    close(pv[0]);
  1693. X    close(pv[1]);
  1694. X}
  1695. X
  1696. X/*
  1697. X * temporary files
  1698. X */
  1699. X
  1700. Xstruct temp *
  1701. Xmaketemp(ap)
  1702. X    Area *ap;
  1703. X{
  1704. X    register struct temp *tp;
  1705. X    static unsigned int inc = 0;
  1706. X    char path [PATH];
  1707. X
  1708. X    sprintf(path, "/tmp/sh%05u%02u", (unsigned)getpid(), inc++);
  1709. X    /* we could create the thing now with 600 mode */
  1710. X    tp = (struct temp *) alloc(sizeof(struct temp), ap);
  1711. X    tp->next = NULL;
  1712. X    tp->name = strsave(path, ap);
  1713. X    return tp;
  1714. X}
  1715. SHAR_EOF
  1716. true || echo 'restore of src/io.c failed'
  1717. fi
  1718. # ============= src/syn.c ==============
  1719. if test -f 'src/syn.c' -a X"$1" != X"-c"; then
  1720.     echo 'x - skipping src/syn.c (File already exists)'
  1721. else
  1722. echo 'x - extracting src/syn.c (Text)'
  1723. sed 's/^X//' << 'SHAR_EOF' > 'src/syn.c' &&
  1724. X/*
  1725. X * shell parser (C version)
  1726. X */
  1727. X
  1728. Xstatic char *RCSid = "$Header: /tmp/egisin/src/RCS/syn.c,v 3.2 88/12/17 21:18:59 egisin Exp $";
  1729. X
  1730. X#include <stddef.h>
  1731. X#include <stdio.h>
  1732. X#include <string.h>
  1733. X#include <errno.h>
  1734. X#include <setjmp.h>
  1735. X#include "sh.h"
  1736. X#include "lex.h"
  1737. X#include "tree.h"
  1738. X#include "table.h"
  1739. X#include "expand.h"
  1740. X
  1741. Xstatic    void    zzerr();
  1742. Xstatic    struct    op *block(), *newtp();
  1743. Xstatic    struct    op *pipeline(), *andor(), *command();
  1744. Xstatic    struct    op *nested(), *c_list();
  1745. Xstatic    struct    op *dogroup(), *thenpart(), *casepart(), *caselist();
  1746. Xstatic    struct    op *elsepart();
  1747. Xstatic    char  **wordlist();
  1748. Xstatic    void    musthave();
  1749. Xstatic    struct ioword *synio(), *io();
  1750. X
  1751. Xstatic    struct    op    *outtree; /* yyparse output */
  1752. X
  1753. Xstatic    int    reject;        /* token(cf) gets symbol again */
  1754. Xstatic    int    symbol;        /* yylex value */
  1755. X
  1756. X#define    REJECT    (reject = 1)
  1757. X#define    ACCEPT    (reject = 0)
  1758. X#define    token(cf) \
  1759. X    ((reject) ? (ACCEPT, symbol) : (symbol = yylex(cf)))
  1760. X#define    tpeek(cf) \
  1761. X    ((reject) ? (symbol) : (REJECT, symbol = yylex(cf)))
  1762. X
  1763. Xint
  1764. Xyyparse()
  1765. X{
  1766. X    ACCEPT;
  1767. X    yynerrs = 0;
  1768. X    if ((tpeek(KEYWORD|ALIAS)) == 0) { /* EOF */
  1769. X        outtree = newtp(TEOF);
  1770. X        return 0;
  1771. X    }
  1772. X    outtree = c_list();
  1773. X    musthave('\n', 0);
  1774. X    return (yynerrs != 0);
  1775. X}
  1776. X
  1777. Xstatic struct op *
  1778. Xpipeline(cf)
  1779. X    int cf;
  1780. X{
  1781. X    register struct op *t, *p, *tl = NULL;
  1782. X    register int c;
  1783. X
  1784. X    t = command(cf);
  1785. X    if (t != NULL) {
  1786. X        while ((c = token(0)) == '|') {
  1787. X            if ((p = command(CONTIN)) == NULL)
  1788. X                SYNTAXERR;
  1789. X            if (tl == NULL)
  1790. X                t = tl = block(TPIPE, t, p, NOWORDS);
  1791. X            else
  1792. X                tl = tl->right = block(TPIPE, tl->right, p, NOWORDS);
  1793. X            /*t = block(TPIPE, t, p, NOWORDS);*/
  1794. X        }
  1795. X        REJECT;
  1796. X    }
  1797. X    return (t);
  1798. X}
  1799. X
  1800. Xstatic struct op *
  1801. Xandor()
  1802. X{
  1803. X    register struct op *t, *p;
  1804. X    register int c;
  1805. X
  1806. X    t = pipeline(0);
  1807. X    if (t != NULL) {
  1808. X        while ((c = token(0)) == LOGAND || c == LOGOR) {
  1809. X            if ((p = pipeline(CONTIN)) == NULL)
  1810. X                SYNTAXERR;
  1811. X            t = block(c == LOGAND? TAND: TOR, t, p, NOWORDS);
  1812. X        }
  1813. X        REJECT;
  1814. X    }
  1815. X    return (t);
  1816. X}
  1817. X
  1818. Xstatic struct op *
  1819. Xc_list()
  1820. X{
  1821. X    register struct op *t, *p, *tl = NULL;
  1822. X    register int c;
  1823. X
  1824. X    t = andor();
  1825. X    if (t != NULL) {
  1826. X        while ((c = token(0)) == ';' || c == '&' ||
  1827. X               multiline && c == '\n') {
  1828. X            if (c == '&')
  1829. X                t = block(TASYNC, t, NOBLOCK, NOWORDS);
  1830. X            if ((p = andor()) == NULL)
  1831. X                return (t);
  1832. X            if (tl == NULL)
  1833. X                t = tl = block(TLIST, t, p, NOWORDS);
  1834. X            else
  1835. X                tl = tl->right = block(TLIST, tl->right, p, NOWORDS);
  1836. X        }
  1837. X        REJECT;
  1838. X    }
  1839. X    return (t);
  1840. X}
  1841. X
  1842. Xstatic struct ioword *
  1843. Xsynio(cf)
  1844. X    int cf;
  1845. X{
  1846. X    register struct ioword *iop;
  1847. X
  1848. X    if (tpeek(cf) != REDIR)
  1849. X        return NULL;
  1850. X    ACCEPT;
  1851. X    iop = yylval.iop;
  1852. X    musthave(LWORD, 0);
  1853. X    iop->name = yylval.cp;
  1854. X    if ((iop->flag&IOTYPE) == IOHERE) {
  1855. X        if (*ident != 0) /* unquoted */
  1856. X            iop->flag |= IOEVAL;
  1857. X        if (herep >= &heres[HERES])
  1858. X            errorf("too many <<'s\n");
  1859. X        *herep++ = iop;
  1860. X    }
  1861. X    return iop;
  1862. X}
  1863. X
  1864. Xstatic void
  1865. Xmusthave(c, cf)
  1866. X    int c, cf;
  1867. X{
  1868. X    if ((token(cf)) != c)
  1869. X        SYNTAXERR;
  1870. X}
  1871. X
  1872. Xstatic struct op *
  1873. Xnested(type, mark)
  1874. X    int type, mark;
  1875. X{
  1876. X    register struct op *t;
  1877. X
  1878. X    multiline++;
  1879. X    t = c_list();
  1880. X    musthave(mark, KEYWORD);
  1881. X    multiline--;
  1882. X    return (block(type, t, NOBLOCK, NOWORDS));
  1883. X}
  1884. X
  1885. Xstatic struct op *
  1886. Xcommand(cf)
  1887. X    int cf;
  1888. X{
  1889. X    register struct op *t;
  1890. X    register int c, iopn = 0;
  1891. X    struct ioword *iop, **iops;
  1892. X    XPtrV args, vars;
  1893. X
  1894. X    iops = (struct ioword **) alloc(sizeofN(struct ioword *, NUFILE+1), ATEMP);
  1895. X    XPinit(args, 16);
  1896. X    XPinit(vars, 16);
  1897. X
  1898. X    if (multiline)
  1899. X        cf = CONTIN;
  1900. X    cf |= KEYWORD|ALIAS;
  1901. X
  1902. X    while ((iop = synio(cf)) != NULL) {
  1903. X        if (iopn >= NUFILE)
  1904. X            yyerror("too many redirections");
  1905. X        iops[iopn++] = iop;
  1906. X        cf &=~ CONTIN;
  1907. X    }
  1908. X
  1909. X    switch (c = token(cf)) {
  1910. X      case 0:
  1911. X        yyerror("unexpected EOF");
  1912. X        return NULL;
  1913. X
  1914. X      default:
  1915. X        REJECT;
  1916. X        if (iopn == 0)
  1917. X            return NULL; /* empty line */
  1918. X        t = newtp(TCOM);
  1919. X        break;
  1920. X
  1921. X      case LWORD:
  1922. X        REJECT;
  1923. X        t = newtp(TCOM);
  1924. X        while (1)
  1925. X            switch (tpeek(0)) {
  1926. X              case REDIR:
  1927. X                if (iopn >= NUFILE)
  1928. X                    yyerror("too many redirections");
  1929. X                iops[iopn++] = synio(0);
  1930. X                break;
  1931. X
  1932. X              case LWORD:
  1933. X                ACCEPT;
  1934. X                if ((XPsize(args) == 0 || flag[FKEYWORD])
  1935. X                    && strchr(ident+1, '='))
  1936. X                    {XPput(vars, yylval.cp);}
  1937. X                else
  1938. X                    {XPput(args, yylval.cp);}
  1939. X                break;
  1940. X
  1941. X              case MPAREN:
  1942. X                ACCEPT;
  1943. X                if (XPsize(args) != 1)
  1944. X                    SYNTAXERR;
  1945. X                if (*ident == 0)
  1946. X                    yyerror("invalid function name\n");
  1947. X                t = newtp(TFUNCT);
  1948. X                t->str = strsave(ident, ATEMP);
  1949. X                musthave('{', CONTIN|KEYWORD);
  1950. X                t->left = nested(TBRACE, '}');
  1951. X                return t;
  1952. X
  1953. X              default:
  1954. X                goto Leave;
  1955. X            }
  1956. X      Leave:
  1957. X        break;
  1958. X
  1959. X      case '(':
  1960. X        t = nested(TPAREN, ')');
  1961. X        break;
  1962. X
  1963. X      case '{':
  1964. X        t = nested(TBRACE, '}');
  1965. X        break;
  1966. X
  1967. X      case FOR:
  1968. X        t = newtp(TFOR);
  1969. X        musthave(LWORD, 0);
  1970. X        t->str = strsave(ident, ATEMP);
  1971. X        multiline++;
  1972. X        t->vars = wordlist();
  1973. X        t->left = dogroup(0);
  1974. X        multiline--;
  1975. X        break;
  1976. X
  1977. X      case WHILE:
  1978. X      case UNTIL:
  1979. X        multiline++;
  1980. X        t = newtp((c == WHILE) ? TWHILE: TUNTIL);
  1981. X        t->left = c_list();
  1982. X        t->right = dogroup(1);
  1983. X        multiline--;
  1984. X        break;
  1985. X
  1986. X      case CASE:
  1987. X        t = newtp(TCASE);
  1988. X        musthave(LWORD, 0);
  1989. X        t->str = yylval.cp;
  1990. X        multiline++;
  1991. X        musthave(IN, KEYWORD|CONTIN);
  1992. X        t->left = caselist();
  1993. X        musthave(ESAC, KEYWORD);
  1994. X        multiline--;
  1995. X        break;
  1996. X
  1997. X      case IF:
  1998. X        multiline++;
  1999. X        t = newtp(TIF);
  2000. X        t->left = c_list();
  2001. X        t->right = thenpart();
  2002. X        musthave(FI, KEYWORD);
  2003. X        multiline--;
  2004. X        break;
  2005. X
  2006. X      case TIME:
  2007. X        t = pipeline(CONTIN);
  2008. X        t = block(TTIME, t, NOBLOCK, NOWORDS);
  2009. X        break;
  2010. X
  2011. X      case FUNCTION:
  2012. X        t = newtp(TFUNCT);
  2013. X        musthave(LWORD, 0);
  2014. X        t->str = strsave(ident, ATEMP);
  2015. X        musthave('{', CONTIN|KEYWORD);
  2016. X        t->left = nested(TBRACE, '}');
  2017. X        break;
  2018. X    }
  2019. X
  2020. X    while ((iop = synio(0)) != NULL) {
  2021. X        if (iopn >= NUFILE)
  2022. X            yyerror("too many redirections");
  2023. X        iops[iopn++] = iop;
  2024. X    }
  2025. X
  2026. X    if (iopn == 0) {
  2027. X        afree((Void*) iops, ATEMP);
  2028. X        t->ioact = NULL;
  2029. X    } else {
  2030. X        iops[iopn++] = NULL;
  2031. X        aresize((Void*) iops, sizeofN(struct ioword *, iopn), ATEMP);
  2032. X        t->ioact = iops;
  2033. X    }
  2034. X
  2035. X    if (t->type == TCOM) {
  2036. X        XPput(args, NULL);
  2037. X        t->args = (char **) XPclose(args);
  2038. X        XPput(vars, NULL);
  2039. X        t->vars = (char **) XPclose(vars);
  2040. X    } else {
  2041. X        XPfree(args);
  2042. X        XPfree(vars);
  2043. X    }
  2044. X
  2045. X    return t;
  2046. X}
  2047. X
  2048. Xstatic struct op *
  2049. Xdogroup(onlydone)
  2050. X    int onlydone;
  2051. X{
  2052. X    register int c;
  2053. X    register struct op *list;
  2054. X
  2055. X    c = token(CONTIN|KEYWORD);
  2056. X    if (c == DONE && onlydone)
  2057. X        return NULL;
  2058. X    if (c != DO)
  2059. X        SYNTAXERR;
  2060. X    list = c_list();
  2061. X    musthave(DONE, KEYWORD);
  2062. X    return list;
  2063. X}
  2064. X
  2065. Xstatic struct op *
  2066. Xthenpart()
  2067. X{
  2068. X    register int c;
  2069. X    register struct op *t;
  2070. X
  2071. X    if ((c = token(0)) != THEN) {
  2072. X        REJECT;
  2073. X        return NULL;
  2074. X    }
  2075. X    t = newtp(0);
  2076. X    t->left = c_list();
  2077. X    if (t->left == NULL)
  2078. X        SYNTAXERR;
  2079. X    t->right = elsepart();
  2080. X    return (t);
  2081. X}
  2082. X
  2083. Xstatic struct op *
  2084. Xelsepart()
  2085. X{
  2086. X    register int c;
  2087. X    register struct op *t;
  2088. X
  2089. X    switch (c = token(0)) {
  2090. X      case ELSE:
  2091. X        if ((t = c_list()) == NULL)
  2092. X            SYNTAXERR;
  2093. X        return (t);
  2094. X
  2095. X      case ELIF:
  2096. X        t = newtp(TELIF);
  2097. X        t->left = c_list();
  2098. X        t->right = thenpart();
  2099. X        return (t);
  2100. X
  2101. X      default:
  2102. X        REJECT;
  2103. X        return NULL;
  2104. X    }
  2105. X}
  2106. X
  2107. Xstatic struct op *
  2108. Xcaselist()
  2109. X{
  2110. X    register struct op *t, *tl;
  2111. X
  2112. X    t = tl = NULL;
  2113. X    while ((tpeek(CONTIN|KEYWORD)) != ESAC) {
  2114. X        struct op *tc = casepart();
  2115. X        if (tl == NULL)
  2116. X            t = tl = tc, tl->right = NULL;
  2117. X        else
  2118. X            tl->right = tc, tl = tc;
  2119. X    }
  2120. X    return (t);
  2121. X}
  2122. X
  2123. Xstatic struct op *
  2124. Xcasepart()
  2125. X{
  2126. X    register struct op *t;
  2127. X    register int c, cf;
  2128. X    XPtrV ptns;
  2129. X
  2130. X    XPinit(ptns, 16);
  2131. X    t = newtp(TPAT);
  2132. X    cf = CONTIN|KEYWORD;
  2133. X    c = token(cf);
  2134. X    if (c != '(')
  2135. X        REJECT;
  2136. X    else
  2137. X        cf = 0;
  2138. X    do {
  2139. X        musthave(LWORD, cf);
  2140. X        XPput(ptns, yylval.cp);
  2141. X        cf = 0;
  2142. X    } while ((c = token(0)) == '|');
  2143. X    REJECT;
  2144. X    XPput(ptns, NULL);
  2145. X    t->vars = (char **) XPclose(ptns);
  2146. X    musthave(')', 0);
  2147. X
  2148. X    t->left = c_list();
  2149. X    if ((tpeek(CONTIN|KEYWORD)) != ESAC)
  2150. X        musthave(BREAK, CONTIN|KEYWORD);
  2151. X    return (t);
  2152. X}
  2153. X
  2154. Xstatic char **
  2155. Xwordlist()
  2156. X{
  2157. X    register int c;
  2158. X    XPtrV args;
  2159. X
  2160. X    XPinit(args, 16);
  2161. X    if ((c = token(CONTIN|KEYWORD)) != IN) {
  2162. X        REJECT;
  2163. X        return NULL;
  2164. X    }
  2165. X    while ((c = token(0)) == LWORD)
  2166. X        XPput(args, yylval.cp);
  2167. X    if (c != '\n' && c != ';')
  2168. X        SYNTAXERR;
  2169. X    if (XPsize(args) == 0) {
  2170. X        XPfree(args);
  2171. X        return NULL;
  2172. X    } else {
  2173. X        XPput(args, NULL);
  2174. X        return (char **) XPclose(args);
  2175. X    }
  2176. X}
  2177. X
  2178. X/*
  2179. X * supporting functions
  2180. X */
  2181. X
  2182. Xstatic struct op *
  2183. Xblock(type, t1, t2, wp)
  2184. X    struct op *t1, *t2;
  2185. X    char **wp;
  2186. X{
  2187. X    register struct op *t;
  2188. X
  2189. X    t = newtp(type);
  2190. X    t->left = t1;
  2191. X    t->right = t2;
  2192. X    t->vars = wp;
  2193. X    return (t);
  2194. X}
  2195. X
  2196. XConst    struct res {
  2197. X    char    *name;
  2198. X    int    val;
  2199. X} restab[] = {
  2200. X    "for",        FOR,
  2201. X    "case",        CASE,
  2202. X    "esac",        ESAC,
  2203. X    "while",    WHILE,
  2204. X    "do",        DO,
  2205. X    "done",        DONE,
  2206. X    "if",        IF,
  2207. X    "in",        IN,
  2208. X    "then",        THEN,
  2209. X    "else",        ELSE,
  2210. X    "elif",        ELIF,
  2211. X    "until",    UNTIL,
  2212. X    "fi",        FI,
  2213. X    "function",    FUNCTION,
  2214. X    "time",        TIME,
  2215. X    "{",        '{',
  2216. X    "}",        '}',
  2217. X    0
  2218. X};
  2219. X
  2220. Xkeywords()
  2221. X{
  2222. X    register struct res Const *rp;
  2223. X    register struct tbl *p;
  2224. X
  2225. X    for (rp = restab; rp->name; rp++) {
  2226. X        p = tenter(&lexicals, rp->name, hash(rp->name));
  2227. X        p->flag |= DEFINED|ISSET;
  2228. X        p->type = CKEYWD;
  2229. X        p->val.i = rp->val;
  2230. X    }
  2231. X}
  2232. X
  2233. Xstatic struct op *
  2234. Xnewtp(type)
  2235. X    int type;
  2236. X{
  2237. X    register struct op *t;
  2238. X
  2239. X    t = (struct op *) alloc(sizeof(*t), ATEMP);
  2240. X    t->type = type;
  2241. X    t->args = t->vars = NULL;
  2242. X    t->ioact = NULL;
  2243. X    t->left = t->right = NULL;
  2244. X    t->str = NULL;
  2245. X    return (t);
  2246. X}
  2247. X
  2248. Xstatic void
  2249. Xzzerr()
  2250. X{
  2251. X    yyerror("syntax error");
  2252. X}
  2253. X
  2254. Xstruct op *
  2255. Xcompile(s)
  2256. X    Source *s;
  2257. X{
  2258. X    yynerrs = 0;
  2259. X    multiline = 0;
  2260. X    herep = heres;
  2261. X    source = s;
  2262. X    if (yyparse())
  2263. X        unwind();
  2264. X    if (s->type == STTY || s->type == SFILE)
  2265. X        s->str = null;    /* line is not preserved */
  2266. X    return outtree;
  2267. X}
  2268. X
  2269. SHAR_EOF
  2270. true || echo 'restore of src/syn.c failed'
  2271. fi
  2272. true || echo 'restore of src/lex.c failed'
  2273. echo End of part 2, continue with part 3
  2274. exit 0
  2275.