home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2323 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  68.8 KB
  1. From: pfalstad@phoenix.Princeton.EDU (Paul John Falstad)
  2. Newsgroups: alt.sources
  3. Subject: zsh - ksh/tcsh-like shell (part 4 of 8)
  4. Message-ID: <4745@idunno.Princeton.EDU>
  5. Date: 14 Dec 90 23:31:22 GMT
  6.  
  7. ---cut here---cut here---cut here---
  8. -                case 'M':
  9. -                    stradd(&bp,hostM);
  10. -                    break;
  11. -                case 'm':
  12. -                    stradd(&bp,hostm);
  13. -                    break;
  14. -                case 'S':
  15. -                    if (tgetstr("so",&bp))
  16. -                        bp--;
  17. -                    break;
  18. -                case 's':
  19. -                    if (tgetstr("se",&bp))
  20. -                        bp--;
  21. -                    break;
  22. -                case 'B':
  23. -                    if (tgetstr("md",&bp))
  24. -                        bp--;
  25. -                    break;
  26. -                case 'b':
  27. -                    if (tgetstr("me",&bp))
  28. -                        bp--;
  29. -                    break;
  30. -                case 'U':
  31. -                    if (tgetstr("us",&bp))
  32. -                        bp--;
  33. -                    break;
  34. -                case 'u':
  35. -                    if (tgetstr("ue",&bp))
  36. -                        bp--;
  37. -                    break;
  38. -                case 't':
  39. -                case '@':
  40. -                    timet = time(NULL);
  41. -                    tm = localtime(&timet);
  42. -                    strftime(bp,16,"%l:%M%p",tm);
  43. -                    if (*bp == ' ')
  44. -                        chuck(bp);
  45. -                    bp += strlen(bp);
  46. -                    break;
  47. -                case 'T':
  48. -                    timet = time(NULL);
  49. -                    tm = localtime(&timet);
  50. -                    strftime(bp,16,"%k:%M",tm);
  51. -                    bp += strlen(bp);
  52. -                    break;
  53. -                case '*':
  54. -                    timet = time(NULL);
  55. -                    tm = localtime(&timet);
  56. -                    strftime(bp,16,"%k:%M:%S",tm);
  57. -                    bp += strlen(bp);
  58. -                    break;
  59. -                case 'n':
  60. -                    stradd(&bp,username);
  61. -                    break;
  62. -                case 'w':
  63. -                    timet = time(NULL);
  64. -                    tm = localtime(&timet);
  65. -                    strftime(bp,16,"%a %e",tm);
  66. -                    bp += strlen(bp);
  67. -                    break;
  68. -                case 'W':
  69. -                    timet = time(NULL);
  70. -                    tm = localtime(&timet);
  71. -                    strftime(bp,16,"%m/%d/%y",tm);
  72. -                    bp += strlen(bp);
  73. -                    break;
  74. -                case 'D':
  75. -                    timet = time(NULL);
  76. -                    tm = localtime(&timet);
  77. -                    strftime(bp,16,"%y-%m-%d",tm);
  78. -                    bp += strlen(bp);
  79. -                    break;
  80. -                case 'l':
  81. -                    if (ss = ttyname(SHTTY))
  82. -                        stradd(&bp,ss+8);
  83. -                    else
  84. -                        stradd(&bp,"(none)");
  85. -                    break;
  86. -                case '%':
  87. -                    *bp++ = '%';
  88. -                    break;
  89. -                case '#':
  90. -                    *bp++ = (geteuid()) ? '%' : '#';
  91. -                    break;
  92. -                default:
  93. -                    *bp++ = '%';
  94. -                    *bp++ = *fm;
  95. -                    break;
  96. -                }
  97. -        else    
  98. -            *bp++ = *fm;
  99. -        }
  100. -    *bp = '\0';
  101. -    return buf;
  102. -}
  103. -
  104. -void herrflush(void)
  105. -{
  106. -    if (strin)
  107. -        hflush();
  108. -    else while (lastc != '\n' && lastc != HERR)
  109. -        hgetch();
  110. -    if (magic)
  111. -        putc('\n',stderr);
  112. -}
  113. -
  114. -/* read an arbitrary amount of data into a buffer until stop is found */
  115. -
  116. -char *hdynread(char stop)
  117. -{
  118. -int bsiz = 256,ct = 0,c;
  119. -char *buf = zalloc(bsiz),*ptr;
  120. - 
  121. -    ptr = buf;
  122. -    while ((c = hgetch()) != stop && c != '\n')
  123. -        {
  124. -        if (c == '\\')
  125. -            c = hgetch();
  126. -        *ptr++ = c;
  127. -        if (++ct == bsiz)
  128. -            {
  129. -            buf = realloc(buf,bsiz *= 2);
  130. -            ptr = buf+ct;
  131. -            }
  132. -        }
  133. -    *ptr = 0;
  134. -    if (c == '\n')
  135. -        {
  136. -        hungetch('\n');
  137. -        zerr("delimiter expected");
  138. -        errflag = 1;
  139. -        free(buf);
  140. -        return NULL;
  141. -        }
  142. -    return buf;
  143. -}
  144. - 
  145. -char *hdynread2(char stop)
  146. -{
  147. -int bsiz = 256,ct = 0,c;
  148. -char *buf = zalloc(bsiz),*ptr;
  149. - 
  150. -    ptr = buf;
  151. -    while ((c = hgetch()) != stop && c != '\n')
  152. -        {
  153. -        if (c == '\n')
  154. -            {
  155. -            hungetch(c);
  156. -            break;
  157. -            }
  158. -        if (c == '\\')
  159. -            if ((c = hgetch()) == '&')
  160. -                c = '&';
  161. -        *ptr++ = c;
  162. -        if (++ct == bsiz)
  163. -            {
  164. -            buf = realloc(buf,bsiz *= 2);
  165. -            ptr = buf+ct;
  166. -            }
  167. -        }
  168. -    *ptr = 0;
  169. -    if (c == '\n')
  170. -        hungetch('\n');
  171. -    return buf;
  172. -}
  173. -
  174. -/* set cbreak mode, or the equivalent */
  175. -
  176. -void setcbreak(void)
  177. -{
  178. -struct ttyinfo ti;
  179. -
  180. -    ti = shttyinfo;
  181. -#ifdef TERMIOS
  182. -    ti.termios.c_lflag &= ~ICANON;
  183. -    ti.termios.c_cc[VMIN] = 1;
  184. -    ti.termios.c_cc[VTIME] = 0;
  185. -#else
  186. -    ti.sgttyb.sg_flags |= CBREAK;
  187. -#endif
  188. -    settyinfo(&ti);
  189. -}
  190. -
  191. -int getlineleng(void)
  192. -{
  193. -int z;
  194. -
  195. -    z = shttyinfo.winsize.ws_col;
  196. -    return (z) ? z : 80;
  197. -}
  198. -
  199. -void unsetcbreak(void)
  200. -{
  201. -    settyinfo(&shttyinfo);
  202. -}
  203. -
  204. -/* give the tty to some process */
  205. -
  206. -void attachtty(long pgrp)
  207. -{
  208. -static int ep = 0;
  209. -
  210. -    if (jobbing)
  211. -#ifdef BUGGY_GCC
  212. -        if (SHTTY != -1 && ioctl(SHTTY,(0x80000000|((sizeof(int)&0xff)<<16)|
  213. -            ('t'<<8)|118),&pgrp) == -1 && !ep)
  214. -#else
  215. -        if (SHTTY != -1 && ioctl(SHTTY,TIOCSPGRP,&pgrp) == -1 && !ep)
  216. -#endif
  217. -            {
  218. -            zerr("can't set tty pgrp: %e",errno);
  219. -            opts[MONITOR] = OPT_UNSET;
  220. -            ep =1;
  221. -            }
  222. -}
  223. -
  224. End of hist.c
  225. echo hist.pro 1>&2
  226. sed 's/^-//' >hist.pro <<'End of hist.pro'
  227. -void hwaddc(int c);
  228. -int hgetc(void);
  229. -void strinbeg(void);
  230. -void strinend(void);
  231. -int stuff(char *fn);
  232. -int hgetch(void);
  233. -void hungetch(int c);
  234. -void hungetc(int c);
  235. -void hflush(void);
  236. -void hungets(char *str);
  237. -void hbegin(void);
  238. -void inittty(void);
  239. -int hend(void);
  240. -void remhist(void);
  241. -void hwbegin(void);
  242. -char *hwadd(void);
  243. -int getargspec(int argc,int marg);
  244. -int hconsearch(char *str,int *marg);
  245. -int hcomsearch(char *str);
  246. -int apply1(int gflag,int (*func)(void **),table list);
  247. -int remtpath(void **junkptr);
  248. -int remtext(void **junkptr);
  249. -int rembutext(void **junkptr);
  250. -int remlpaths(void **junkptr);
  251. -int subst(int gbal,table slist,char *ptr1,char *ptr2);
  252. -int subststr(void **strptr,char *in,char *out,int gbal);
  253. -char *convamps(char *out,char *in);
  254. -char *makehlist(table tab,int freeit);
  255. -table quietgetevent(int ev);
  256. -table getevent(int ev);
  257. -int getargc(table tab);
  258. -table getargs(table elist,int arg1,int arg2);
  259. -int quote(void **tr);
  260. -int quotebreak(void **tr);
  261. -void stradd(char **p,char *d);
  262. -char *putprompt(char *fm);
  263. -void herrflush(void);
  264. -char *hdynread(char stop);
  265. -char *hdynread2(char stop);
  266. -void setcbreak(void);
  267. -int getlineleng(void);
  268. -void unsetcbreak(void);
  269. -void attachtty(long pgrp);
  270. End of hist.pro
  271. echo init.c 1>&2
  272. sed 's/^-//' >init.c <<'End of init.c'
  273. -/*
  274. -
  275. -    init.c - initialization, main loop
  276. -
  277. -    This file is part of zsh, the Z shell.
  278. -
  279. -   zsh is free software; no one can prevent you from reading the source
  280. -   code, or giving it to someone else.
  281. -   This file is copyrighted under the GNU General Public License, which
  282. -   can be found in the file called COPYING.
  283. -
  284. -   Copyright (C) 1990 Paul Falstad
  285. -
  286. -   zsh is distributed in the hope that it will be useful, but
  287. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  288. -   responsibility to anyone for the consequences of using it or for
  289. -   whether it serves any particular purpose or works at all, unless he
  290. -   says so in writing.  Refer to the GNU General Public License
  291. -   for full details.
  292. -
  293. -   Everyone is granted permission to copy, modify and redistribute
  294. -   zsh, but only under the conditions described in the GNU General Public
  295. -   License.   A copy of this license is supposed to have been given to you
  296. -   along with zsh so you can know your rights and responsibilities.
  297. -   It should be in a file named COPYING.
  298. -
  299. -   Among other things, the copyright notice and this notice must be
  300. -   preserved on all copies.
  301. -
  302. -*/
  303. -
  304. -#include "zsh.h"
  305. -#include "funcs.h"
  306. -#include <pwd.h>
  307. -
  308. -void main(int argc, char **argv)
  309. -{
  310. -int notect = 0;
  311. -
  312. -    setflags();
  313. -    parseargs(argv);
  314. -    setmoreflags();
  315. -    setupvals();
  316. -    initialize();
  317. -    runscripts();
  318. -    FOREVER
  319. -        {
  320. -        do
  321. -            loop();
  322. -        while (peek != EOF);
  323. -        if (!(isset(IGNOREEOF) && interact))
  324. -            {
  325. -            if (interact)
  326. -                fputs(islogin ? "logout\n" : "exit\n",stderr);
  327. -            zexit(NULL);
  328. -            continue;
  329. -            }
  330. -        zerrnam("\nzsh",(!islogin) ? "use 'exit' to exit."
  331. -            : "use 'logout' to logout.");
  332. -        notect++;
  333. -        if (notect == 10)
  334. -            zexit(NULL);
  335. -        }
  336. -}
  337. -
  338. -/* keep executing lists until EOF found */
  339. -
  340. -void loop(void)
  341. -{
  342. -list list;
  343. -
  344. -    FOREVER
  345. -        {
  346. -        peek = EMPTY;
  347. -        if (interact)
  348. -            preprompt();
  349. -        hbegin();        /* init history mech */
  350. -        intr();            /* interrupts on */
  351. -        ainit();            /* init alias mech */
  352. -        if (!(list = parlist1(0)))
  353. -            {                /* if we couldn't parse a list */
  354. -            hend();
  355. -            if (!errflag)
  356. -                if (peek == OUTPAR)
  357. -                    {
  358. -                    errflag = 1;
  359. -                    zerr("mismatched parenthesis");
  360. -                    }
  361. -                else if (peek == OUTBRACE)
  362. -                    {
  363. -                    errflag = 1;
  364. -                    zerr("mismatched brace");
  365. -                    }
  366. -                else if (peek != EOF && peek != EMPTY && peek != NEWLIN)
  367. -                    {
  368. -                    errflag = 1;
  369. -                    zerr("semicolon or newline expected");
  370. -                    }
  371. -            if (peek == EOF && !errflag)
  372. -                return;
  373. -            continue;
  374. -            }
  375. -        if (peek != EMPTY && peek != EOF)
  376. -            {
  377. -            if (peek == OUTPAR)
  378. -                zerr("mismatched parenthesis");
  379. -            else if (peek == OUTBRACE)
  380. -                zerr("mismatched brace");
  381. -            else
  382. -                zerr("semicolon or newline expected");
  383. -            hend();
  384. -            errflag = 1;
  385. -            }
  386. -        else if (hend())
  387. -            {
  388. -            if (stopmsg)        /* unset 'you have stopped jobs' flag */
  389. -                stopmsg--;
  390. -            execlist(list);
  391. -            }
  392. -        if (ferror(stderr))
  393. -            {
  394. -            zerr("write error");
  395. -            clearerr(stderr);
  396. -            }
  397. -        if (subsh)                /* how'd we get this far in a subshell? */
  398. -            exit(lastval);
  399. -        if ((!interact && errflag) || retflag)
  400. -            return;
  401. -        if ((opts['t'] == OPT_SET) || (lastval && opts[ERREXIT] == OPT_SET))
  402. -            {
  403. -            if (sigtrapped[SIGEXIT])
  404. -                dotrap(SIGEXIT);
  405. -            exit(lastval);
  406. -            }
  407. -        }
  408. -}
  409. -
  410. -void setflags(void)
  411. -{
  412. -int c;
  413. -
  414. -    for (c = 0; c != 128; c++)
  415. -        opts[c] = OPT_INVALID;
  416. -    opts['a'] = opts['e'] = opts['f'] = opts['h'] = opts['k'] = opts['n'] = 
  417. -        opts['s'] = opts['t'] = opts['u'] = opts['v'] = opts['x'] = 
  418. -        opts['c'] = OPT_UNSET;
  419. -    opts['i'] = (isatty(0)) ? OPT_SET : OPT_UNSET;
  420. -    for (c = '0'; c <= '9'; c++)
  421. -        opts[c] = OPT_UNSET;
  422. -    for (c = 'A'; c <= 'K'; c++)
  423. -        opts[c] = OPT_UNSET;
  424. -    opts[BGNICE] = opts[NOTIFY] = OPT_SET;
  425. -}
  426. -
  427. -static char *cmd;
  428. -
  429. -void parseargs(char **argv)
  430. -{
  431. -char *argv0 = *argv;
  432. -int bk = 0;
  433. -
  434. -    islogin = **(argv++) == '-';
  435. -    SHIN = 0;
  436. -    while (!bk && *argv && **argv == '-')
  437. -        {
  438. -        while (*++*argv)
  439. -            {
  440. -            if (opts[**argv] == OPT_INVALID)
  441. -                {
  442. -                zerr("bad option: -%c",**argv);
  443. -                exit(1);
  444. -                }
  445. -            opts[**argv] = OPT_SET;
  446. -            if (bk = **argv == 'b')
  447. -                break;
  448. -            if (**argv == 'c') /* -c command */
  449. -                {
  450. -                argv++;
  451. -                if (!*argv)
  452. -                    {
  453. -                    zerr("string expected after -c");
  454. -                    exit(1);
  455. -                    }
  456. -                cmd = strdup(*argv);
  457. -                opts[INTERACTIVE] = OPT_UNSET;
  458. -                break;
  459. -                }
  460. -            }
  461. -        argv++;
  462. -        }
  463. -    pparms = newtable();
  464. -    if (*argv)
  465. -        {
  466. -        if (opts[SHINSTDIN] == OPT_UNSET)
  467. -            {
  468. -            SHIN = movefd(open(argv0 = *argv,O_RDONLY));
  469. -            if (SHIN == -1)
  470. -                {
  471. -                zerr("can't open input file: %s",*argv);
  472. -                exit(1);
  473. -                }
  474. -            opts[INTERACTIVE] = OPT_UNSET;
  475. -            argv++;
  476. -            }
  477. -        addnode(pparms,argv0);  /* assign positional parameters */
  478. -        while (*argv)
  479. -            addnode(pparms,strdup(*argv++));
  480. -        }
  481. -    else
  482. -        {
  483. -        addnode(pparms,strdup(argv0));
  484. -        opts[SHINSTDIN] = OPT_SET;
  485. -        }
  486. -}
  487. -
  488. -void setmoreflags(void)
  489. -{
  490. -    setlinebuf(stderr);
  491. -    setlinebuf(stdout);
  492. -    subsh = 0;
  493. -    opts[MONITOR] = (interact) ? OPT_SET : OPT_UNSET;
  494. -    if (jobbing)
  495. -        {
  496. -        SHTTY = movefd((isatty(0)) ? dup(0) : open("/dev/tty",O_RDWR));
  497. -        if (SHTTY == -1)
  498. -            opts[MONITOR] = OPT_UNSET;
  499. -        else
  500. -            gettyinfo(&shttyinfo);    /* get tty state */
  501. -        if ((shpgrp = getpgrp(0)) <= 0)
  502. -            opts[MONITOR] = OPT_UNSET;
  503. -        }
  504. -    else
  505. -        SHTTY = -1;
  506. -}
  507. -
  508. -void setupvals(void)
  509. -{
  510. -struct passwd *pwd;
  511. -char *ptr;
  512. -
  513. -    shtimer = time(NULL);    /* init $SECONDS */
  514. -    /* build various hash tables; argument to newhtable is table size */
  515. -    alhtab = newhtable(37);
  516. -    parmhtab = newhtable(17);
  517. -    shfunchtab = newhtable(17);
  518. -    if (interact)
  519. -        {
  520. -        if (!getparm("PROMPT"))
  521. -            setparm(strdup("PROMPT"),strdup("%M%# "),0,0);
  522. -        if (!getparm("PROMPT2"))
  523. -            setparm(strdup("PROMPT2"),strdup("> "),0,0);
  524. -        if (!getparm("PROMPT3"))
  525. -            setparm(strdup("PROMPT3"),strdup("?# "),0,0);
  526. -        }
  527. -    if (!getparm("PATH"))
  528. -        setparm(strdup("PATH"),strdup("/bin:/usr/bin:/usr/ucb"),1,0);
  529. -    setparm(strdup("VERSION"),strdup(VERSIONSTR),1,0);
  530. -    home = xsymlink(getparm("HOME"));
  531. -    setparm(strdup("HOME"),strdup(home),0,0);
  532. -    setiparm(strdup("UID"),getuid(),1);
  533. -    setiparm(strdup("EUID"),geteuid(),1);
  534. -    setiparm(strdup("PPID"),getppid(),1);
  535. -    lineno = 0;
  536. -    pwd = getpwuid(getuid());
  537. -    setparm(strdup("USERNAME"),strdup(pwd->pw_name),0,0);
  538. -    username = strdup(pwd->pw_name);
  539. -    setparm(strdup("HOSTTYPE"),strdup(HOSTTYP),0,0);
  540. -    cwd = zgetwd();
  541. -    setparm(strdup("PWD"),strdup(cwd),0,0);
  542. -    if (!getparm("IFS"))
  543. -        {
  544. -        ifs = strdup(" \t\n");
  545. -        setparm(strdup("IFS"),strdup(ifs),0,0);
  546. -        }
  547. -    hostM = alloc(512);    /* get hostname, with and without .podunk.edu */
  548. -    hostm = hostM+256;
  549. -    gethostname(hostm,256);
  550. -    gethostname(hostM,256);
  551. -    procnum = getpid();
  552. -    for (ptr = hostM; *ptr && *ptr != '.'; ptr++);
  553. -    *ptr = '\0';
  554. -}
  555. -
  556. -void initialize(void)
  557. -{
  558. -int t0;
  559. -
  560. -    breaks = loops = incmd = 0;
  561. -    lastmailcheck = 0;
  562. -    lastmailval = -1;
  563. -    tfev = 1;
  564. -    tevs = DEFAULT_HISTSIZE;
  565. -    histlist = newtable();
  566. -    dirstack = newtable();
  567. -    ungots = ungotptr = NULL;
  568. -    signal(SIGQUIT,SIG_IGN);
  569. -    for (t0 = 0; t0 != RLIM_NLIMITS; t0++)
  570. -        getrlimit(t0,limits+t0);
  571. -    last = rast = NULL;
  572. -    proclast = 0;
  573. -    if (!interact || SHTTY == -1)
  574. -        bshin = fdopen(SHIN,"r");
  575. -    signal(SIGCHLD,handler);
  576. -    addreswords();
  577. -    addhnode(strdup("false"),mkanode(strdup("let 0"),1),alhtab,NULL);
  578. -    addhnode(strdup("history"),mkanode(strdup("fc -l"),1),alhtab,NULL);
  579. -    addhnode(strdup("nohup"),mkanode(strdup("nohup "),1),alhtab,NULL);
  580. -    addhnode(strdup("r"),mkanode(strdup("fc -e -"),1),alhtab,NULL);
  581. -    addhnode(strdup("true"),mkanode(strdup(":"),1),alhtab,NULL);
  582. -    addhnode(strdup("pwd"),mkanode(strdup("echo $PWD"),1),alhtab,NULL);
  583. -    parsepath();
  584. -    parsecdpath();
  585. -    if (jobbing)
  586. -        {
  587. -        signal(SIGTTOU,SIG_IGN);
  588. -        signal(SIGTSTP,SIG_IGN);
  589. -        signal(SIGTTIN,SIG_IGN);
  590. -        signal(SIGPIPE,SIG_IGN);
  591. -        attachtty(shpgrp);
  592. -        }
  593. -    if (interact)
  594. -        {
  595. -        signal(SIGTERM,SIG_IGN);
  596. -        intr();
  597. -        }
  598. -}
  599. -
  600. -void addreswords(void)
  601. -{
  602. -char *reswds[] = {
  603. -    "do", "done", "esac", "then", "elif", "else", "fi", "for", "case",
  604. -    "if", "while", "function", "repeat", "time", "until", "exec", "command",
  605. -    "select", "coproc", NULL
  606. -    };
  607. -int t0;
  608. -
  609. -    for (t0 = 0; reswds[t0]; t0++)
  610. -        addhnode(strdup(reswds[t0]),mkanode(NULL,-1-t0),alhtab,NULL);
  611. -}
  612. -
  613. -void runscripts(void)
  614. -{
  615. -    if (interact)
  616. -        checkfirstmail();
  617. -    if (opts[NORCS] == OPT_UNSET)
  618. -        {
  619. -#ifdef GLOBALZSHRC
  620. -        source(GLOBALZSHRC);
  621. -#endif
  622. -        sourcehome(".zshrc");
  623. -        if (islogin)
  624. -            {
  625. -#ifdef GLOBALZLOGIN
  626. -            source(GLOBALZLOGIN);
  627. -#endif
  628. -            sourcehome(".zlogin");
  629. -            }
  630. -        }
  631. -    if (opts['c'] == OPT_SET)
  632. -        {
  633. -        close(SHIN);
  634. -        SHIN = movefd(open("/dev/null",O_RDONLY));
  635. -        hungets(cmd);
  636. -        strinbeg();
  637. -        }
  638. -}
  639. -
  640. -void ainit(void)
  641. -{
  642. -    alix = 0;        /* reset alias stack */
  643. -    alstat = 0;
  644. -    firstln = 1;
  645. -}
  646. End of init.c
  647. echo init.pro 1>&2
  648. sed 's/^-//' >init.pro <<'End of init.pro'
  649. -void main(int argc, char **argv);
  650. -void loop(void);
  651. -void setflags(void);
  652. -void parseargs(char **argv);
  653. -void setmoreflags(void);
  654. -void setupvals(void);
  655. -void initialize(void);
  656. -void addreswords(void);
  657. -void runscripts(void);
  658. -void ainit(void);
  659. End of init.pro
  660. echo jobs.c 1>&2
  661. sed 's/^-//' >jobs.c <<'End of jobs.c'
  662. -/*
  663. -
  664. -    jobs.c - job control
  665. -
  666. -    This file is part of zsh, the Z shell.
  667. -
  668. -   zsh is free software; no one can prevent you from reading the source
  669. -   code, or giving it to someone else.
  670. -   This file is copyrighted under the GNU General Public License, which
  671. -   can be found in the file called COPYING.
  672. -
  673. -   Copyright (C) 1990 Paul Falstad
  674. -
  675. -   zsh is distributed in the hope that it will be useful, but
  676. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  677. -   responsibility to anyone for the consequences of using it or for
  678. -   whether it serves any particular purpose or works at all, unless he
  679. -   says so in writing.  Refer to the GNU General Public License
  680. -   for full details.
  681. -
  682. -   Everyone is granted permission to copy, modify and redistribute
  683. -   zsh, but only under the conditions described in the GNU General Public
  684. -   License.   A copy of this license is supposed to have been given to you
  685. -   along with zsh so you can know your rights and responsibilities.
  686. -   It should be in a file named COPYING.
  687. -
  688. -   Among other things, the copyright notice and this notice must be
  689. -   preserved on all copies.
  690. -
  691. -*/
  692. -
  693. -#include "zsh.h"
  694. -#include "funcs.h"
  695. -#include <sys/errno.h>
  696. -
  697. -#define WCOREDUMPED(x) ((x)&0x80)
  698. -
  699. -/* != 0 means the handler is active */
  700. -
  701. -static int handling = 0;
  702. -
  703. -/* != 0 means the shell is waiting for a job to complete */
  704. -
  705. -static int waiting = 0;
  706. -
  707. -/* != 0 means readline is active */
  708. -
  709. -extern int rl_active;
  710. -
  711. -/* != 0 means readline is waiting for a keypress */
  712. -
  713. -extern int rl_waiting;
  714. -
  715. -#ifdef INTHANDTYPE
  716. -#define RETURN return 0
  717. -#else
  718. -#define RETURN return
  719. -#endif
  720. -
  721. -/* the signal handler */
  722. -
  723. -HANDTYPE handler(int sig,int code)
  724. -{
  725. -long pid;
  726. -int statusp;
  727. -struct jobnode *jn;
  728. -struct procnode *pn;
  729. -struct rusage ru;
  730. -
  731. -    if (sig == SIGINT)
  732. -        {
  733. -        if (sigtrapped[SIGINT])
  734. -            dotrap(SIGINT);
  735. -        else
  736. -            errflag = 1;
  737. -        RETURN;
  738. -        }
  739. -    if (sig != SIGCHLD)
  740. -        {
  741. -        dotrap(sig);
  742. -        RETURN;
  743. -        }
  744. -    for (;;)
  745. -        {
  746. -        pid = wait3(&statusp,WNOHANG|WUNTRACED,&ru);
  747. -        if (pid == -1)
  748. -            {
  749. -            if (errno != ECHILD)
  750. -                zerr("%e",errno);
  751. -            RETURN;
  752. -            }
  753. -        if (!pid)
  754. -            RETURN;
  755. -        findproc(pid,&jn,&pn);    /* find the procnode of this pid */
  756. -        if (jn)
  757. -            {
  758. -            pn->statusp = statusp;
  759. -            handling = 1;
  760. -            pn->ru_utime = ru.ru_utime;
  761. -            pn->ru_stime = ru.ru_stime;
  762. -            pn->endtime = time(NULL);
  763. -            updatestatus(jn);
  764. -            handling = 0;
  765. -            }
  766. -        else if (WIFSTOPPED(SP(statusp)))
  767. -            kill(pid,SIGKILL);    /* kill stopped untraced children */
  768. -        }
  769. -    if (rl_active)
  770. -        rl_prep_terminal();
  771. -    RETURN;
  772. -}
  773. -
  774. -/* change job table entry from stopped to running */
  775. -
  776. -void makerunning(struct jobnode *jn)
  777. -{
  778. -struct procnode *pn;
  779. -
  780. -    jn->stat &= ~STAT_STOPPED;
  781. -    for (pn = jn->procs; pn; pn = pn->next)
  782. -        if (WIFSTOPPED(SP(pn->statusp)))
  783. -            pn->statusp = SP_RUNNING;
  784. -}
  785. -
  786. -/* update status of job, possibly printing it */
  787. -
  788. -void updatestatus(struct jobnode *jn)
  789. -{
  790. -struct procnode *pn;
  791. -int notrunning = 1,alldone = 1,val,job = jn-jobtab,somestopped = 0;
  792. -
  793. -    for (pn = jn->procs; pn; pn = pn->next)
  794. -        {
  795. -        if (pn->statusp == SP_RUNNING)
  796. -            notrunning = 0;
  797. -        if (pn->statusp == SP_RUNNING || WIFSTOPPED(SP(pn->statusp)))
  798. -            alldone = 0;
  799. -        if (WIFSTOPPED(SP(pn->statusp)))
  800. -            somestopped = 1;
  801. -        if (!pn->next && jn)
  802. -            val = (WIFSIGNALED(SP(pn->statusp))) ?
  803. -                0200 | WTERMSIG(SP(pn->statusp)) : WEXITSTATUS(SP(pn->statusp));
  804. -        }
  805. -    if (!notrunning)
  806. -        return;
  807. -    if (somestopped && (jn->stat & STAT_STOPPED))
  808. -        return;
  809. -    jn->stat |= (alldone) ? STAT_CHANGED|STAT_DONE :
  810. -        STAT_CHANGED|STAT_STOPPED;
  811. -    if (!alldone)
  812. -        gettyinfo(&jn->ttyinfo);
  813. -    if (job == curjob)
  814. -        {
  815. -        if (!val)
  816. -            gettyinfo(&shttyinfo);
  817. -        else
  818. -            settyinfo(&shttyinfo);
  819. -        lastval = val;
  820. -        }
  821. -    if (jn->stat & STAT_STOPPED)
  822. -        {
  823. -        prevjob = topjob;
  824. -        topjob = job;
  825. -        }
  826. -    if ((isset(NOTIFY) || job == curjob) && jn->stat & STAT_LOCKED)
  827. -        printjob(jn,0);
  828. -    if (sigtrapped[SIGCHLD] && job != curjob)
  829. -        dotrap(SIGCHLD);
  830. -}
  831. -
  832. -/* find procnode and jobnode associated with pid */
  833. -
  834. -void findproc(int pid,struct jobnode **jptr,struct procnode **pptr)
  835. -{
  836. -struct procnode *pn;
  837. -int jn;
  838. -
  839. -    for (jn = 1; jn != MAXJOB; jn++)
  840. -        for (pn = jobtab[jn].procs; pn; pn = pn->next)
  841. -            if (pn->pid == pid)
  842. -                {
  843. -                *pptr = pn;
  844. -                *jptr = jobtab+jn;
  845. -                return;
  846. -                }
  847. -    *pptr = NULL;
  848. -    *jptr = NULL;
  849. -}
  850. -
  851. -static char *sigmsg[32] = {
  852. -    "done","hangup","interrupt","quit",
  853. -    "illegal instruction","trace trap","IOT instruction","EMT instruction",
  854. -    "floating exception","killed","bus error","segmentation fault",
  855. -    "bad system call","broken pipe","SIGALRM","terminated",
  856. -#ifdef USE_SUSPENDED
  857. -    "SIGURG","suspended (signal)","suspended","continued",
  858. -    "SIGCHLD","suspended (tty input)","suspended (tty output)","SIGIO",
  859. -#else
  860. -    "SIGURG","stopped (signal)","stopped","continued",
  861. -    "SIGCHLD","stopped (tty input)","stopped (tty output)","SIGIO",
  862. -#endif
  863. -    "CPU time limit exceeded","file size limit exceeded","SIGVTALRM","SIGPROF",
  864. -    "window changed","resource lost","SIGUSR1","SIGUSR2"
  865. -    };
  866. -
  867. -/* lng = 0 means jobs 
  868. -    lng = 1 means jobs -l
  869. -    lng = 2 means jobs -p
  870. -*/
  871. -
  872. -void printjob(struct jobnode *jn,int lng)
  873. -{
  874. -int job = jn-jobtab,len = 9,sig = -1,sflag = 0,llen,printed = 0;
  875. -int conted = 0,lineleng = getlineleng(),doputnl = 0;
  876. -struct procnode *pn;
  877. -extern void rl_on_new_line(void);
  878. -
  879. -    if (lng < 0)
  880. -        {
  881. -        conted = 1;
  882. -        lng = 0;
  883. -        }
  884. -
  885. -    /* find length of longest signame, check to see if we
  886. -        really need to print this job */
  887. -
  888. -    for (pn = jn->procs; pn; pn = pn->next)
  889. -        {
  890. -        if (pn->statusp != SP_RUNNING)
  891. -            if (WIFSIGNALED(SP(pn->statusp)))
  892. -                {
  893. -                sig = WTERMSIG(SP(pn->statusp));
  894. -                llen = strlen(sigmsg[sig]);
  895. -                if (WCOREDUMPED(pn->statusp))
  896. -                    llen += 14;
  897. -                if (llen > len)
  898. -                    len = llen;
  899. -                if (sig != SIGINT && sig != SIGPIPE)
  900. -                    sflag = 1;
  901. -                if (sig == SIGINT && job == curjob && interact)
  902. -                    doputnl = 1;
  903. -                }
  904. -            else if (WIFSTOPPED(SP(pn->statusp)))
  905. -                {
  906. -                sig = WSTOPSIG(SP(pn->statusp));
  907. -                if (strlen(sigmsg[sig]) > len)
  908. -                    len = strlen(sigmsg[sig]);
  909. -                }
  910. -            else if (isset(PRINTEXITVALUE) && WEXITSTATUS(SP(pn->statusp)))
  911. -                sflag = 1;
  912. -        }
  913. -    if (doputnl)
  914. -        putc('\n',stderr);
  915. -
  916. -    /* print if necessary */
  917. -
  918. -    if (interact && jobbing && ((jn->stat & STAT_STOPPED) || sflag ||
  919. -            job != curjob))
  920. -        {
  921. -        int len2,fline = 1;
  922. -        struct procnode *qn;
  923. -
  924. -        if (handling && (!waiting || jn->stat & STAT_STOPPED))
  925. -            putc('\n',stderr);
  926. -        for (pn = jn->procs; pn;)
  927. -            {
  928. -            len2 = ((job == curjob) ? 5 : 10)+len; /* 2 spaces */
  929. -            if (lng)
  930. -                qn = pn->next;
  931. -            else for (qn = pn->next; qn; qn = qn->next)
  932. -                {
  933. -                if (qn->statusp != pn->statusp)
  934. -                    break;
  935. -                if (strlen(qn->text)+len2+((qn->next) ? 3 : 0) > lineleng)
  936. -                    break;
  937. -                len2 += strlen(qn->text)+2;
  938. -                }
  939. -            if (job != curjob)
  940. -                if (fline)
  941. -                    fprintf(stderr,"[%d]  %c ",jn-jobtab,(job == topjob) ? '+' :
  942. -                        (job == prevjob) ? '-' : ' ');
  943. -                else
  944. -                    fprintf(stderr,(job > 9) ? "        " : "       ");
  945. -            else
  946. -                fprintf(stderr,"zsh: ");
  947. -            if (lng)
  948. -                if (lng == 1)
  949. -                    fprintf(stderr,"%d ",pn->pid);
  950. -                else
  951. -                    {
  952. -                    fprintf(stderr,"%d ",jn->gleader);
  953. -                    lng = 0;
  954. -                    }
  955. -            if (pn->statusp == SP_RUNNING)
  956. -                if (!conted)
  957. -                    fprintf(stderr,"running%*s",len-7+2,"");
  958. -                else
  959. -                    fprintf(stderr,"continued%*s",len-9+2,"");
  960. -            else if (WIFEXITED(SP(pn->statusp)))
  961. -                if (WEXITSTATUS(SP(pn->statusp)))
  962. -                    fprintf(stderr,"exit %-4d%*s",WEXITSTATUS(SP(pn->statusp)),
  963. -                        len-9+2,"");
  964. -                else
  965. -                    fprintf(stderr,"done%*s",len-4+2,"");
  966. -            else if (WIFSTOPPED(SP(pn->statusp)))
  967. -                fprintf(stderr,"%-*s",len+2,sigmsg[WSTOPSIG(SP(pn->statusp))]);
  968. -            else if (WCOREDUMPED(pn->statusp))
  969. -                fprintf(stderr,"%s (core dumped)%*s",
  970. -                    sigmsg[WTERMSIG(SP(pn->statusp))],
  971. -                    len-14+2-strlen(sigmsg[WTERMSIG(SP(pn->statusp))]),"");
  972. -            else
  973. -                fprintf(stderr,"%-*s",len+2,sigmsg[WTERMSIG(SP(pn->statusp))]);
  974. -            for (; pn != qn; pn = pn->next)
  975. -                fprintf(stderr,(pn->next) ? "%s | " : "%s",pn->text);
  976. -            putc('\n',stderr);
  977. -            fline = 0;
  978. -            }
  979. -        printed = 1;
  980. -        }
  981. -
  982. -    /* print "(pwd now: foo)" messages */
  983. -
  984. -    if (interact && job==curjob && strcmp(jn->cwd,cwd))
  985. -        {
  986. -        printf("(pwd now: ");
  987. -        printdir(cwd);
  988. -        printf(")\n");
  989. -        fflush(stdout);
  990. -        }
  991. -
  992. -    /* delete job if done */
  993. -
  994. -    if (jn->stat & STAT_DONE)
  995. -        {
  996. -        static struct jobnode zero;
  997. -        struct procnode *nx;
  998. -        char *s;
  999. -
  1000. -        if (jn->stat & STAT_TIMED)
  1001. -            {
  1002. -            dumptime(jn);
  1003. -            printed = 1;
  1004. -            }
  1005. -        for (pn = jn->procs; pn; pn = nx)
  1006. -            {
  1007. -            nx = pn->next;
  1008. -            if (pn->text)
  1009. -                free(pn->text);
  1010. -            free(pn);
  1011. -            }
  1012. -        free(jn->cwd);
  1013. -        if (jn->filelist)
  1014. -            {
  1015. -            while (s = getnode(jn->filelist))
  1016. -                {
  1017. -                unlink(s);
  1018. -                free(s);
  1019. -                }
  1020. -            free(jn->filelist);
  1021. -            }
  1022. -        *jn = zero;
  1023. -        if (job == topjob)
  1024. -            {
  1025. -            topjob = prevjob;
  1026. -            prevjob = job;
  1027. -            }
  1028. -        if (job == prevjob)
  1029. -            setprevjob();
  1030. -        }
  1031. -    else
  1032. -        jn->stat &= ~STAT_CHANGED;
  1033. -    if (printed && rl_active)
  1034. -        {
  1035. -        rl_on_new_line();
  1036. -        if (rl_waiting)
  1037. -            rl_redisplay();
  1038. -        }
  1039. -}
  1040. -
  1041. -/* set the previous job to something reasonable */
  1042. -
  1043. -void setprevjob(void)
  1044. -{
  1045. -int t0;
  1046. -
  1047. -    for (t0 = MAXJOB-1; t0; t0--)
  1048. -        if (jobtab[t0].stat && jobtab[t0].stat & STAT_STOPPED &&
  1049. -                t0 != topjob && t0 != curjob)
  1050. -            break;
  1051. -    if (!t0)
  1052. -        for (t0 = MAXJOB-1; t0; t0--)
  1053. -            if (jobtab[t0].stat && t0 != topjob && t0 != curjob)
  1054. -                break;
  1055. -    prevjob = (t0) ? t0 : -1;
  1056. -}
  1057. -
  1058. -/* initialize a job table entry */
  1059. -
  1060. -void initjob(int flags)
  1061. -{
  1062. -    jobtab[curjob].cwd = strdup(cwd);
  1063. -    jobtab[curjob].stat = (flags & PFLAG_TIMED) | STAT_INUSE;
  1064. -    jobtab[curjob].ttyinfo = shttyinfo;
  1065. -    jobtab[curjob].gleader = 0;
  1066. -}
  1067. -
  1068. -/* add a process to the current job */
  1069. -
  1070. -struct procnode *addproc(long pid,char *text)
  1071. -{
  1072. -struct procnode *procnode;
  1073. -
  1074. -    if (!jobtab[curjob].gleader)
  1075. -        jobtab[curjob].gleader = proclast = pid;
  1076. -    proclast = pid;
  1077. -    procnode = alloc(sizeof(struct procnode));
  1078. -    procnode->pid = pid;
  1079. -    procnode->text = text;
  1080. -    procnode->next = NULL;
  1081. -    procnode->statusp = SP_RUNNING;
  1082. -    procnode->bgtime = time(NULL);
  1083. -    if (jobtab[curjob].procs)
  1084. -        {
  1085. -        struct procnode *n;
  1086. -
  1087. -        for (n = jobtab[curjob].procs; n->next && !n->next->lastfg; n = n->next);
  1088. -        procnode->next = n->next;
  1089. -        n->next = procnode;
  1090. -        }
  1091. -    else
  1092. -        jobtab[curjob].procs = procnode;
  1093. -    return procnode;
  1094. -}
  1095. -
  1096. -/* determine if it's all right to exec a command without
  1097. -    forking in last component of subshells; it's not ok if we have files
  1098. -    to delete */
  1099. -
  1100. -int execok(void)
  1101. -{
  1102. -struct jobnode *jn;
  1103. -
  1104. -    if (!exiting)
  1105. -        return 0;
  1106. -    for (jn = jobtab+1; jn != jobtab+MAXJOB; jn++)
  1107. -        if (jn->stat && jn->filelist)
  1108. -            return 0;
  1109. -    return 1;
  1110. -}
  1111. -
  1112. -/* wait for a SIGCHLD, wait for the handler to execute, and return */
  1113. -
  1114. -void chldsuspend(void)
  1115. -{
  1116. -struct sigvec vec = { handler,sigmask(SIGCHLD),SV_INTERRUPT };
  1117. -
  1118. -    sigvec(SIGCHLD,&vec,NULL);
  1119. -    sigpause(0);
  1120. -    signal(SIGCHLD,handler);
  1121. -}
  1122. -
  1123. -/* wait for the current job to finish */
  1124. -
  1125. -void waitjobs(void)
  1126. -{
  1127. -static struct jobnode zero;
  1128. -struct jobnode *jn;
  1129. -
  1130. -    if (jobtab[curjob].procs)    /* if any forks were done */
  1131. -        {
  1132. -        jobtab[curjob].stat |= STAT_LOCKED;
  1133. -        waiting = 1;
  1134. -        if (jobtab[curjob].stat & STAT_CHANGED)
  1135. -            printjob(jobtab+curjob,0);
  1136. -        while (jobtab[curjob].stat &&
  1137. -                !(jobtab[curjob].stat & (STAT_DONE|STAT_STOPPED)))
  1138. -            chldsuspend();
  1139. -        waiting = 0;
  1140. -        }
  1141. -    else    /* else do what printjob() usually does */
  1142. -        {
  1143. -        char *s;
  1144. -
  1145. -        jn = jobtab+curjob;
  1146. -        free(jn->cwd);
  1147. -        if (jn->filelist)
  1148. -            {
  1149. -            while (s = getnode(jn->filelist))
  1150. -                {
  1151. -                unlink(s);
  1152. -                free(s);
  1153. -                }
  1154. -            free(jn->filelist);
  1155. -            }
  1156. -        *jn = zero;
  1157. -        }
  1158. -    curjob = -1;
  1159. -}
  1160. -
  1161. -/* clear jobtab when entering subshells */
  1162. -
  1163. -void clearjobtab(void)
  1164. -{
  1165. -static struct jobnode zero;
  1166. -int t0;
  1167. -
  1168. -    for (t0 = 1; t0 != MAXJOB; t0++)
  1169. -        jobtab[curjob] = zero;
  1170. -}
  1171. -
  1172. -/* get a free entry in the job table to use */
  1173. -
  1174. -int getfreejob(void)
  1175. -{
  1176. -int mask,t0;
  1177. -
  1178. -    FOREVER    
  1179. -        {
  1180. -        mask = sigblock(sigmask(SIGCHLD));
  1181. -        for (t0 = 1; t0 != MAXJOB; t0++)
  1182. -            if (!jobtab[t0].stat)
  1183. -                {
  1184. -                sigsetmask(mask);
  1185. -                jobtab[t0].stat |= STAT_INUSE;
  1186. -                return t0;
  1187. -                }
  1188. -        sigsetmask(mask);
  1189. -        sleep(1);
  1190. -        }
  1191. -}
  1192. -
  1193. -/* print pids for & */
  1194. -
  1195. -void spawnjob(void)
  1196. -{
  1197. -struct procnode *pn;
  1198. -
  1199. -    if (!subsh)
  1200. -        {
  1201. -        if (topjob == -1 || !(jobtab[topjob].stat & STAT_STOPPED))
  1202. -            {
  1203. -            topjob = curjob;
  1204. -            setprevjob();
  1205. -            }
  1206. -        else if (prevjob == -1 || !(jobtab[prevjob].stat & STAT_STOPPED))
  1207. -            prevjob = curjob;
  1208. -        if (interact && jobbing)
  1209. -            {
  1210. -            fprintf(stderr,"[%d]",curjob);
  1211. -            for (pn = jobtab[curjob].procs; pn; pn = pn->next)
  1212. -                fprintf(stderr," %d",pn->pid);
  1213. -            fprintf(stderr,"\n");
  1214. -            }
  1215. -        }
  1216. -    jobtab[curjob].stat |= STAT_LOCKED;
  1217. -    curjob = -1;
  1218. -}
  1219. -
  1220. -void fixsigs(void)
  1221. -{
  1222. -    sigsetmask(0);
  1223. -}
  1224. -
  1225. -/* timing */
  1226. -
  1227. -static void addtimeval(struct timeval *s,struct timeval *t)
  1228. -{
  1229. -    s->tv_sec += t->tv_sec+(s->tv_usec+t->tv_usec)/1000000;
  1230. -    s->tv_usec = (s->tv_usec+t->tv_usec)%1000000;
  1231. -}
  1232. -
  1233. -static void printtime(time_t real,struct timeval *u,struct timeval *s,char *desc)
  1234. -{
  1235. -    if (!desc)
  1236. -        desc = "";
  1237. -    fprintf(stderr,"real: %lds  user: %ld.%03lds  sys: %ld.%03lds\n",
  1238. -        real,u->tv_sec,u->tv_usec/1000,s->tv_sec,s->tv_usec/1000);
  1239. -}
  1240. -
  1241. -static void printheader(void)
  1242. -{
  1243. -    fprintf(stderr,"  real       user      system\n");
  1244. -}
  1245. -
  1246. -static void printtimes(time_t real,struct timeval *u,struct timeval *s,char *desc)
  1247. -{
  1248. -    if (!desc)
  1249. -        desc = "";
  1250. -    fprintf(stderr,"% 8lds  % 4d.%03lds  % 4d.%03lds  %s\n",
  1251. -        real,u->tv_sec,u->tv_usec/1000,s->tv_sec,s->tv_usec/1000,desc);
  1252. -}
  1253. -
  1254. -void dumptime(struct jobnode *jn)
  1255. -{
  1256. -struct procnode *pn = jn->procs;
  1257. -struct timeval utot = { 0,0 },stot = { 0,0 };
  1258. -time_t maxend,minbeg;
  1259. -
  1260. -    if (!jn->procs)
  1261. -        return;
  1262. -    if (!jn->procs->next)
  1263. -        printtime(pn->endtime-pn->bgtime,&pn->ru_utime,&pn->ru_stime,pn->text);
  1264. -    else
  1265. -        {
  1266. -        maxend = jn->procs->endtime;
  1267. -        minbeg = jn->procs->bgtime;
  1268. -        printheader();
  1269. -        for (pn = jn->procs; pn; pn = pn->next)
  1270. -            {
  1271. -            printtimes(pn->endtime-pn->bgtime,&pn->ru_utime,&pn->ru_stime,pn->text);
  1272. -            addtimeval(&utot,&pn->ru_utime);
  1273. -            addtimeval(&stot,&pn->ru_stime);
  1274. -            if (pn->endtime > maxend)
  1275. -                maxend = pn->endtime;
  1276. -            if (pn->bgtime < minbeg)
  1277. -                minbeg = pn->bgtime;
  1278. -            }
  1279. -        printtimes(maxend-minbeg,&utot,&stot,"total");
  1280. -        }
  1281. -}
  1282. -
  1283. -/* SIGHUP any jobs left running */
  1284. -
  1285. -void killrunjobs(void)
  1286. -{
  1287. -int t0,killed = 0;
  1288. -
  1289. -    for (t0 = 1; t0 != MAXJOB; t0++)
  1290. -        if (t0 != curjob && jobtab[t0].stat &&
  1291. -                !(jobtab[t0].stat & STAT_STOPPED))
  1292. -            {
  1293. -            killpg(jobtab[t0].gleader,SIGHUP);
  1294. -            killed++;
  1295. -            }
  1296. -    if (killed)
  1297. -        zerr("warning: %d jobs SIGHUPed",killed);
  1298. -}
  1299. -
  1300. -/* check to see if user has jobs running/stopped */
  1301. -
  1302. -void checkjobs(void)
  1303. -{
  1304. -int t0;
  1305. -
  1306. -    for (t0 = 1; t0 != MAXJOB; t0++)
  1307. -        if (t0 != curjob && jobtab[t0].stat)
  1308. -            break;
  1309. -    if (t0 != MAXJOB)
  1310. -        {
  1311. -        if (jobtab[t0].stat & STAT_STOPPED)
  1312. -            {
  1313. -#ifdef USE_SUSPENDED
  1314. -            zerr("you have suspended jobs.");
  1315. -#else
  1316. -            zerr("you have stopped jobs.");
  1317. -#endif
  1318. -            }
  1319. -        else
  1320. -            zerr("you have running jobs.");
  1321. -        stopmsg = 1;
  1322. -        }
  1323. -}
  1324. -
  1325. -/* send a signal to a job (simply involves killpg if monitoring is on) */
  1326. -
  1327. -int killjb(struct jobnode *jn,int sig)
  1328. -{
  1329. -struct procnode *pn;
  1330. -int err;
  1331. -
  1332. -    if (jobbing)
  1333. -        return(killpg(jn->gleader,sig));
  1334. -    for (pn = jn->procs; pn; pn = pn->next)
  1335. -        if ((err = kill(pn->pid,sig)) == -1 && errno != ESRCH)
  1336. -            return -1;
  1337. -    return err;
  1338. -}
  1339. -
  1340. End of jobs.c
  1341. echo jobs.pro 1>&2
  1342. sed 's/^-//' >jobs.pro <<'End of jobs.pro'
  1343. -HANDTYPE handler(int sig,int code);
  1344. -void makerunning(struct jobnode *jn);
  1345. -void updatestatus(struct jobnode *jn);
  1346. -void findproc(int pid,struct jobnode **jptr,struct procnode **pptr);
  1347. -void printjob(struct jobnode *jn,int lng);
  1348. -void setprevjob(void);
  1349. -void initjob(int flags);
  1350. -struct procnode *addproc(long pid,char *text);
  1351. -int execok(void);
  1352. -void chldsuspend(void);
  1353. -void waitjobs(void);
  1354. -void clearjobtab(void);
  1355. -int getfreejob(void);
  1356. -void spawnjob(void);
  1357. -void fixsigs(void);
  1358. -void dumptime(struct jobnode *jn);
  1359. -void killrunjobs(void);
  1360. -void checkjobs(void);
  1361. -int killjb(struct jobnode *jn,int sig);
  1362. End of jobs.pro
  1363. echo lex.c 1>&2
  1364. sed 's/^-//' >lex.c <<'End of lex.c'
  1365. -/*
  1366. -
  1367. -    lex.c - lexical analysis
  1368. -
  1369. -    This file is part of zsh, the Z shell.
  1370. -
  1371. -   zsh is free software; no one can prevent you from reading the source
  1372. -   code, or giving it to someone else.
  1373. -   This file is copyrighted under the GNU General Public License, which
  1374. -   can be found in the file called COPYING.
  1375. -
  1376. -   Copyright (C) 1990 Paul Falstad
  1377. -
  1378. -   zsh is distributed in the hope that it will be useful, but
  1379. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  1380. -   responsibility to anyone for the consequences of using it or for
  1381. -   whether it serves any particular purpose or works at all, unless he
  1382. -   says so in writing.  Refer to the GNU General Public License
  1383. -   for full details.
  1384. -
  1385. -   Everyone is granted permission to copy, modify and redistribute
  1386. -   zsh, but only under the conditions described in the GNU General Public
  1387. -   License.   A copy of this license is supposed to have been given to you
  1388. -   along with zsh so you can know your rights and responsibilities.
  1389. -   It should be in a file named COPYING.
  1390. -
  1391. -   Among other things, the copyright notice and this notice must be
  1392. -   preserved on all copies.
  1393. -
  1394. -*/
  1395. -
  1396. -#include "zsh.h"
  1397. -#include "funcs.h"
  1398. -
  1399. -/* match the current token and get another
  1400. -    (actually just get another) */
  1401. -
  1402. -void matchit(void)
  1403. -{
  1404. -    do
  1405. -        gettok();
  1406. -    while (exalias());
  1407. -}
  1408. -
  1409. -int len = 0,bsiz = 256;
  1410. -char *bptr;
  1411. -
  1412. -/* add a char to the string buffer */
  1413. -
  1414. -void add(int c)
  1415. -{
  1416. -    *bptr++ = c;
  1417. -    if (bsiz == ++len)
  1418. -        bptr = len+(tstr = realloc(tstr,bsiz *= 2));
  1419. -}
  1420. -
  1421. -/* get a token */
  1422. -
  1423. -void gettok(void)
  1424. -{
  1425. -int bct = 0,pct = 0;
  1426. -int c,d,intpos = 1;
  1427. -static int dbparens = 0;
  1428. -
  1429. -beginning:
  1430. -    hlastw = NULL;
  1431. -    tstr = NULL;
  1432. -    while (zspace(c = hgetc()) || c == '\t' || c == ' ');
  1433. -    firstln = 0;
  1434. -    hwbegin();
  1435. -    hwaddc(c);
  1436. -    if (dbparens)    /* handle ((...)) */
  1437. -        {
  1438. -        int pct = 2;
  1439. -
  1440. -        peek = STRING;
  1441. -        len = dbparens = 0;
  1442. -        bptr = tstr = zalloc(bsiz = 256);
  1443. -        for (;;)
  1444. -            {
  1445. -            if (c == '(')
  1446. -                pct++;
  1447. -            else if (c == ')')
  1448. -                pct--;
  1449. -            else if (c == '\n')
  1450. -                {
  1451. -                zerr("parse error: )) expected");
  1452. -                peek = HERR;
  1453. -                free(tstr);
  1454. -                return;
  1455. -                }
  1456. -            else if (c == '$')
  1457. -                c = Qstring;
  1458. -            if (pct >= 2)
  1459. -                add(c);
  1460. -            if (pct)
  1461. -                c = hgetc();
  1462. -            else
  1463. -                break;
  1464. -            }
  1465. -        *bptr = '\0';
  1466. -        return;
  1467. -        }
  1468. -    peekfd = -1;
  1469. -    if (isdigit(c))    /* handle 1< foo */
  1470. -        {
  1471. -        d = hgetc();
  1472. -        hungetc(d);
  1473. -        if (d == '>' || d == '<')
  1474. -            {
  1475. -            peekfd = c-'0';
  1476. -            c = hgetc();
  1477. -            }
  1478. -        }
  1479. -
  1480. -    /* chars in initial position in word */
  1481. -
  1482. -    switch (c)
  1483. -        {
  1484. -        case '\\':
  1485. -            d = hgetc();
  1486. -            if (d == '\n')
  1487. -                goto beginning;
  1488. -            hungetc(d);
  1489. -            break;
  1490. -        case EOF:
  1491. -            peek = EOF;
  1492. -            return;
  1493. -        case HERR:
  1494. -            peek = HERR;
  1495. -            return;
  1496. -        case '\n':
  1497. -            peek = NEWLIN;
  1498. -            return;
  1499. -        case ';':
  1500. -            d = hgetc();
  1501. -            if (d != ';')
  1502. -                {
  1503. -                hungetc(d);
  1504. -                peek = SEMI;
  1505. -                }
  1506. -            else
  1507. -                peek = DSEMI;
  1508. -            return;
  1509. -        case '!':
  1510. -            if (!incmd)
  1511. -                {
  1512. -                peek = BANG;
  1513. -                return;
  1514. -                }
  1515. -            break;
  1516. -        case '&':
  1517. -            d = hgetc();
  1518. -            if (d != '&')
  1519. -                {
  1520. -                hungetc(d);
  1521. -                peek = AMPER;
  1522. -                }
  1523. -            else
  1524. -                peek = DAMPER;
  1525. -            return;
  1526. -        case '|':
  1527. -            d = hgetc();
  1528. -            if (d == '|')
  1529. -                peek = DBAR;
  1530. -            else if (d == '&')
  1531. -                peek = BARAMP;
  1532. -            else
  1533. -                {
  1534. -                hungetc(d);
  1535. -                peek = BAR;
  1536. -                }
  1537. -            return;
  1538. -        case '(':
  1539. -            if (incmd)
  1540. -                break;
  1541. -            d = hgetc();
  1542. -            if (d == '(')
  1543. -                {
  1544. -                peek = STRING;
  1545. -                tstr = strdup("let");
  1546. -                dbparens = 1;
  1547. -                return;
  1548. -                }
  1549. -            hungetc(d);
  1550. -            peek = INPAR;
  1551. -            return;
  1552. -        case ')':
  1553. -            peek = OUTPAR;
  1554. -            return;
  1555. -        case '{':
  1556. -            if (incmd)
  1557. -                break;
  1558. -            peek = INBRACE;
  1559. -            return;
  1560. -        case '}':
  1561. -            peek = OUTBRACE;
  1562. -            return;
  1563. -        case '<':
  1564. -            d = hgetc();
  1565. -            if (incmd && d == '(')
  1566. -                {
  1567. -                hungetc(d);
  1568. -                break;
  1569. -                }
  1570. -            else if (d == '<')
  1571. -                {
  1572. -                int e = hgetc();
  1573. -
  1574. -                hungetc(e);
  1575. -                if (e == '(')
  1576. -                    {
  1577. -                    hungetc(d);
  1578. -                    peek = INANG;
  1579. -                    }
  1580. -                else
  1581. -                    peek = DINANG;
  1582. -                }
  1583. -            else if (d == '&')
  1584. -                peek = INANGAMP;
  1585. -            else
  1586. -                {
  1587. -                peek = INANG;
  1588. -                hungetc(d);
  1589. -                }
  1590. -            return;
  1591. -        case '>':
  1592. -            d = hgetc();
  1593. -            if (d == '(')
  1594. -                {
  1595. -                hungetc(d);
  1596. -                break;
  1597. -                }
  1598. -            else if (d == '&')
  1599. -                {
  1600. -                d = hgetc();
  1601. -                if (d == '!')
  1602. -                    peek = OUTANGAMPBANG;
  1603. -                else
  1604. -                    {
  1605. -                    hungetc(d);
  1606. -                    peek = OUTANGAMP;
  1607. -                    }
  1608. -                }
  1609. -            else if (d == '!')
  1610. -                peek = OUTANGBANG;
  1611. -            else if (d == '>')
  1612. -                {
  1613. -                d = hgetc();
  1614. -                if (d == '&')
  1615. -                    {
  1616. -                    d = hgetc();
  1617. -                    if (d == '!')
  1618. -                        peek = DOUTANGAMPBANG;
  1619. -                    else
  1620. -                        {
  1621. -                        hungetc(d);
  1622. -                        peek = DOUTANGAMP;
  1623. -                        }
  1624. -                    }
  1625. -                else if (d == '!')
  1626. -                    peek = DOUTANGBANG;
  1627. -                else if (d == '(')
  1628. -                    {
  1629. -                    hungetc(d);
  1630. -                    hungetc('>');
  1631. -                    peek = OUTANG;
  1632. -                    }
  1633. -                else
  1634. -                    {
  1635. -                    hungetc(d);
  1636. -                    peek = DOUTANG;
  1637. -                    }
  1638. -                }
  1639. -            else
  1640. -                {
  1641. -                hungetc(d);
  1642. -                peek = OUTANG;
  1643. -                }
  1644. -            return;
  1645. -        case '#':
  1646. -#ifndef INTERACTIVE_COMMENTS
  1647. -            if (interact)
  1648. -                break;
  1649. -#endif
  1650. -            while ((c = hgetch()) != '\n' && !istok(c) && c != EOF);
  1651. -            if (c == '\n')
  1652. -                peek = NEWLIN;
  1653. -            else
  1654. -                errflag = 1;
  1655. -            return;
  1656. -        }
  1657. -
  1658. -    /* we've started a string, now get the rest of it, performing
  1659. -        tokenization */
  1660. -
  1661. -    peek = STRING;
  1662. -    len = 0;
  1663. -    bptr = tstr = zalloc(bsiz = 256);
  1664. -    for(;;)
  1665. -        {
  1666. -        if (c == ';' || c == '&' || c == EOF ||
  1667. -                c == HERR || c == '\03' || c == '\n' || 
  1668. -                c == ' ' || c == '\t' || znspace(c))
  1669. -            break;
  1670. -        if (c == '#')
  1671. -            c = Pound;
  1672. -        else if (c == ')')
  1673. -            {
  1674. -            if (!pct)
  1675. -                break;
  1676. -            pct--;
  1677. -            c = Outpar;
  1678. -            }
  1679. -        else if (c == ',')
  1680. -            c = Comma;
  1681. -        else if (c == '|')
  1682. -            {
  1683. -            if (!pct)
  1684. -                break;
  1685. -            c = Bar;
  1686. -            }
  1687. -        else if (c == '$')
  1688. -            {
  1689. -            d = hgetc();
  1690. -
  1691. -            c = String;
  1692. -            if (d == '[')
  1693. -                {
  1694. -                add(String);
  1695. -                add(Inbrack);
  1696. -                while ((c = hgetc()) != ']' && !istok(c) && c != EOF)
  1697. -                    add(c);
  1698. -                c = Outbrack;
  1699. -                }
  1700. -            else if (d == '(')
  1701. -                {
  1702. -                add(String);
  1703. -                skipcomm();
  1704. -                c = Outpar;
  1705. -                }
  1706. -            else
  1707. -                hungetc(d);
  1708. -            }
  1709. -        else if (c == '^')
  1710. -            c = Hat;
  1711. -        else if (c == '[')
  1712. -            c = Inbrack;
  1713. -        else if (c == ']')
  1714. -            c = Outbrack;
  1715. -        else if (c == '*')
  1716. -            c = Star;
  1717. -        else if (intpos && c == '~')
  1718. -            c = Tilde;
  1719. -        else if (c == '?')
  1720. -            c = Quest;
  1721. -        else if (c == '(')
  1722. -            {
  1723. -            int d = hgetc();
  1724. -
  1725. -            hungetc(d);
  1726. -            if (!incmd)
  1727. -                break;
  1728. -#if 0
  1729. -            if (d != ')' && intpos)
  1730. -                {
  1731. -                add(Inang);
  1732. -                skipcomm();
  1733. -                c = Outpar;
  1734. -                }
  1735. -            else
  1736. -#endif
  1737. -                {
  1738. -                pct++;
  1739. -                c = Inpar;
  1740. -                }
  1741. -            }
  1742. -        else if (c == '{')
  1743. -            {
  1744. -            c = Inbrace;
  1745. -            bct++;
  1746. -            }
  1747. -        else if (c == '}')
  1748. -            {
  1749. -            if (!bct)
  1750. -                break;
  1751. -            c = Outbrace;
  1752. -            bct--;
  1753. -            }
  1754. -        else if (c == '>')
  1755. -            {
  1756. -            d = hgetc();
  1757. -            if (d != '(')
  1758. -                {
  1759. -                hungetc(d);
  1760. -                break;
  1761. -                }
  1762. -            add(Outang);
  1763. -            skipcomm();
  1764. -            c = Outpar;
  1765. -            }
  1766. -        else if (c == '<')
  1767. -            {
  1768. -            d = hgetc();
  1769. -            if (!(isdigit(d) || d == '-' || d == '>' || d == '(' || d == ')'))
  1770. -                {
  1771. -                hungetc(d);
  1772. -                break;
  1773. -                }
  1774. -            c = Inang;
  1775. -            if (d == '(')
  1776. -                {
  1777. -                add(c);
  1778. -                skipcomm();
  1779. -                c = Outpar;
  1780. -                }
  1781. -            else if (d == ')')
  1782. -                hungetc(d);
  1783. -            else
  1784. -                {
  1785. -                add(c);
  1786. -                c = d;
  1787. -                while (c != '>' && !istok(c) && c != EOF)
  1788. -                    add(c),c = hgetc();
  1789. -                if (c == EOF)
  1790. -                    {
  1791. -                    errflag = 1;
  1792. -                    peek = EOF;
  1793. -                    return;
  1794. -                    }
  1795. -                c = Outang;
  1796. -                }
  1797. -            }
  1798. -        else if (c == '=')
  1799. -            {
  1800. -            if (intpos)
  1801. -                {
  1802. -                d = hgetc();
  1803. -                if (d != '(')
  1804. -                    {
  1805. -                    hungetc(d);
  1806. -                    c = Equals;
  1807. -                    }
  1808. -                else
  1809. -                    {
  1810. -                    add(Equals);
  1811. -                    skipcomm();
  1812. -                    c = Outpar;
  1813. -                    }
  1814. -                }
  1815. -            else if (peek != ENVSTRING)
  1816. -                {
  1817. -                peek = ENVSTRING;
  1818. -                intpos = 2;
  1819. -                }
  1820. -            }
  1821. -        else if (c == '\\')
  1822. -            {
  1823. -            c = hgetc();
  1824. -
  1825. -            if (c == '\n')
  1826. -                {
  1827. -                c = hgetc();
  1828. -                continue;
  1829. -                }
  1830. -            add(c);
  1831. -            c = hgetc();
  1832. -            continue;
  1833. -            }
  1834. -        else if (c == '\'')
  1835. -            {
  1836. -            add(Nularg);
  1837. -
  1838. -            /* we add the Nularg to prevent this:
  1839. -
  1840. -            echo $PA'TH'
  1841. -
  1842. -            from printing the path. */
  1843. -
  1844. -            while ((c = hgetc()) != '\'' && !istok(c) && c != EOF)
  1845. -                add(c);
  1846. -            if (c == EOF)
  1847. -                {
  1848. -                errflag = 1;
  1849. -                peek = EOF;
  1850. -                return;
  1851. -                }
  1852. -            c = Nularg;
  1853. -            }
  1854. -        else if (c == HQUOT)
  1855. -            {
  1856. -            add(Nularg);
  1857. -            while ((c = hgetc()) != HQUOT && !istok(c) && c != EOF)
  1858. -                add(c);
  1859. -            if (c == EOF)
  1860. -                {
  1861. -                errflag = 1;
  1862. -                peek = EOF;
  1863. -                return;
  1864. -                }
  1865. -            c = Nularg;
  1866. -            }
  1867. -        else if (c == '\"')
  1868. -            {
  1869. -            add(Nularg);
  1870. -            while ((c = hgetc()) != '\"' && !istok(c) && c != EOF)
  1871. -                if (c == '\\')
  1872. -                    {
  1873. -                    c = hgetc();
  1874. -                    if (c != '\n')
  1875. -                        {
  1876. -                        if (c != '$' && c != '\\' && c != '\"' && c != '`')
  1877. -                            add('\\');
  1878. -                        add(c);
  1879. -                        }
  1880. -                    }
  1881. -                else
  1882. -                    {
  1883. -                    if (c == '$')
  1884. -                        {
  1885. -                        int d = hgetc();
  1886. -
  1887. -                        if (d == '(')
  1888. -                            {
  1889. -                            add(Qstring);
  1890. -                            skipcomm();
  1891. -                            c = Outpar;
  1892. -                            }
  1893. -                        else if (d == '[')
  1894. -                            {
  1895. -                            add(String);
  1896. -                            add(Inbrack);
  1897. -                            while ((c = hgetc()) != ']' && c != EOF)
  1898. -                                add(c);
  1899. -                            c = Outbrack;
  1900. -                            }
  1901. -                        else
  1902. -                            {
  1903. -                            c = Qstring;
  1904. -                            hungetc(d);
  1905. -                            }
  1906. -                        }
  1907. -                    else if (c == '`')
  1908. -                        c = Qtick;
  1909. -                    add(c);
  1910. -                    }
  1911. -            if (c == EOF)
  1912. -                {
  1913. -                errflag = 1;
  1914. -                peek = EOF;
  1915. -                return;
  1916. -                }
  1917. -            c = Nularg;
  1918. -            }
  1919. -        else if (c == '`')
  1920. -            {
  1921. -            add(Tick);
  1922. -            while ((c = hgetc()) != '`' && !istok(c) && c != EOF)
  1923. -                if (c == '\\')
  1924. -                    {
  1925. -                    c = hgetc();
  1926. -                    if (c != '\n')
  1927. -                        {
  1928. -                        if (c != '`' && c != '\\' && c != '$')
  1929. -                            add('\\');
  1930. -                        add(c);
  1931. -                        }
  1932. -                    }
  1933. -                else
  1934. -                    {
  1935. -                    if (c == '$')
  1936. -                        c = String;
  1937. -                    add(c);
  1938. -                    }
  1939. -            if (c == EOF)
  1940. -                {
  1941. -                errflag = 1;
  1942. -                peek = EOF;
  1943. -                return;
  1944. -                }
  1945. -            c = Tick;
  1946. -            }
  1947. -        add(c);
  1948. -        c = hgetc();
  1949. -        if (intpos)
  1950. -            intpos--;
  1951. -        }
  1952. -    if (c == HERR)
  1953. -        {
  1954. -        free(tstr);
  1955. -        peek = HERR;
  1956. -        return;
  1957. -        }
  1958. -    hungetc(c);
  1959. -    *bptr = '\0';
  1960. -}
  1961. -
  1962. -/* expand aliases, perhaps */
  1963. -
  1964. -int exalias(void)
  1965. -{
  1966. -struct anode *an;
  1967. -char *s;
  1968. -
  1969. -    s = hwadd();
  1970. -    if (alix != MAXAL && (an = gethnode(s,alhtab)) && !an->inuse &&
  1971. -            !(an->cmd && incmd && alstat != ALSTAT_MORE))
  1972. -        {
  1973. -        if (an->cmd < 0)
  1974. -            {
  1975. -            peek = DO-an->cmd-1;
  1976. -            return 0;
  1977. -            }
  1978. -        an->inuse = 1;
  1979. -        hungets(strdup(ALPOPS));
  1980. -        hungets(strdup((alstack[alix++] = an)->text));
  1981. -        alstat = 0;
  1982. -        if (tstr)
  1983. -            free(tstr);
  1984. -        return 1;
  1985. -        }
  1986. -    return 0;
  1987. -}
  1988. -
  1989. -/* != 0 if c is not a newline, but in IFS */
  1990. -
  1991. -int zspace(int c)
  1992. -{
  1993. -    if (c == '\n')
  1994. -        return 0;
  1995. -    return znspace(c);
  1996. -}
  1997. -
  1998. -/* != 0 if c is in IFS */
  1999. -
  2000. -int znspace(int c)
  2001. -{
  2002. -char *ptr = ifs;
  2003. -
  2004. -    while (*ptr)
  2005. -        if (*ptr++ == c)
  2006. -            return 1;
  2007. -    return 0;
  2008. -}
  2009. -
  2010. -/* skip (...) */
  2011. -
  2012. -void skipcomm(void)
  2013. -{
  2014. -int pct = 1,c;
  2015. -
  2016. -    c = Inpar;
  2017. -    do
  2018. -        {
  2019. -        add(c);
  2020. -reget:
  2021. -        c = hgetc();
  2022. -        if (istok(c) || c == EOF)
  2023. -            break;
  2024. -        else if (c == '(') pct++;
  2025. -        else if (c == ')') pct--;
  2026. -        else if (c == '\\')
  2027. -            {
  2028. -            add(c);
  2029. -            c = hgetc();
  2030. -            }
  2031. -        else if (c == '\'')
  2032. -            {
  2033. -            add(c);
  2034. -            while ((c = hgetc()) != '\'' && !istok(c) && c != EOF)
  2035. -                add(c);
  2036. -            }
  2037. -        else if (c == HQUOT)
  2038. -            {
  2039. -            while ((c = hgetc()) != HQUOT && !istok(c) && c != EOF)
  2040. -                add(c);
  2041. -            goto reget;
  2042. -            }
  2043. -        else if (c == '\"')
  2044. -            {
  2045. -            add(c);
  2046. -            while ((c = hgetc()) != '\"' && !istok(c) && c != EOF)
  2047. -                if (c == '\\')
  2048. -                    {
  2049. -                    add(c);
  2050. -                    add(hgetc());
  2051. -                    }
  2052. -                else add(c);
  2053. -            }
  2054. -        else if (c == '`')
  2055. -            {
  2056. -            add(c);
  2057. -            while ((c = hgetc()) != '`' && c != HERR && c != EOF)
  2058. -                if (c == '\\') add(c), add(hgetc());
  2059. -                else add(c);
  2060. -            }
  2061. -        }
  2062. -    while(pct);
  2063. -}
  2064. -
  2065. End of lex.c
  2066. echo lex.pro 1>&2
  2067. sed 's/^-//' >lex.pro <<'End of lex.pro'
  2068. -void matchit(void);
  2069. -void add(int c);
  2070. -void gettok(void);
  2071. -int exalias(void);
  2072. -int zspace(int c);
  2073. -int znspace(int c);
  2074. -void skipcomm(void);
  2075. End of lex.pro
  2076. echo loop.c 1>&2
  2077. sed 's/^-//' >loop.c <<'End of loop.c'
  2078. -/*
  2079. -
  2080. -    loop.c - parsing and executing loop constructs
  2081. -
  2082. -    This file is part of zsh, the Z shell.
  2083. -
  2084. -   zsh is free software; no one can prevent you from reading the source
  2085. -   code, or giving it to someone else.
  2086. -   This file is copyrighted under the GNU General Public License, which
  2087. -   can be found in the file called COPYING.
  2088. -
  2089. -   Copyright (C) 1990 Paul Falstad
  2090. -
  2091. -   zsh is distributed in the hope that it will be useful, but
  2092. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  2093. -   responsibility to anyone for the consequences of using it or for
  2094. -   whether it serves any particular purpose or works at all, unless he
  2095. -   says so in writing.  Refer to the GNU General Public License
  2096. -   for full details.
  2097. -
  2098. -   Everyone is granted permission to copy, modify and redistribute
  2099. -   zsh, but only under the conditions described in the GNU General Public
  2100. -   License.   A copy of this license is supposed to have been given to you
  2101. -   along with zsh so you can know your rights and responsibilities.
  2102. -   It should be in a file named COPYING.
  2103. -
  2104. -   Among other things, the copyright notice and this notice must be
  2105. -   preserved on all copies.
  2106. -
  2107. -*/
  2108. -
  2109. -#include "zsh.h"
  2110. -#include "funcs.h"
  2111. -
  2112. -/* parse a for/select loop */
  2113. -
  2114. -int parfor(comm comm,int isfor)
  2115. -{
  2116. -struct fornode *node = alloc(sizeof(struct fornode));
  2117. -char *comnam = (isfor) ? "for" : "select";
  2118. -
  2119. -    comm->type = (isfor) ? CFOR : CSELECT;
  2120. -    comm->info = node;
  2121. -    if (peek != STRING)
  2122. -        {
  2123. -        zerr("parse error in %s: identifier expected",comnam);
  2124. -        errflag = 1;
  2125. -        return 0;
  2126. -        }
  2127. -    node->name = tstr;
  2128. -    matchit();
  2129. -    node->list = NULL;
  2130. -    node->inflag = 0;
  2131. -    if (peek == STRING && !strcmp("in",tstr))
  2132. -       {
  2133. -        node->inflag = 1;
  2134. -        free(tstr);
  2135. -        matchit();
  2136. -        while (peek == STRING)
  2137. -            {
  2138. -            addnode(comm->args,tstr);
  2139. -            matchit();
  2140. -            }
  2141. -        }
  2142. -    if (peek != NEWLIN && peek != SEMI)
  2143. -        {
  2144. -        zerr("parse error: bad token in '%s' list",comnam);
  2145. -        freecmd(comm);
  2146. -        return 1;
  2147. -        }
  2148. -    incmd = 0;
  2149. -    matchit();
  2150. -    while (peek == NEWLIN)
  2151. -        matchit();
  2152. -    if (peek != DO)
  2153. -        {
  2154. -        zerr("parse error: 'do' expected");
  2155. -        freecmd(comm);
  2156. -        return 1;
  2157. -        }
  2158. -    matchit();
  2159. -    if (!(node->list = parlist(1)))
  2160. -        {
  2161. -        freecmd(comm);
  2162. -        return 1;
  2163. -        }
  2164. -    if (peek != DONE)
  2165. -        {
  2166. -        zerr("parse error: 'done' expected");
  2167. -        freecmd(comm);
  2168. -        return 1;
  2169. -        }
  2170. -    matchit();
  2171. -    return 0;
  2172. -}
  2173. - 
  2174. -int parcase(comm comm)
  2175. -{
  2176. -struct casenode *node = alloc(sizeof(struct casenode)),*last = NULL;
  2177. -char *tok; /* add FREES to this function */
  2178. -
  2179. -    comm->type = CCASE;
  2180. -    comm->info = node;
  2181. -    if (peek != STRING)
  2182. -        {
  2183. -        zerr("parse error in case: identifier expected");
  2184. -        errflag = 1;
  2185. -        return 0;
  2186. -        }
  2187. -    addnode(comm->args,tstr);
  2188. -    matchit();
  2189. -    if (peek != STRING || strcmp(tstr,"in"))
  2190. -        {
  2191. -        zerr("parse error in case: `in' expected");
  2192. -        errflag = 1;
  2193. -        return 0;
  2194. -        }
  2195. -    while (tok = getcasepat())
  2196. -        {
  2197. -        node = alloc(sizeof(struct casenode));
  2198. -        node->pat = tok;
  2199. -        if (last)
  2200. -            last->next = node;
  2201. -        else
  2202. -            comm->info = node;
  2203. -        (last = node)->list = parlist(1);
  2204. -        if (peek != DSEMI)
  2205. -            {
  2206. -            zerr("parse error: ;; expected");
  2207. -            return 1;
  2208. -            }
  2209. -        }
  2210. -    if (!last)
  2211. -        {
  2212. -        zerr("null case construct");
  2213. -        return 1;
  2214. -        }
  2215. -    return 0;
  2216. -}
  2217. -
  2218. -/* get a case pattern: foo) */
  2219. -
  2220. -char *getcasepat(void)
  2221. -{
  2222. -int c,bsiz = 256,ct = 0,pct = 0,qt = 0;
  2223. -char *buf = zalloc(bsiz),*ptr,*s;
  2224. - 
  2225. -    peek = EMPTY;
  2226. -    while (znspace(c = hgetc()))
  2227. -        {
  2228. -        if (c == '\n')
  2229. -            {
  2230. -            hwbegin();
  2231. -            hwaddc('\n');
  2232. -            hwadd();
  2233. -            }
  2234. -        }
  2235. -    ptr = buf;
  2236. -    hwbegin();
  2237. -    hwaddc(c);
  2238. -    while (c != ')' || pct)
  2239. -        {
  2240. -        for (s = tokens; *s; s++)
  2241. -            if (*s == c)
  2242. -                {
  2243. -                c = (s-tokens)+Pound;
  2244. -                break;
  2245. -                }
  2246. -        if (qt)
  2247. -            {
  2248. -            if (c == '\'')
  2249. -                {
  2250. -                qt = 0;
  2251. -                c = hgetc();
  2252. -                continue;
  2253. -                }
  2254. -            if (c == EOF)
  2255. -                {
  2256. -                qt = 0;
  2257. -                continue;
  2258. -                }
  2259. -            }
  2260. -        else
  2261. -            {
  2262. -            if (c == '\\')
  2263. -                c = hgetc();
  2264. -            if (c == '\'')
  2265. -                {
  2266. -                qt = 1;
  2267. -                c = hgetc();
  2268. -                continue;
  2269. -                }
  2270. -            if (c == Inpar)
  2271. -                pct++;
  2272. -            if (c == Outpar)
  2273. -                pct--;
  2274. -            if (ct == 4 && (znspace(c)||c ==';'||c=='&') && !strncmp(buf,"esac",4))
  2275. -                {
  2276. -                hungetc(c);
  2277. -                hwadd();
  2278. -                free(buf);
  2279. -                matchit();
  2280. -                return NULL;
  2281. -                }
  2282. -            if (c == '\n' || c == EOF)
  2283. -                {
  2284. -                free(buf);
  2285. -                zerr("parse error: 'esac' expected");
  2286. -                return NULL;
  2287. -                }
  2288. -            }
  2289. -        if (c == HERR)
  2290. -            {
  2291. -            free(buf);
  2292. -            return NULL;
  2293. -            }
  2294. -        *ptr++ = c;
  2295. -        if (++ct == bsiz)
  2296. -            {
  2297. -            ptr = zalloc(bsiz *= 2);
  2298. -            memcpy(ptr,buf,ct);
  2299. -            free(buf);
  2300. -            buf = ptr;
  2301. -            ptr = buf+ct;
  2302. -            }
  2303. -        c = hgetc();
  2304. -        }
  2305. -    *ptr = 0;
  2306. -    hwadd();
  2307. -    return buf;
  2308. -}
  2309. - 
  2310. -int parif(comm comm)
  2311. -{
  2312. -struct ifnode *node = alloc(sizeof(struct ifnode));
  2313. - 
  2314. -    comm->type = CIF;
  2315. -    comm->info = node;
  2316. -do_then:
  2317. -    node->next = NULL;
  2318. -    if (!(node->ifl = parlist(1)))
  2319. -        {
  2320. -        freecmd(comm);
  2321. -        return 1;
  2322. -        }
  2323. -    if (peek != THEN)
  2324. -        {
  2325. -        zerr("parse error: 'then' expected");
  2326. -        freecmd(comm);
  2327. -        return 1;
  2328. -        }
  2329. -    matchit();
  2330. -    if (!(node->thenl = parlist(1)))
  2331. -        {
  2332. -        freecmd(comm);
  2333. -        return 1;
  2334. -        }
  2335. -    if (peek == ELIF)
  2336. -        {
  2337. -        matchit();
  2338. -        node = node->next = alloc(sizeof(struct ifnode));
  2339. -        goto do_then;
  2340. -        }
  2341. -    else if (peek == ELSE)
  2342. -        {
  2343. -        matchit();
  2344. -        node = node->next = alloc(sizeof(struct ifnode));
  2345. -        node->next = NULL;
  2346. -        node->ifl = NULL;
  2347. -        if (!(node->thenl = parlist(1)))
  2348. -            {
  2349. -            freecmd(comm);
  2350. -            return 1;
  2351. -            }
  2352. -        }
  2353. -    if (peek != FI)
  2354. -        {
  2355. -        zerr("parse error: 'fi' expected");
  2356. -        freecmd(comm);
  2357. -        return 1;
  2358. -        }
  2359. -    matchit();
  2360. -    return 0;
  2361. -}
  2362. -
  2363. -/* parse while or until */
  2364. -
  2365. -int parwhile(comm comm,int cond)
  2366. -{
  2367. -struct whilenode *node = alloc(sizeof (struct whilenode));
  2368. - 
  2369. -    comm->type = CWHILE;
  2370. -    comm->info = node;
  2371. -    node->cond = cond;
  2372. -    node->loop = node->cont = NULL;
  2373. -    if (!(node->cont = parlist(1)))
  2374. -        {
  2375. -        freecmd(comm);
  2376. -        return NULL;
  2377. -        }
  2378. -    if (peek != DO)
  2379. -        {
  2380. -        zerr("parse error: 'do' expected");
  2381. -        freecmd(comm);
  2382. -        return 1;
  2383. -        }
  2384. -    matchit();
  2385. -    node->loop = parlist(1);
  2386. -    if (peek != DONE)
  2387. -        {
  2388. -        zerr("parse error: 'done' expected");
  2389. -        freecmd(comm);
  2390. -        return 1;
  2391. -        }
  2392. -    matchit();
  2393. -    return 0;
  2394. -}
  2395. - 
  2396. -int parrepeat(comm comm)
  2397. -{
  2398. -struct repeatnode *node = alloc(sizeof (struct repeatnode));
  2399. -
  2400. -    comm->type = CREPEAT;
  2401. -    comm->info = node;
  2402. -    node->list = NULL;
  2403. -    if (peek != STRING || !isdigit(*tstr))
  2404. -        {
  2405. -        zerr("parse error: number expected");
  2406. -        freecmd(comm);
  2407. -        return 1;
  2408. -        }
  2409. -    node->count = atoi(tstr);
  2410. -    free(tstr);
  2411. -    incmd = 0;
  2412. -    do
  2413. -        matchit();
  2414. -    while (peek == NEWLIN);
  2415. -    if (peek != DO)
  2416. -        {
  2417. -        zerr("parse error: 'do' expected");
  2418. -        freecmd(comm);
  2419. -        return 1;
  2420. -        }
  2421. -    matchit();
  2422. -    node->list = parlist(1);
  2423. -    if (peek != DONE)
  2424. -        {
  2425. -        zerr("parse error: 'done' expected");
  2426. -        freecmd(comm);
  2427. -        return 1;
  2428. -        }
  2429. -    matchit();
  2430. -    return 0;
  2431. -}
  2432. -
  2433. -void execfor(comm comm)
  2434. -{
  2435. -list list;
  2436. -struct fornode *node;
  2437. -char *str;
  2438. -table args;
  2439. -int cj = curjob;
  2440. -
  2441. -    loops++;
  2442. -    exiting = 0;
  2443. -    node = comm->info;
  2444. -    args = comm->args;
  2445. -    if (!node->inflag)
  2446. -        {
  2447. -        args = duptable(pparms,dupstr);
  2448. -        freestr(getnode(args));
  2449. -        }
  2450. -    while (str = getnode(args))
  2451. -        {
  2452. -        setparm(strdup(node->name),str,0,0);
  2453. -        list = duplist(node->list);
  2454. -        execlist(list);
  2455. -        if (breaks)
  2456. -            {
  2457. -            breaks--;
  2458. -            if (breaks || !contflag)
  2459. -                break;
  2460. -            contflag = 0;
  2461. -            }
  2462. -        }
  2463. -    curjob = cj;
  2464. -}
  2465. -
  2466. -void execselect(comm comm)
  2467. -{
  2468. -list list;
  2469. -struct fornode *node;
  2470. -char *str,*s;
  2471. -table args;
  2472. -Node n;
  2473. -int cj = curjob,t0;
  2474. -
  2475. -    loops++;
  2476. -    node = comm->info;
  2477. -    args = comm->args;
  2478. -    exiting = 0;
  2479. -    for (;;)
  2480. -        {
  2481. -        do
  2482. -            {
  2483. -            for (t0 = 1,n = args->first; n; n=n->next,t0++)
  2484. -                fprintf(stderr,"%d %s\n",t0,n->dat);
  2485. -            if (interact && SHTTY != -1)
  2486. -                {
  2487. -                inittty();
  2488. -                str = readline(putprompt("PROMPT3"));
  2489. -                }
  2490. -            else
  2491. -                str = fgets(zalloc(256),256,bshin);
  2492. -            if (!str || errflag)
  2493. -                {
  2494. -                fprintf(stderr,"\n");
  2495. -                goto done;
  2496. -                }
  2497. -            if (s = strchr(str,'\n'))
  2498. -                *s = '\0';
  2499. -            }
  2500. -        while (!*str);
  2501. -        setparm(strdup("REPLY"),str,0,0);
  2502. -        t0 = atoi(str);
  2503. -        if (!t0)
  2504. -            str = "";
  2505. -        else
  2506. -            {
  2507. -            for (t0--,n = args->first; n && t0; n=n->next,t0--);
  2508. -            if (n)
  2509. -                str = n->dat;
  2510. -            else
  2511. -                str = "";
  2512. -            }
  2513. -        setparm(strdup(node->name),strdup(str),0,0);
  2514. -        list = duplist(node->list);
  2515. -        execlist(list);
  2516. -        if (breaks)
  2517. -            {
  2518. -            breaks--;
  2519. -            if (breaks || !contflag)
  2520. -                break;
  2521. -            contflag = 0;
  2522. -            }
  2523. -        if (errflag)
  2524. -            break;
  2525. -        }
  2526. -done:
  2527. -    curjob = cj;
  2528. -}
  2529. - 
  2530. -void execwhile(comm comm)
  2531. -{
  2532. -list list;
  2533. -struct whilenode *node;
  2534. -int cj = curjob; 
  2535. -
  2536. -    loops++;
  2537. -    node = comm->info;
  2538. -    exiting = 0;
  2539. -    FOREVER
  2540. -        {
  2541. -        list = duplist(node->cont);
  2542. -        execlist(list);
  2543. -        if (!((lastval == 0) ^ node->cond))
  2544. -            break;
  2545. -        if (breaks)
  2546. -            {
  2547. -            breaks--;
  2548. -            if (breaks || !contflag)
  2549. -                break;
  2550. -            contflag = 0;
  2551. -            }
  2552. -        list = duplist(node->loop);
  2553. -        execlist(list);
  2554. -        }
  2555. -    curjob = cj;
  2556. -}
  2557. - 
  2558. -void execrepeat(comm comm)
  2559. -{
  2560. -list list;
  2561. -struct repeatnode *node;
  2562. -int cj = curjob;
  2563. -
  2564. -    loops++;
  2565. -    node = comm->info;
  2566. -    exiting = 0;
  2567. -    while (node->count--)
  2568. -        {
  2569. -        list = duplist(node->list);
  2570. -        execlist(list);
  2571. -        if (breaks)
  2572. -            {
  2573. -            breaks--;
  2574. -            if (breaks || !contflag)
  2575. -                break;
  2576. -            contflag = 0;
  2577. -            }
  2578. -        if (lastval)
  2579. -            break;
  2580. -        }
  2581. -    curjob = cj;
  2582. -}
  2583. - 
  2584. -void execif(comm comm)
  2585. -{
  2586. -list list;
  2587. -struct ifnode *node;
  2588. -int cj = curjob;
  2589. -
  2590. -    node = comm->info;
  2591. -    exiting = 0;
  2592. -    while (node)
  2593. -        {
  2594. -        if (node->ifl)
  2595. -            {
  2596. -            list = duplist(node->ifl);
  2597. -            execlist(list);
  2598. -            if (lastval)
  2599. -                {
  2600. -                node = node->next;
  2601. -                continue;
  2602. -                }
  2603. -            }
  2604. -        list = duplist(node->thenl);
  2605. -        execlist(list);
  2606. -        break;
  2607. -        }
  2608. -    curjob = cj;
  2609. -}
  2610. - 
  2611. -void execcase(comm comm)
  2612. -{
  2613. -list list;
  2614. -struct casenode *node;
  2615. -char *word;
  2616. -table args;
  2617. -int cj = curjob;
  2618. -
  2619. -    node = comm->info;
  2620. -    args = comm->args;
  2621. -    exiting = 0;
  2622. -    if (!args->first || args->first->next)
  2623. -        {
  2624. -        zerr("bad case statement");
  2625. -        errflag = 1;
  2626. -        return;
  2627. -        }
  2628. -    word = args->first->dat;
  2629. -    while (node)
  2630. -        if (matchpat(word,node->pat))
  2631. -            break;
  2632. -        else
  2633. -            node = node->next;
  2634. -    if (node)
  2635. -        {
  2636. -        list = duplist(node->list);
  2637. -        execlist(list);
  2638. -        }
  2639. -    curjob = cj;
  2640. -}
  2641. - 
  2642. -list duplist(list xlist)
  2643. -{
  2644. -list nlist;
  2645. - 
  2646. -    if (!xlist)
  2647. -        return NULL;
  2648. -    nlist = alloc(sizeof(struct lnode));
  2649. -    nlist->left = duplist2(xlist->left);
  2650. -    nlist->right = duplist(xlist->right);
  2651. -    nlist->type = xlist->type;
  2652. -    return nlist;
  2653. -}
  2654. -
  2655. -void freelist(list xlist)
  2656. -{
  2657. -    if (xlist)
  2658. -        {
  2659. -        freelist2(xlist->left);
  2660. -        freelist(xlist->right);
  2661. -        free(xlist);
  2662. -        }
  2663. -}
  2664. -
  2665. -list2 duplist2(list2 x)
  2666. -{
  2667. -list2 y;
  2668. -
  2669. -    if (!x)
  2670. -        return NULL;
  2671. -    y = alloc(sizeof(struct l2node));
  2672. -    *y = *x;
  2673. -    y->left = duppline(x->left);
  2674. -    y->right = duplist2(x->right);
  2675. -    return y;
  2676. -}
  2677. -
  2678. -void freelist2(list2 x)
  2679. -{
  2680. -    if (x)
  2681. -        {
  2682. -        freepline(x->left);
  2683. -        freelist2(x->right);
  2684. -        free(x);
  2685. -        }
  2686. -}
  2687. -
  2688. -pline duppline(pline xpline)
  2689. -{
  2690. -pline npline;
  2691. - 
  2692. -    if (!xpline)
  2693. -        return NULL;
  2694. -    npline = alloc(sizeof(struct pnode));
  2695. -    npline->left = dupcomm(xpline->left);
  2696. -    npline->right = duppline(xpline->right);
  2697. -    npline->type = xpline->type;
  2698. -    return npline;
  2699. -}
  2700. -
  2701. -void freepline(pline x)
  2702. -{
  2703. -    if (x)
  2704. -        {
  2705. -        freecmd(x->left);
  2706. -        freepline(x->right);
  2707. -        free(x);
  2708. -        }
  2709. -}
  2710. -
  2711. -comm dupcomm(comm xcomm)
  2712. -{
  2713. -comm ncomm;
  2714. -void *(*duprs[])(void *) = {dupfor,dupwhile,duprepeat,dupif,dupcase};
  2715. -int type;
  2716. - 
  2717. -    if (!xcomm)
  2718. -        return NULL;
  2719. -    ncomm = alloc(sizeof(struct cnode));
  2720. -    ncomm->left = duplist(xcomm->left);
  2721. -    ncomm->cmd = dupstr(xcomm->cmd);
  2722. -    ncomm->args = duptable(xcomm->args,dupstr);
  2723. -    ncomm->redir = duptable(xcomm->redir,dupfnode);
  2724. -    ncomm->vars = (xcomm->vars) ? duptable(xcomm->vars,dupstr) : NULL;
  2725. -    ncomm->type = type = xcomm->type;
  2726. -    if (type >= CFOR && type <= CCASE)
  2727. -        ncomm->info = (duprs[type-CFOR])(xcomm->info);
  2728. -    return ncomm;
  2729. -}
  2730. -
  2731. -void freecmd(comm x)
  2732. -{
  2733. -    if (x)
  2734. -        {
  2735. -        freelist(x->left);
  2736. -        if (x->cmd)
  2737. -            free(x->cmd);
  2738. -        if (x->args)
  2739. -            freetable(x->args,freestr);
  2740. -        if (x->redir)
  2741. -            freetable(x->redir,freeredir);
  2742. -        if (x->vars)
  2743. -            freetable(x->vars,freestr);
  2744. -/*        if (x->info)
  2745. -            freeinfo(x->info);*/
  2746. -        free(x);
  2747. -        }
  2748. -}
  2749. -
  2750. -void *dupstr(void *str)
  2751. -{
  2752. -    if (!str)
  2753. -        return NULL;
  2754. -    return strdup(str);
  2755. -}
  2756. -
  2757. -void *dupfnode(void *i)
  2758. -{
  2759. -struct fnode *fn = i,*nfn = alloc(sizeof(struct fnode));
  2760. - 
  2761. -    if (!i)
  2762. -        return NULL;
  2763. -    *nfn = *fn;
  2764. -    if (nfn->type < HEREDOC)
  2765. -        nfn->u.name = strdup(fn->u.name);
  2766. -    return nfn;
  2767. -}
  2768. -
  2769. -void *dupfor(void *i)
  2770. -{
  2771. -struct fornode *nnode,*node = i;
  2772. - 
  2773. -    nnode = alloc(sizeof(struct fornode));
  2774. -    *nnode = *(struct fornode *) i;
  2775. -    nnode->name = strdup(node->name);
  2776. -    nnode->list = duplist(node->list);
  2777. -    return nnode;
  2778. -}
  2779. - 
  2780. -void *dupcase(void *i)
  2781. -{
  2782. -struct casenode *nnode,*node = i;
  2783. - 
  2784. -    if (!i)
  2785. -        return NULL;
  2786. -    nnode = alloc(sizeof(struct casenode));
  2787. -    nnode->next = dupcase(node->next);
  2788. -    nnode->list = duplist(node->list);
  2789. -    nnode->pat = strdup(node->pat);
  2790. -    return nnode;
  2791. -}
  2792. - 
  2793. -void *dupif(void *i)
  2794. -{
  2795. -struct ifnode *nnode,*node = i;
  2796. - 
  2797. -    if (!i)
  2798. -        return NULL;
  2799. -    nnode = alloc(sizeof(struct ifnode));
  2800. -    nnode->next = dupif(node->next);
  2801. -    nnode->ifl = duplist(node->ifl);
  2802. -    nnode->thenl = duplist(node->thenl);
  2803. -    return nnode;
  2804. -}
  2805. - 
  2806. -void *dupwhile(void *i)
  2807. -{
  2808. -struct whilenode *nnode,*node = i;
  2809. - 
  2810. -    if (!i)
  2811. -        return NULL;
  2812. -    nnode = alloc(sizeof(struct whilenode));
  2813. -    nnode->cond = node->cond;
  2814. -    nnode->cont = duplist(node->cont);
  2815. -    nnode->loop = duplist(node->loop);
  2816. -    return nnode;
  2817. -}
  2818. -
  2819. -void *duprepeat(void *i)
  2820. -{
  2821. -struct repeatnode *nnode,*node = i;
  2822. -
  2823. -    if (!i)
  2824. -        return NULL;
  2825. -    nnode = alloc(sizeof(struct repeatnode));
  2826. -    nnode->count = node->count;
  2827. -    nnode->list = duplist(node->list);
  2828. -    return nnode;
  2829. -}    
  2830. -
  2831. -table duptable(table tab,void *(*func)(void *))
  2832. -{
  2833. -table ret;
  2834. -Node node;
  2835. -
  2836. -    ret = newtable();
  2837. -    for (node = tab->first; node; node = node->next)
  2838. -        addnode(ret,func(node->dat));
  2839. -    return ret;
  2840. -}
  2841. End of loop.c
  2842. echo loop.pro 1>&2
  2843. sed 's/^-//' >loop.pro <<'End of loop.pro'
  2844. -int parfor(comm comm,int isfor);
  2845. -int parcase(comm comm);
  2846. -char *getcasepat(void);
  2847. -int parif(comm comm);
  2848. -int parwhile(comm comm,int cond);
  2849. -int parrepeat(comm comm);
  2850. -void execfor(comm comm);
  2851. -void execselect(comm comm);
  2852. -void execwhile(comm comm);
  2853. -void execrepeat(comm comm);
  2854. -void execif(comm comm);
  2855. -void execcase(comm comm);
  2856. -list duplist(list xlist);
  2857. -void freelist(list xlist);
  2858. -list2 duplist2(list2 x);
  2859. -void freelist2(list2 x);
  2860. -pline duppline(pline xpline);
  2861. -void freepline(pline x);
  2862. -comm dupcomm(comm xcomm);
  2863. -void freecmd(comm x);
  2864. -void *dupstr(void *str);
  2865. -void *dupfnode(void *i);
  2866. -void *dupfor(void *i);
  2867. -void *dupcase(void *i);
  2868. -void *dupif(void *i);
  2869. -void *dupwhile(void *i);
  2870. -void *duprepeat(void *i);
  2871. -table duptable(table tab,void *(*func)(void *));
  2872. End of loop.pro
  2873. echo math.c 1>&2
  2874. sed 's/^-//' >math.c <<'End of math.c'
  2875. -/*
  2876. -
  2877. -    math.c - evaluating arithmetic expressions
  2878. -
  2879. -    This file is part of zsh, the Z shell.
  2880. -
  2881. -   zsh is free software; no one can prevent you from reading the source
  2882. -   code, or giving it to someone else.
  2883. -   This file is copyrighted under the GNU General Public License, which
  2884. -   can be found in the file called COPYING.
  2885. -
  2886. -   Copyright (C) 1990 Paul Falstad
  2887. -
  2888. -   zsh is distributed in the hope that it will be useful, but
  2889. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  2890. -   responsibility to anyone for the consequences of using it or for
  2891. -   whether it serves any particular purpose or works at all, unless he
  2892. -   says so in writing.  Refer to the GNU General Public License
  2893. -   for full details.
  2894. -
  2895. -   Everyone is granted permission to copy, modify and redistribute
  2896. -   zsh, but only under the conditions described in the GNU General Public
  2897. -   License.   A copy of this license is supposed to have been given to you
  2898. -   along with zsh so you can know your rights and responsibilities.
  2899. -   It should be in a file named COPYING.
  2900. -
  2901. -   Among other things, the copyright notice and this notice must be
  2902. -   preserved on all copies.
  2903. -
  2904. -*/
  2905. -
  2906. -#include <stdio.h>
  2907. -#include <ctype.h>
  2908. -#include <string.h>
  2909. -#include <math.h>
  2910. -#include <assert.h>
  2911. -
  2912. -extern int errflag;
  2913. -extern char *setiparm(char *,long,int);
  2914. -extern long getiparm(char *);
  2915. -extern void zerr(char *,...);
  2916. -extern char *strdup(char *);
  2917. -
  2918. -char *ptr;
  2919. -
  2920. -typedef int LV;
  2921. -
  2922. -long yyval;
  2923. -LV yylval;
  2924. -
  2925. -/* nonzero means we are not evaluating, just parsing */
  2926. -
  2927. -int noeval = 0;
  2928. -
  2929. -/* != 0 means recognize unary plus, minus, etc.
  2930. -    The parser was originally written in lex, hence the name. */
  2931. -
  2932. -int initial = 1;
  2933. -
  2934. -void mathparse(int);
  2935. -
  2936. -/* LR = left-to-right associativity
  2937. -    RL = right-to-left associativity
  2938. -    BOO = short-circuiting boolean */
  2939. -
  2940. -enum xtyp { LR,RL,BOO };
  2941. -
  2942. -enum xtok {
  2943. -INPAR, OUTPAR, NOT, COMP, POSTPLUS,
  2944. -POSTMINUS, UPLUS, UMINUS, AND, XOR,
  2945. -OR, MUL, DIV, MOD, PLUS,
  2946. -MINUS, SHLEFT, SHRIGHT, LES, LEQ,
  2947. -GRE, GEQ, DEQ, NEQ, DAND,
  2948. -DOR, DXOR, QUEST, COLON, EQ,
  2949. -PLUSEQ, MINUSEQ, MULEQ, DIVEQ, MODEQ,
  2950. -ANDEQ, XOREQ, OREQ, SHLEFTEQ, SHRIGHTEQ,
  2951. -DANDEQ, DOREQ, DXOREQ, COMMA, EOI,
  2952. -PREPLUS, PREMINUS, NUM, ID, TOKCOUNT
  2953. -};
  2954. -
  2955. -/* precedences */
  2956. -
  2957. -int prec[TOKCOUNT] = {
  2958. -1,200,2,2,2,
  2959. -2,2,2,3,4,
  2960. -5,6,6,6,7,
  2961. -7,8,8,9,9,
  2962. -9,9,10,10,11,
  2963. -12,12,13,13,14,
  2964. -14,14,14,14,14,
  2965. -14,14,14,14,14,
  2966. -14,14,14,15,200,
  2967. -2,2,0,0,
  2968. -};
  2969. -
  2970. -#define TOPPREC 15
  2971. -
  2972. -int type[TOKCOUNT] = {
  2973. -LR,LR,RL,RL,RL,
  2974. -RL,RL,RL,LR,LR,
  2975. -LR,LR,LR,LR,LR,
  2976. -LR,LR,LR,LR,LR,
  2977. -LR,LR,LR,LR,BOO,
  2978. -BOO,LR,RL,RL,RL,
  2979. -RL,RL,RL,RL,RL,
  2980. -RL,RL,RL,RL,RL,
  2981. -BOO,BOO,RL,RL,RL,
  2982. -RL,RL,LR,LR,
  2983. -};
  2984. -
  2985. -#define LVCOUNT 32
  2986. -
  2987. -/* table of lvalues (variables) */
  2988. -
  2989. -int lvc;
  2990. -char *lvals[LVCOUNT];
  2991. -
  2992. -int yylex(void)
  2993. -{
  2994. -    for(;;)
  2995. -        switch (*ptr++)
  2996. -            {
  2997. -            case '+':
  2998. -                if (*ptr == '+' && (initial || !isalnum(*ptr)))
  2999. -                    {
  3000. -                    ptr++;
  3001. -                    return (initial) ? PREPLUS : POSTPLUS;
  3002. -                    }
  3003. -                if (*ptr == '=') { initial = 1; ptr++; return PLUSEQ; }
  3004. -                return (initial) ? UPLUS : PLUS;
  3005. -            case '-':
  3006. -                if (*ptr == '-' && (initial || !isalnum(*ptr)))
  3007. -                    {
  3008. -                    ptr++;
  3009. -                    return (initial) ? PREMINUS : POSTMINUS;
  3010. -                    }
  3011. -                if (*ptr == '=') { initial = 1; ptr++; return MINUSEQ; }
  3012. -                return (initial) ? UMINUS : MINUS;
  3013. -            case '(': initial = 1; return INPAR;
  3014. -            case ')': return OUTPAR;
  3015. -            case '!': if (*ptr == '=')
  3016. -                        { initial = 1; ptr++; return NEQ; }
  3017. -                        return NOT;
  3018. -            case '~': return COMP;
  3019. -            case '&': initial = 1;
  3020. -                if (*ptr == '&') { if (*++ptr == '=')
  3021. -                { ptr++; return DANDEQ; } return DAND; }
  3022. -                else if (*ptr == '=') { ptr++; return ANDEQ; } return AND;
  3023. -            case '|': initial = 1;
  3024. -                if (*ptr == '|') { if (*++ptr == '=')
  3025. -                { ptr++; return DOREQ; } return DOR; }
  3026. -                else if (*ptr == '=') { ptr++; return OREQ; } return OR;
  3027. -            case '^': initial = 1;
  3028. -                if (*ptr == '^') { if (*++ptr == '=')
  3029. -                { ptr++; return DXOREQ; } return DXOR; }
  3030. -                else if (*ptr == '=') { ptr++; return XOREQ; } return XOR;
  3031. -            case '*': initial = 1;
  3032. -                if (*ptr == '=') { ptr++; return MULEQ; } return MUL;
  3033. -            case '/': initial = 1;
  3034. -                if (*ptr == '=') { ptr++; return DIVEQ; } return DIV;
  3035. -            case '%': initial = 1;
  3036. -                if (*ptr == '=') { ptr++; return MODEQ; } return MOD;
  3037. -            case '<': initial = 1; if (*ptr == '<')
  3038. -                { if (*++ptr == '=') { ptr++; return SHLEFTEQ; } return SHLEFT; }
  3039. -                else if (*ptr == '=') { ptr++; return LEQ; } return LES;
  3040. -            case '>': initial = 1; if (*ptr == '>')
  3041. -                { if (*++ptr == '=') { ptr++; return SHRIGHTEQ; } return SHRIGHT; }
  3042. -                else if (*ptr == '=') { ptr++; return GEQ; } return GRE;
  3043. -            case '=': initial = 1; if (*ptr == '=') { ptr++; return DEQ; }
  3044. -                return EQ;
  3045. -            case '?': initial = 1; return QUEST;
  3046. -            case ':': initial = 1; return COLON;
  3047. -            case ',': initial = 1; return COMMA;
  3048. -            case '\0': initial = 1; ptr--; return EOI;
  3049. -            case '[': initial = 0;
  3050. -                { int base = strtol(ptr,&ptr,10);
  3051. -                    yyval = strtol(ptr+1,&ptr,base); return NUM; }
  3052. -            case ' ': case '\t':
  3053. -                break;
  3054. -            default:
  3055. -                if (isdigit(*--ptr))
  3056. -                    { initial = 0; yyval = strtol(ptr,&ptr,10); return NUM; }
  3057. -                if (isalpha(*ptr) || *ptr == '$')
  3058. -                    {
  3059. -                    char *p,q;
  3060. -
  3061. -                    if (*ptr == '$')
  3062. -                        ptr++;
  3063. -                    p = ptr;
  3064. -                    if (lvc == LVCOUNT)
  3065. -                        {
  3066. -                        zerr("too many identifiers in expression");
  3067. -                        errflag = 1;
  3068. -                        return EOI;
  3069. -                        }
  3070. -                    initial = 0;
  3071. -                    while(isalpha(*++ptr));
  3072. -                    q = *ptr;
  3073. -                    *ptr = '\0';
  3074. -                    lvals[yylval = lvc++] = strdup(p);
  3075. -                    *ptr = q;
  3076. -                    return ID;
  3077. -                    }
  3078. -                zerr("illegal character: %c",*ptr);
  3079. -                errflag = 1;
  3080. -                return EOI;
  3081. -            }
  3082. -}
  3083. -
  3084. -/* the value stack */
  3085. -
  3086. -#define STACKSZ 1000
  3087. -int tok;            /* last token */
  3088. -int sp = -1;    /* stack pointer */
  3089. -struct value {
  3090. -    LV lval;
  3091. -    long val;
  3092. -    } stack[STACKSZ];
  3093. -
  3094. -void push(long val,LV lval)
  3095. -{
  3096. -    sp++;
  3097. -    stack[sp].val = val;
  3098. -    stack[sp].lval = lval;
  3099. -}
  3100. -
  3101. -long getvar(LV s)
  3102. -{
  3103. -long t;
  3104. -
  3105. -    if (!(t = getiparm(lvals[s])))
  3106. -        return 0;
  3107. -    return t;
  3108. -}
  3109. -
  3110. -long setvar(LV s,long v)
  3111. -{
  3112. -    if (s == -1)
  3113. -        {
  3114. -        zerr("lvalue required");
  3115. -        errflag = 1;
  3116. -        return 0;
  3117. -        }
  3118. -    if (noeval)
  3119. -        return v;
  3120. -    setiparm(strdup(lvals[s]),v,0);
  3121. -    return v;
  3122. -}
  3123. -
  3124. -int notzero(int a)
  3125. -{
  3126. -    if (a == 0)
  3127. -        {
  3128. -        errflag = 1;
  3129. -        zerr("division by zero");
  3130. -        return 0;
  3131. -        }
  3132. -    return 1;
  3133. -}
  3134. -
  3135. -#define pop2() { b = stack[sp--].val; a = stack[sp--].val; }
  3136. -#define pop3() {c=stack[sp--].val;b=stack[sp--].val;a=stack[sp--].val;}
  3137. -#define nolval() {stack[sp].lval=-1;}
  3138. -#define pushv(X) { push(X,-1); }
  3139. -#define pop2lv() { pop2() lv = stack[sp+1].lval; }
  3140. -#define set(X) { push(setvar(lv,X),lv); }
  3141. -
  3142. -void op(int what)
  3143. -{
  3144. -long a,b,c;
  3145. -LV lv;
  3146. -
  3147. -    switch(what) {
  3148. -        case NOT: stack[sp].val = !stack[sp].val; nolval(); break;
  3149. -        case COMP: stack[sp].val = ~stack[sp].val; nolval(); break;
  3150. -        case POSTPLUS: (void) setvar(stack[sp].lval,stack[sp].val+1); break;
  3151. -        case POSTMINUS: (void) setvar(stack[sp].lval,stack[sp].val-1); break;
  3152. -        case UPLUS: nolval(); break;
  3153. -        case UMINUS: stack[sp].val = -stack[sp].val; nolval(); break;
  3154. -        case AND: pop2(); pushv(a&b); break;
  3155. -        case XOR: pop2(); pushv(a^b); break;
  3156. -        case OR: pop2(); pushv(a|b); break;
  3157. -        case MUL: pop2(); pushv(a*b); break;
  3158. -        case DIV: pop2(); if (notzero(b)) pushv(a/b); break;
  3159. -        case MOD: pop2(); if (notzero(b)) pushv(a%b); break;
  3160. -        case PLUS: pop2(); pushv(a+b); break;
  3161. -        case MINUS: pop2(); pushv(a-b); break;
  3162. -        case SHLEFT: pop2(); pushv(a<<b); break;
  3163. -        case SHRIGHT: pop2(); pushv(a>>b); break;
  3164. -        case LES: pop2(); pushv(a<b); break;
  3165. -        case LEQ: pop2(); pushv(a<=b); break;
  3166. -        case GRE: pop2(); pushv(a>b); break;
  3167. -        case GEQ: pop2(); pushv(a>=b); break;
  3168. -        case DEQ: pop2(); pushv(a==b); break;
  3169. -        case NEQ: pop2(); pushv(a!=b); break;
  3170. -        case DAND: pop2(); pushv(a&&b); break;
  3171. -        case DOR: pop2(); pushv(a||b); break;
  3172. -        case DXOR: pop2(); pushv(a&&!b||!a&&b); break;
  3173. -        case QUEST: pop3(); pushv((a)?b:c); break;
  3174. -        case COLON: break;
  3175. -        case EQ: pop2lv(); set(b); break;
  3176. -        case PLUSEQ: pop2lv(); set(a+b); break;
  3177. -        case MINUSEQ: pop2lv(); set(a-b); break;
  3178. -        case MULEQ: pop2lv(); set(a*b); break;
  3179. -        case DIVEQ: pop2lv(); if (notzero(b)) set(a/b); break;
  3180. -        case MODEQ: pop2lv(); if (notzero(b)) set(a%b); break;
  3181. -        case ANDEQ: pop2lv(); set(a&b); break;
  3182. -        case XOREQ: pop2lv(); set(a^b); break;
  3183. -        case OREQ: pop2lv(); set(a|b); break;
  3184. -        case SHLEFTEQ: pop2lv(); set(a<<b); break;
  3185. -        case SHRIGHTEQ: pop2lv(); set(a>>b); break;
  3186. -        case DANDEQ: pop2lv(); set(a&&b); break;
  3187. -        case DOREQ: pop2lv(); set(a||b); break;
  3188. -        case DXOREQ: pop2lv(); set(a&&!b||!a&&b); break;
  3189. -        case COMMA: pop2(); pushv(b); break;
  3190. -        case PREPLUS: stack[sp].val = setvar(stack[sp].lval,
  3191. -            stack[sp].val+1); break;
  3192. -        case PREMINUS: stack[sp].val = setvar(stack[sp].lval,
  3193. -            stack[sp].val-1); break;
  3194. -        default: fprintf(stderr,"whoops.\n"); exit(1);
  3195. -    }
  3196. -}
  3197. -
  3198. -void bop(int tok)
  3199. -{
  3200. -    switch (tok) {
  3201. -        case DAND: case DANDEQ: if (!stack[sp].val) noeval++; break;
  3202. -        case DOR: case DOREQ: if (stack[sp].val) noeval++; break;
  3203. -        };
  3204. -}
  3205. -
  3206. -long matheval(char *s)
  3207. -{
  3208. -int t0;
  3209. -
  3210. -    for (t0 = 0; t0 != LVCOUNT; t0++)
  3211. -        lvals[t0] = NULL;
  3212. -    lvc = 0;
  3213. -    ptr = s;
  3214. -    sp = -1;
  3215. -    mathparse(TOPPREC);
  3216. -    if (!errflag && sp)
  3217. -        zerr("arithmetic error: unbalanced stack");
  3218. -    for (t0 = 0; t0 != lvc; t0++)
  3219. -        free(lvals[t0]);
  3220. -    return stack[0].val;
  3221. -}
  3222. -
  3223. -/* operator-precedence parse the string and execute */
  3224. -
  3225. -void mathparse(int pc)
  3226. -{
  3227. -    if (errflag)
  3228. -        return;
  3229. -    tok = yylex();
  3230. -    while (prec[tok] <= pc)
  3231. -        {
  3232. -        if (errflag)
  3233. -            return;
  3234. -        if (tok == NUM)
  3235. -            push(yyval,-1);
  3236. -        else if (tok == ID)
  3237. -            push(getvar(yylval),yylval);
  3238. -        else if (tok == INPAR)
  3239. -            {
  3240. -            mathparse(TOPPREC);
  3241. -            if (tok != OUTPAR)
  3242. -                exit(1);
  3243. -            }
  3244. -        else if (tok == QUEST)
  3245. -            {
  3246. -            int q = stack[sp].val;
  3247. -            if (!q) noeval++;
  3248. -            mathparse(prec[QUEST]-1);
  3249. -            if (!q) noeval--; else noeval++;
  3250. -            mathparse(prec[QUEST]);
  3251. -            if (q) noeval--;
  3252. -            op(QUEST);
  3253. -            continue;
  3254. -            }
  3255. -        else
  3256. -            {
  3257. -            int otok = tok,onoeval = noeval;
  3258. -
  3259. -            if (type[otok] == BOO)
  3260. -                bop(otok);
  3261. -            mathparse(prec[otok]-(type[otok] != RL));
  3262. -            noeval = onoeval;
  3263. -            op(otok);
  3264. -            continue;
  3265. -            }
  3266. -        tok = yylex();
  3267. -        }
  3268. -}
  3269. -
  3270. End of math.c
  3271. echo math.pro 1>&2
  3272. sed 's/^-//' >math.pro <<'End of math.pro'
  3273. -INPAR, OUTPAR, NOT, COMP, POSTPLUS,;
  3274. -POSTMINUS, UPLUS, UMINUS, AND, XOR,;
  3275. -OR, MUL, DIV, MOD, PLUS,;
  3276. -MINUS, SHLEFT, SHRIGHT, LES, LEQ,;
  3277. -GRE, GEQ, DEQ, NEQ, DAND,;
  3278. -DOR, DXOR, QUEST, COLON, EQ,;
  3279. -PLUSEQ, MINUSEQ, MULEQ, DIVEQ, MODEQ,;
  3280. -ANDEQ, XOREQ, OREQ, SHLEFTEQ, SHRIGHTEQ,;
  3281. -DANDEQ, DOREQ, DXOREQ, COMMA, EOI,;
  3282. -PREPLUS, PREMINUS, NUM, ID, TOKCOUNT;
  3283. -LR,LR,RL,RL,RL,;
  3284. -RL,RL,RL,LR,LR,;
  3285. -LR,LR,LR,LR,LR,;
  3286. -LR,LR,LR,LR,LR,;
  3287. -LR,LR,LR,LR,BOO,;
  3288. -BOO,LR,RL,RL,RL,;
  3289. -RL,RL,RL,RL,RL,;
  3290. -RL,RL,RL,RL,RL,;
  3291. -BOO,BOO,RL,RL,RL,;
  3292. -RL,RL,LR,LR,;
  3293. -int yylex(void);
  3294. -void push(long val,LV lval);
  3295. -long getvar(LV s);
  3296. -long setvar(LV s,long v);
  3297. -int notzero(int a);
  3298. -void op(int what);
  3299. -void bop(int tok);
  3300. -long matheval(char *s);
  3301. -void mathparse(int pc);
  3302. End of math.pro
  3303. echo parse.c 1>&2
  3304. sed 's/^-//' >parse.c <<'End of parse.c'
  3305. -/*
  3306. -
  3307. -    parse.c - parsing
  3308. -
  3309. -    This file is part of zsh, the Z shell.
  3310. -
  3311. -   zsh is free software; no one can prevent you from reading the source
  3312. -   code, or giving it to someone else.
  3313. -   This file is copyrighted under the GNU General Public License, which
  3314. -   can be found in the file called COPYING.
  3315. -
  3316. -   Copyright (C) 1990 Paul Falstad
  3317. -
  3318. -   zsh is distributed in the hope that it will be useful, but
  3319. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  3320. -   responsibility to anyone for the consequences of using it or for
  3321. -   whether it serves any particular purpose or works at all, unless he
  3322. -   says so in writing.  Refer to the GNU General Public License
  3323. -   for full details.
  3324. -
  3325. -   Everyone is granted permission to copy, modify and redistribute
  3326. -   zsh, but only under the conditions described in the GNU General Public
  3327. -   License.   A copy of this license is supposed to have been given to you
  3328. -   along with zsh so you can know your rights and responsibilities.
  3329. -   It should be in a file named COPYING.
  3330. -
  3331. -   Among other things, the copyright notice and this notice must be
  3332. -   preserved on all copies.
  3333. -
  3334. -*/
  3335. -
  3336. -#include "zsh.h"
  3337. -#include "funcs.h"
  3338. -
  3339. -/* parse a list, but return : instead of NULL */
  3340. -
  3341. -list parlist(int nest)
  3342. -{
  3343. -list l1;
  3344. -list2 l2;
  3345. -pline p;
  3346. -comm c;
  3347. -
  3348. -    if (l1 = parlist1(nest))
  3349. -        return l1;
  3350. -    if (errflag)
  3351. -        return NULL;
  3352. -    c = alloc(sizeof *c);
  3353. -    c->cmd = strdup("");
  3354. -    c->args = newtable();
  3355. -    c->redir = newtable();
  3356. -    c->type = SIMPLE;
  3357. -    p = alloc(sizeof *p);
  3358. -    p->left = c;
  3359. -    p->type = END;
  3360. -    l2 = alloc(sizeof *l2);
  3361. -    l2->left = p;
  3362. -    l2->type = END;
  3363. -    l1 = alloc(sizeof *l1);
  3364. -    l1->left = l2;
  3365. -    l1->type = SYNC;
  3366. -    return l1;
  3367. -}
  3368. -
  3369. -/* parse a list */
  3370. -
  3371. -list parlist1(int nest)
  3372. -{
  3373. -list l1 = (list) alloc(sizeof *l1);
  3374. -int isnl;
  3375. -
  3376. -    incmd = 0;
  3377. -    if (peek == EMPTY)
  3378. -        matchit();
  3379. -    if (nest)
  3380. -        while (peek == NEWLIN || peek == SEMI)
  3381. -            matchit();
  3382. -    if (!(l1->left = parlist2()))
  3383. -        {
  3384. -        free(l1);
  3385. -        return NULL;
  3386. -        }
  3387. -    l1->type = (peek == AMPER) ? ASYNC : SYNC;
  3388. -    if ((isnl = peek == NEWLIN) || peek == SEMI || peek == AMPER)
  3389. -        peek = EMPTY;
  3390. -    if ((nest || !isnl) && peek == EMPTY)
  3391. -        {
  3392. -        if (!(l1->right = parlist1(nest)))
  3393. -            {
  3394. -            if (!errflag)
  3395. -                {
  3396. -                if (peek == NEWLIN)
  3397. -                    peek = EMPTY;
  3398. -                return l1;
  3399. -                }
  3400. -            freelist2(l1->left);
  3401. -            free(l1);
  3402. -            return NULL;
  3403. -            }
  3404. -        }
  3405. -    else
  3406. -        l1->right = NULL;
  3407. -    return l1;
  3408. -}
  3409. -
  3410. -/* parse a sublist */
  3411. -
  3412. -list2 parlist2(void)
  3413. ---cut here---cut here---cut here---
  3414.