home *** CD-ROM | disk | FTP | other *** search
/ Source Code 1992 March / Source_Code_CD-ROM_Walnut_Creek_March_1992.iso / usenet / altsrcs / 2 / 2324 < prev    next >
Encoding:
Internet Message Format  |  1990-12-28  |  63.3 KB
  1. From: pfalstad@phoenix.Princeton.EDU (Paul John Falstad)
  2. Newsgroups: alt.sources
  3. Subject: zsh - ksh/tcsh-like shell (part 5 of 8)
  4. Message-ID: <4746@idunno.Princeton.EDU>
  5. Date: 14 Dec 90 23:32:05 GMT
  6.  
  7. ---cut here---cut here---cut here---
  8. -{
  9. -list2 l2 = (list2) alloc(sizeof *l2);
  10. -int iter = 0;
  11. -
  12. -    for (;;)
  13. -        {
  14. -        if (peek == BANG)
  15. -            {
  16. -            l2->flags |= PFLAG_NOT;
  17. -            matchit();
  18. -            }
  19. -        else if (peek == TIME)
  20. -            {
  21. -            l2->flags |= PFLAG_TIMED;
  22. -            matchit();
  23. -            }
  24. -        else if (peek == COPROC)
  25. -            {
  26. -            l2->flags |= PFLAG_COPROC;
  27. -            matchit();
  28. -            }
  29. -        else
  30. -            break;
  31. -        iter = 1;
  32. -        }
  33. -    if (!(l2->left = parpline()))
  34. -        {
  35. -        free(l2);
  36. -        if (!errflag && iter)
  37. -            {
  38. -            zerr("parse error: pipeline expected");
  39. -            errflag = 1;
  40. -            }
  41. -        return NULL;
  42. -        }
  43. -    if (peek == DAMPER || peek == DBAR)
  44. -        {
  45. -        l2->type = (peek == DAMPER) ? ANDNEXT : ORNEXT;
  46. -        matchit();
  47. -        while (peek == NEWLIN)
  48. -            matchit();
  49. -        if (!(l2->right = parlist2()))
  50. -            {
  51. -            if (!errflag)
  52. -                {
  53. -                zerr("invalid null command");
  54. -                errflag = 1;
  55. -                }
  56. -            freepline(l2->left);
  57. -            free(l2);
  58. -            return NULL;
  59. -            }
  60. -        }
  61. -    else
  62. -        {
  63. -        l2->type = END;
  64. -        l2->right = NULL;
  65. -        }
  66. -    return l2;
  67. -}
  68. -
  69. -/* parse a pipeline */
  70. -
  71. -pline parpline(void)
  72. -{
  73. -pline p = (pline) alloc(sizeof *p);
  74. -
  75. -    if (!(p->left = parcmd()))
  76. -        {
  77. -        free(p);
  78. -        return NULL;
  79. -        }
  80. -    if (peek == HERR)
  81. -        {
  82. -        freecmd(p->left);
  83. -        free(p);
  84. -        return NULL;
  85. -        }
  86. -    if (peek == BAR || peek == BARAMP)
  87. -        {
  88. -        if (peek == BARAMP)
  89. -            {
  90. -            struct fnode *f;
  91. -
  92. -            f = alloc(sizeof *f);
  93. -            f->type = MERGEOUT;
  94. -            f->fd1 = 2;
  95. -            f->u.fd2 = 1;
  96. -            addnode(p->left->redir,f);
  97. -            }
  98. -        matchit();
  99. -        while (peek == NEWLIN)
  100. -            matchit();
  101. -        p->type = PIPE;
  102. -        if (!(p->right = parpline()))
  103. -            {
  104. -            if (!errflag)
  105. -                {
  106. -                zerr("invalid null command");
  107. -                errflag = 1;
  108. -                }
  109. -            freecmd(p->left);
  110. -            free(p);
  111. -            return NULL;
  112. -            }
  113. -        }
  114. -    else
  115. -        {
  116. -        p->type = END;
  117. -        p->right = NULL;
  118. -        }
  119. -    return p;
  120. -}
  121. -
  122. -/* parse a command */
  123. -
  124. -comm parcmd(void)
  125. -{
  126. -comm c = (comm) alloc(sizeof *c);
  127. -list l;
  128. -char *str;
  129. -int flag,iter = 0;
  130. -
  131. -    incmd = 0;
  132. -    c->left = NULL;
  133. -    c->cmd = NULL;
  134. -    c->args = newtable();
  135. -    c->redir = newtable();
  136. -    c->type = SIMPLE;
  137. -    c->vars = NULL;
  138. -    if (peek == EOF)
  139. -        return NULL;
  140. -foo:
  141. -    switch (peek)
  142. -        {
  143. -        case HERR:
  144. -            return NULL;
  145. -        case ENVSTRING:
  146. -            if (!c->vars)
  147. -                c->vars = newtable(); /* FIX */
  148. -            for (str = tstr; *str != '='; str++);
  149. -            *str++ = '\0';
  150. -            addnode(c->vars,tstr);
  151. -            addnode(c->vars,strdup(str));
  152. -            matchit();
  153. -            goto foo;
  154. -        case FOR:
  155. -            incmd = 1;
  156. -            matchit();
  157. -            if (parfor(c,1))
  158. -                return NULL;
  159. -            break;
  160. -        case SELECT:
  161. -            incmd = 1;
  162. -            matchit();
  163. -            if (parfor(c,0))
  164. -                return NULL;
  165. -            break;
  166. -        case CASE:
  167. -            incmd = 1;
  168. -            matchit();
  169. -            if (parcase(c))
  170. -                return NULL;
  171. -            break;
  172. -        case IF:
  173. -            matchit();
  174. -            if (parif(c))
  175. -                return NULL;
  176. -            break;
  177. -        case WHILE:
  178. -            matchit();
  179. -            if (parwhile(c,0))
  180. -                return NULL;
  181. -            break;
  182. -        case UNTIL:
  183. -            matchit();
  184. -            if (parwhile(c,1))
  185. -                return NULL;
  186. -            break;
  187. -        case REPEAT:
  188. -            incmd = 1;
  189. -            matchit();
  190. -            if (parrepeat(c))
  191. -                return NULL;
  192. -            break;
  193. -        case INPAR:
  194. -            matchit();
  195. -            c->type = SUBSH;
  196. -            if (!(c->left = parlist(1)))
  197. -                {
  198. -                freecmd(c);
  199. -                return NULL;
  200. -                }
  201. -            if (peek != OUTPAR)
  202. -                {
  203. -                freecmd(c);
  204. -                zerr("parse error: '}' expected");
  205. -                return NULL;
  206. -                }
  207. -            matchit();
  208. -            break;
  209. -        case INBRACE:
  210. -            matchit();
  211. -            c->type = CURSH;
  212. -            if (!(c->left = parlist(1)))
  213. -                {
  214. -                freecmd(c);
  215. -                return NULL;
  216. -                }
  217. -            if (peek != OUTBRACE)
  218. -                {
  219. -                freecmd(c);
  220. -                zerr("parse error: '}' expected");
  221. -                return NULL;
  222. -                }
  223. -            matchit();
  224. -            break;
  225. -        case FUNC:
  226. -            matchit();
  227. -            str = tstr;
  228. -            if (peek != STRING && peek != ENVSTRING)
  229. -                {
  230. -                c->cmd = strdup("function");
  231. -                incmd = 1;
  232. -                if (isredir())
  233. -                    goto jump1;
  234. -                else
  235. -                    goto jump2;
  236. -                }
  237. -            do    
  238. -                matchit();
  239. -            while (peek == NEWLIN);
  240. -            if (peek != INBRACE)
  241. -                {
  242. -                freecmd(c);
  243. -                zerr("parse error: '{' expected");
  244. -                return NULL;
  245. -                }
  246. -            matchit();
  247. -            flag = peek == OUTBRACE;
  248. -            if (!(l = parlist(1)))
  249. -                {
  250. -                freecmd(c);
  251. -                return NULL;
  252. -                }
  253. -            if (peek != OUTBRACE)
  254. -                {
  255. -                freelist(l);
  256. -                freecmd(c);
  257. -                zerr("parse error: '}' expected");
  258. -                return NULL;
  259. -                }
  260. -            matchit();
  261. -            settrap(str,flag);
  262. -            addhnode(str,l,shfunchtab,freeshfunc);
  263. -            c->cmd = strdup("");
  264. -            c->type = SIMPLE;
  265. -            break;
  266. -        case EXEC:
  267. -            c->flags |= CFLAG_EXEC;
  268. -            matchit();
  269. -            iter = 1;
  270. -            goto foo;
  271. -        case COMMAND:
  272. -            c->flags |= CFLAG_COMMAND;
  273. -            matchit();
  274. -            iter = 1;
  275. -            goto foo;
  276. -        default:
  277. -jump1:
  278. -            if (isredir())
  279. -                {
  280. -                if (parredir(c))
  281. -                    {
  282. -                    freecmd(c);
  283. -                    return NULL;
  284. -                    }
  285. -                goto foo;
  286. -                }
  287. -            if (!(peek == STRING || peek == ENVSTRING))
  288. -                {
  289. -                if (full(c->redir))
  290. -                    {
  291. -                    c->cmd = strdup("cat");
  292. -                    return c;
  293. -                    }
  294. -                if (c->vars)
  295. -                    {
  296. -                    c->cmd = strdup("");
  297. -                    return c;
  298. -                    }
  299. -                free(c->args);
  300. -                free(c->redir);
  301. -                free(c);
  302. -                if (iter && !errflag)
  303. -                    {
  304. -                    errflag = 1;
  305. -                    zerr("parse error: command expected");
  306. -                    }
  307. -                return NULL;
  308. -                }
  309. -jump2:
  310. -            while (peek == STRING || peek == ENVSTRING || isredir())
  311. -                if (isredir())
  312. -                    {
  313. -                    if (parredir(c))
  314. -                        {
  315. -                        freecmd(c);
  316. -                        return NULL;
  317. -                        }
  318. -                    }
  319. -                else
  320. -                    {
  321. -                    if (tstr[0] == Inpar && tstr[1] == Outpar && !tstr[2])
  322. -                        {
  323. -                        free(tstr);
  324. -                        incmd = 0;
  325. -                        matchit();
  326. -                        if (full(c->args))
  327. -                            {
  328. -                            zerr("illegal function definition");
  329. -                            freecmd(c);
  330. -                            return NULL;
  331. -                            }
  332. -                        while (peek == NEWLIN)
  333. -                            matchit();
  334. -                        if (peek != INBRACE)
  335. -                            {
  336. -                            freecmd(c);
  337. -                            zerr("parse error: '{' expected");
  338. -                            return NULL;
  339. -                            }
  340. -                        matchit();
  341. -                        flag = peek == OUTBRACE;
  342. -                        if (!(l = parlist(1)))
  343. -                            {
  344. -                            freecmd(c);
  345. -                            return NULL;
  346. -                            }
  347. -                        if (peek != OUTBRACE)
  348. -                            {
  349. -                            freelist(l);
  350. -                            freecmd(c);
  351. -                            zerr("parse error: '}' expected");
  352. -                            return NULL;
  353. -                            }
  354. -                        matchit();
  355. -                        settrap(c->cmd,flag);
  356. -                        addhnode(c->cmd,l,shfunchtab,freeshfunc);
  357. -                        c->cmd = strdup("");
  358. -                        c->type = SIMPLE;
  359. -                        incmd = 0;
  360. -                        return c;
  361. -                        }
  362. -                    if (peek == ENVSTRING && (!incmd || opts[KEYWORD] == OPT_SET))
  363. -                        {
  364. -                        if (!c->vars)
  365. -                            c->vars = newtable(); /* FIX */
  366. -                        for (str = tstr; *str != '='; str++);
  367. -                        *str++ = '\0';
  368. -                        addnode(c->vars,tstr);
  369. -                        addnode(c->vars,strdup(str));
  370. -                        }
  371. -                    else if (c->cmd)
  372. -                        addnode(c->args,tstr);
  373. -                    else
  374. -                        {
  375. -                        c->cmd = tstr;
  376. -                        incmd = 1;
  377. -                        }
  378. -                    matchit();
  379. -                    }
  380. -            break;
  381. -        }
  382. -    while (isredir())
  383. -        if (parredir(c))
  384. -            {
  385. -            freecmd(c);
  386. -            return NULL;
  387. -            }
  388. -    incmd = 0;
  389. -    if (peek == HERR)
  390. -        {
  391. -        freecmd(c);
  392. -        return NULL;
  393. -        }
  394. -    return c;
  395. -}
  396. -
  397. -/* != 0 if peek is a redirection operator */
  398. -
  399. -int isredir(void)
  400. -{
  401. -    return (peek >= OUTANG && peek <= DOUTANGAMPBANG);
  402. -}
  403. -
  404. -/* get fd associated with str */
  405. -
  406. -int getfdstr(char *s)
  407. -{
  408. -    if (s[1])
  409. -        return -1;
  410. -    if (isdigit(*s))
  411. -        return *s-'0';
  412. -    if (*s == 'p')
  413. -        return -2;
  414. -    return -1;
  415. -}
  416. -
  417. -int parredir(comm c)
  418. -{
  419. -struct fnode *fn = (struct fnode *) alloc(sizeof *fn);
  420. -int pk = peek,ic = incmd,mrg2 = 0;
  421. -
  422. -    fn->type = peek-OUTANG+WRITE;
  423. -    if (peek == OUTANGAMP)
  424. -        fn->type = MERGEOUT;
  425. -    if (peekfd != -1)
  426. -        fn->fd1 = peekfd;
  427. -    else if (peek <= DOUTANGBANG || peek >= OUTANGAMP)
  428. -        fn->fd1 = 1;
  429. -    else
  430. -        fn->fd1 = 0;
  431. -    incmd = 1;
  432. -    matchit();
  433. -    incmd = ic;
  434. -    if (peek != STRING)
  435. -        {
  436. -        zerr("parse error: filename expected");
  437. -        return 1;
  438. -        }
  439. -    
  440. -    if ((*tstr == Inang || *tstr == Outang) && tstr[1] == Inpar)
  441. -        {
  442. -        if (fn->type == WRITE)
  443. -            fn->type = OUTPIPE;
  444. -        else if (fn->type == READ)
  445. -            fn->type = INPIPE;
  446. -        else
  447. -            {
  448. -            zerr("parse error: bad process redirection");
  449. -            return 1;
  450. -            }
  451. -        fn->u.name = tstr;
  452. -        }
  453. -    else if (fn->type == HEREDOC)
  454. -        fn->u.fd2 = gethere(tstr);
  455. -    else if (pk >= OUTANGAMP && getfdstr(tstr) == -1)
  456. -        {
  457. -        mrg2 = 1;
  458. -        fn->u.name = tstr;
  459. -        fn->type = pk-OUTANGAMP;
  460. -        }
  461. -    else if (pk > OUTANGAMPBANG)
  462. -        {
  463. -        zerr("parse error: filename expected");
  464. -        return 1;
  465. -        }
  466. -    else if (pk == OUTANGAMPBANG)
  467. -        {
  468. -        struct fnode *fe = alloc(sizeof *fe);
  469. -
  470. -        fe->fd1 = fn->fd1;
  471. -        fe->type = CLOSE;
  472. -        addnode(c->redir,fe);
  473. -        fn->u.fd2 = getfdstr(tstr);
  474. -        if (fn->u.fd2 == -2)
  475. -            fn->u.fd2 = spout;
  476. -        fn->type = MERGEOUT;
  477. -        }
  478. -    else if (fn->type == MERGE || fn->type == MERGEOUT)
  479. -        {
  480. -        if (*tstr == '-')
  481. -            fn->type = CLOSE;
  482. -        else
  483. -            {
  484. -            fn->u.fd2 = getfdstr(tstr);
  485. -            if (fn->u.fd2 == -2)
  486. -                fn->u.fd2 = (pk == OUTANGAMP) ? spout : spin;
  487. -            }
  488. -        }
  489. -    else
  490. -        fn->u.name = tstr;
  491. -    addnode(c->redir,fn);
  492. -    if (mrg2)
  493. -        {
  494. -        struct fnode *fe = alloc(sizeof *fe);
  495. -
  496. -        fe->fd1 = 2;
  497. -        fe->u.fd2 = fn->fd1;
  498. -        fe->type = MERGEOUT;
  499. -        addnode(c->redir,fe);
  500. -        }
  501. -    matchit();
  502. -    return 0;
  503. -}
  504. -
  505. End of parse.c
  506. echo parse.pro 1>&2
  507. sed 's/^-//' >parse.pro <<'End of parse.pro'
  508. -list parlist(int nest);
  509. -list parlist1(int nest);
  510. -list2 parlist2(void);
  511. -pline parpline(void);
  512. -comm parcmd(void);
  513. -int isredir(void);
  514. -int getfdstr(char *s);
  515. -int parredir(comm c);
  516. End of parse.pro
  517. echo subst.c 1>&2
  518. sed 's/^-//' >subst.c <<'End of subst.c'
  519. -/*
  520. -
  521. -    subst.c - various substitution
  522. -
  523. -    This file is part of zsh, the Z shell.
  524. -
  525. -   zsh is free software; no one can prevent you from reading the source
  526. -   code, or giving it to someone else.
  527. -   This file is copyrighted under the GNU General Public License, which
  528. -   can be found in the file called COPYING.
  529. -
  530. -   Copyright (C) 1990 Paul Falstad
  531. -
  532. -   zsh is distributed in the hope that it will be useful, but
  533. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  534. -   responsibility to anyone for the consequences of using it or for
  535. -   whether it serves any particular purpose or works at all, unless he
  536. -   says so in writing.  Refer to the GNU General Public License
  537. -   for full details.
  538. -
  539. -   Everyone is granted permission to copy, modify and redistribute
  540. -   zsh, but only under the conditions described in the GNU General Public
  541. -   License.   A copy of this license is supposed to have been given to you
  542. -   along with zsh so you can know your rights and responsibilities.
  543. -   It should be in a file named COPYING.
  544. -
  545. -   Among other things, the copyright notice and this notice must be
  546. -   preserved on all copies.
  547. -
  548. -*/
  549. -
  550. -#include "zsh.h"
  551. -#include "funcs.h"
  552. -#include <pwd.h>
  553. -#define MAXPATHLEN 1024
  554. -
  555. -#define magicerr() { if (magic) putc('\n',stderr); }
  556. -
  557. -/* do substitutions before fork */
  558. -
  559. -void prefork(table list)
  560. -{
  561. -Node node = list->first;
  562. -
  563. -    while (node)
  564. -        {
  565. -        char *str,*str3;
  566. -        
  567. -        str = str3 = node->dat;
  568. -        if (!magic && str[1] == Inpar && (*str == Inang ||
  569. -                *str == Outang || *str == Equals))
  570. -            {
  571. -            if (*str == Inang)
  572. -                node->dat = getoutproc(str+2);        /* <(...) */
  573. -            else if (*str == Equals)
  574. -                node->dat = getoutputfile(str+2);    /* =(...) */
  575. -            else
  576. -                node->dat = getinproc(str+2);            /* >(...) */
  577. -            free(str);
  578. -            if (!node->dat)
  579. -                {
  580. -                zerr("parse error in process substitution");
  581. -                errflag = 1;
  582. -                return;
  583. -                }
  584. -            }
  585. -        else while (*str)
  586. -            {
  587. -            if (*str == String || *str == Qstring)
  588. -                if (str[1] != Inpar)
  589. -                    if (str[1] == '*' || str[1] == Star)
  590. -                        parminsall(list,&node,&str,&str3);    /* $* */
  591. -                    else if (str[1] == Inbrack)
  592. -                        {
  593. -                        arithsuber((void **) &str,&str3);    /* $[...] */
  594. -                        if (magic)
  595. -                            magic = 2;
  596. -                        node->dat = str3;
  597. -                        }
  598. -                    else
  599. -                        {
  600. -                        parmsuber(str,&str3);        /* $foo */
  601. -                        node->dat = str = str3;
  602. -                        if (errflag)
  603. -                            return;
  604. -                        continue;
  605. -                        }
  606. -            str++;
  607. -            if (errflag)
  608. -                return;
  609. -            }
  610. -        node = node->next;
  611. -        }
  612. -}
  613. -
  614. -void postfork(table list,int globstat)
  615. -{
  616. -Node node = list->first;
  617. -int glb = 1;
  618. -
  619. -    if (isset(NOGLOBOPT) || globstat != GLOB)
  620. -        glb = 0;
  621. -    while (node)
  622. -        {
  623. -        char *str,*str3;
  624. -        
  625. -        str = str3 = node->dat;
  626. -        while (*str)
  627. -            {
  628. -            if (((*str == String || *str == Qstring) && str[1] == Inpar) ||
  629. -                    *str == Tick || *str == Qtick)
  630. -                comminsall(list,&node,&str,&str3);    /* `...`,$(...) */
  631. -            str++;
  632. -            if (errflag)
  633. -                return;
  634. -            }
  635. -        
  636. -        /* now we remove the Nulargs tokens if this is not a null
  637. -            arguments.  The lexical analyzer throws these in so that
  638. -            zsh will not look at this:
  639. -
  640. -            $PA"TH"
  641. -
  642. -            and expand it to $PATH.  But after parameter substitution
  643. -            these are only a nuisance, so we remove them. */
  644. -
  645. -        if (*(char *) node->dat)
  646. -            remnulargs(node->dat);
  647. -        
  648. -        if (unset(IGNOREBRACES))
  649. -            while (hasbraces(node->dat))
  650. -                xpandbraces(list,&node);
  651. -        filesub(&node->dat);
  652. -        if (errflag)
  653. -            return;
  654. -        if (glb)
  655. -            {
  656. -            if (haswilds(node->dat))
  657. -                glob(list,&node);
  658. -            if (errflag)
  659. -                return;
  660. -            }
  661. -        else if (globstat == MOSTGLOB && *(char *) node->dat != '-')
  662. -            glb = 1;
  663. -        node = node->next;
  664. -        }
  665. -}
  666. -
  667. -/* strdup, but returns "Nularg" if this is a null string */
  668. -
  669. -void *nstrdup(void *s)
  670. -{
  671. -char *t = s,u[] = {Nularg,'\0'};
  672. -
  673. -    if (!*t)
  674. -        return strdup(u);
  675. -    return strdup(t);
  676. -}
  677. -
  678. -/* $* */
  679. -
  680. -void parminsall(table l,Node *nn,char **aptr,char **bptr)
  681. -{
  682. -char *str3 = *aptr,*str = *bptr;
  683. -Node n = *nn,where = n->last;
  684. -table pl;
  685. -
  686. -    if (magic)
  687. -        magic = 2;
  688. -    *str3 = '\0';
  689. -    str3 += 2;
  690. -    remnode(l,n);
  691. -    pl = duptable(pparms,nstrdup);
  692. -    free(getnode(pl));
  693. -    if (pl->first)    /* if $# > 1 */
  694. -        {
  695. -        char *ptr;
  696. -        Node tmp;
  697. -
  698. -        ptr = pl->first->dat;
  699. -        pl->first->dat = dyncat(str,ptr);
  700. -        free(ptr);
  701. -        ptr = pl->last->dat;
  702. -        *bptr = pl->last->dat = dyncat(ptr,str3);
  703. -        *aptr = *bptr+strlen(str)+strlen(ptr)-1;
  704. -        free(ptr);
  705. -        tmp = where->next;
  706. -        where->next = pl->first;
  707. -        pl->last->next = tmp;
  708. -        pl->first->last = where;
  709. -        if (tmp)
  710. -            tmp->last = pl->last;
  711. -        else
  712. -            l->last = pl->last;
  713. -        *nn = pl->last;
  714. -        }
  715. -    else    /* just remove the $* */
  716. -        {
  717. -        insnode(l,where,*bptr = dyncat(str,str3));
  718. -        *nn = where->next;
  719. -        *aptr = *bptr+strlen(str)-1;
  720. -        }
  721. -}
  722. -
  723. -char *dynread(char stop)
  724. -{
  725. -int bsiz = 256,ct = 0,c;
  726. -char *buf = zalloc(bsiz),*ptr;
  727. - 
  728. -    ptr = buf;
  729. -    while ((c = hgetc()) != stop)
  730. -        {
  731. -        *ptr++ = c;
  732. -        if (++ct == bsiz)
  733. -            {
  734. -            buf = realloc(buf,bsiz *= 2);
  735. -            ptr = buf+ct;
  736. -            }
  737. -        }
  738. -    *ptr = 0;
  739. -    return buf;
  740. -}
  741. -
  742. -int filesub(void **namptr)
  743. -{
  744. -char *str = *namptr,*cnam;
  745. -
  746. -    if (*str == Tilde && str[1] != '=')
  747. -        {
  748. -        if (str[1] == '+')
  749. -            {
  750. -            char *foo = strdup(cwd),*t = str;    /* ~+ */
  751. -
  752. -            str+=2;
  753. -            modify((void **) &foo,&str);
  754. -            *namptr = dyncat(cwd,str);
  755. -            free(foo);
  756. -            free(t);
  757. -            return 1;
  758. -            }
  759. -        else if (str[1] == '-')            /* ~- */
  760. -            {
  761. -            char *foo,*t = str;
  762. -
  763. -            if (cnam = getparm("OLDPWD"))
  764. -                foo = cnam;
  765. -            else
  766. -                foo = cwd;
  767. -            str += 2;
  768. -            foo = strdup(foo);
  769. -            modify((void **) &foo,&str);
  770. -            *namptr = dyncat(foo,str);
  771. -            free(t);
  772. -            free(foo);
  773. -            return 1;
  774. -            }
  775. -        if (isalpha(str[1]))        /* ~foo */
  776. -            {
  777. -            char *ptr,*home;
  778. - 
  779. -            for (ptr = ++str; *ptr && !istok(*ptr) && (isalnum(*ptr) || *ptr == '-'); ptr++)
  780. -                if (*ptr == '-')
  781. -                    *ptr = '-';
  782. -            if (!(home = gethome(str,ptr-str)))
  783. -                {
  784. -                if (magic)
  785. -                    home = completehome(str,ptr-str);
  786. -                if (!home)
  787. -                    {
  788. -                    magicerr();
  789. -                    zerr("user not found: %l",ptr-str,str);
  790. -                    errflag = 1;
  791. -                    return 0;
  792. -                    }
  793. -                }
  794. -            modify((void **) &home,&ptr);
  795. -            *namptr = dyncat(home,ptr);
  796. -            free(home);
  797. -            free(str-1);
  798. -            return 1;
  799. -            }
  800. -        else if (str[1] == '/')    /* ~/foo */
  801. -            {
  802. -            *namptr = dyncat(home,str+1);
  803. -            free(str);
  804. -            return 1;
  805. -            }
  806. -        else if (!str[1])        /* ~ by itself */
  807. -            {
  808. -            free(str);
  809. -            *namptr = strdup(home);
  810. -            return 1;
  811. -            }
  812. -        }
  813. -    if (*str == Equals && !istok(str[1]) && (isalnum(str[1]) || str[1] == '-'))
  814. -        {
  815. -        char *ptr,*s,*ds;
  816. -        int val;
  817. -        
  818. -        untokenize(str);
  819. -        if (isalpha(str[1]))        /* =foo */
  820. -            {
  821. -            struct chnode *chn;
  822. -            struct anode *t;
  823. -            char sav,*pp;
  824. - 
  825. -            for (pp = str+1; *pp && *pp != ':'; pp++);
  826. -            sav = *pp;
  827. -            *pp = '\0';
  828. -            if ((t = gethnode(str+1,alhtab)) && t->cmd)
  829. -                if (t->cmd >= 0)
  830. -                    cnam = strdup(t->text);
  831. -                else
  832. -                    {
  833. -                    magicerr();
  834. -                    zerr("%s: shell reserved word",str+1);
  835. -                    errflag = 1;
  836. -                    return 0;
  837. -                    }
  838. -             else if (chn = gethnode(str+1,chtab))
  839. -                if (chn->type != BUILTIN)
  840. -                    cnam = strdup(chn->u.nam);
  841. -                else
  842. -                    {
  843. -                    magicerr();
  844. -                    zerr("%s: shell built-in command",str+1);
  845. -                    errflag = 1;
  846. -                    return 0;
  847. -                    }
  848. -            else if (!(cnam = findcmd(str+1)))
  849. -                {
  850. -                magicerr();
  851. -                zerr("%s not found",str+1);
  852. -                errflag = 1;
  853. -                return 0;
  854. -                }
  855. -            *namptr = cnam;
  856. -            if ((*pp = sav) == ':')
  857. -                {
  858. -                modify(namptr,&pp);
  859. -                s = *namptr;
  860. -                *namptr = dyncat(*namptr,pp);
  861. -                free(s);
  862. -                }
  863. -            free(str);
  864. -            return 1;
  865. -            }
  866. -        if (str[1] == '-')     /* =- */
  867. -            {
  868. -            val = -1;
  869. -            ptr = str+2;
  870. -            }
  871. -        else
  872. -            val = strtol(str+1,&ptr,10);    /* =# */
  873. -        ds = dstackent(val);
  874. -        if (!ds)
  875. -            return 1;
  876. -        s = strdup(ds);
  877. -        modify((void **) &s,&ptr);
  878. -        *namptr = dyncat(s,ptr);
  879. -        free(s);
  880. -        free(str);
  881. -        return 1;
  882. -        }
  883. -    return 0;
  884. -}
  885. -
  886. -/* get a user's directory */
  887. -
  888. -char *gethome(char *user,int len)
  889. -{
  890. -char sav,*str;
  891. -struct passwd *pw;
  892. - 
  893. -    sav = user[len];
  894. -    user[len] = '\0';
  895. -    if (!(pw = getpwnam(user)))
  896. -        {
  897. -        user[len] = sav;
  898. -        return NULL;
  899. -        }
  900. -    str = xsymlink(pw->pw_dir);
  901. -    user[len] = sav;
  902. -    return str;
  903. -}
  904. -
  905. -/* complete a user and try to get his home directory */
  906. -
  907. -char *completehome(char *user,int len)
  908. -{
  909. -FILE *in;
  910. -char buf[MAXPATHLEN],*str;
  911. -
  912. -    sprintf(buf,"%s/.zfriends",getparm("HOME"));
  913. -    if (!(in = fopen(buf,"r")))
  914. -        return NULL;
  915. -    while (fgetline(buf,MAXPATHLEN,in))
  916. -        if (!strncmp(user,buf,len))
  917. -            if (str = gethome(buf,strlen(buf)))
  918. -                {
  919. -                fclose(in);
  920. -                return str;
  921. -                }
  922. -    fclose(in);
  923. -    return NULL;
  924. -}
  925. -
  926. -/* get the value of the parameter specified by the first len
  927. -    characters of s */
  928. -
  929. -char *getsparmval(char *s,int len)
  930. -{
  931. -char sav = s[len];
  932. -char *val;
  933. -char buf[50];
  934. -int t0;
  935. -
  936. -    if (len == 1 && (istok(*s) || !isalnum(*s)))
  937. -        switch(*s)
  938. -            {
  939. -            case Pound:
  940. -            case '#':
  941. -                sprintf(buf,"%d",ppcount());
  942. -                return strdup(buf);
  943. -            case '-':
  944. -                for (val = buf, t0 = ' '; t0 <= 'z'; t0++)
  945. -                    if (opts[t0] == OPT_SET)
  946. -                        *val++ = t0;
  947. -                *val = '\0';
  948. -                return strdup(buf);
  949. -            case '?':
  950. -            case Quest:
  951. -                sprintf(buf,"%d",lastval);
  952. -                return strdup(buf);
  953. -            case '$':
  954. -            case String:
  955. -                sprintf(buf,"%d",procnum);
  956. -                return strdup(buf);
  957. -            case '!':
  958. -                sprintf(buf,"%d",proclast);
  959. -                return strdup(buf);
  960. -            default:
  961. -                return NULL;
  962. -            }
  963. -    s[len] = '\0';
  964. -    if (isdigit(*s))
  965. -        {
  966. -        int num;
  967. -        Node node;
  968. -        
  969. -        num = atoi(s);
  970. -        s[len] = sav;
  971. -        for (node = pparms->first; node && num; num--,node = node->next);
  972. -        return (node) ? strdup(node->dat) : NULL;
  973. -        }
  974. -    val = getparm(s);
  975. -    s[len] = sav;
  976. -    return (val) ? strdup(val) : NULL;
  977. -}
  978. -
  979. -/* set the parameter associated with the first len characters of s
  980. -    to v. */
  981. -
  982. -void setparml(char *s,int len,char *v)
  983. -{
  984. -char c;
  985. - 
  986. -    c = s[len];
  987. -    s[len] = 0;
  988. -    if (isdigit(*s))
  989. -        {
  990. -        int num;
  991. -        Node node;
  992. -        
  993. -        num = atoi(s);
  994. -        for (node = pparms->first; node && num; num--,node = node->next);
  995. -        if (node)
  996. -            {
  997. -            free(node->dat);
  998. -            node->dat = v;
  999. -            }
  1000. -        else
  1001. -            {
  1002. -            while (num--)
  1003. -                addnode(pparms,strdup(""));
  1004. -            addnode(pparms,v);
  1005. -            }
  1006. -        }
  1007. -    else
  1008. -        setparm(strdup(s),v,0,0);
  1009. -    s[len] = c;
  1010. -}
  1011. -
  1012. -/* `...`, $(...) */
  1013. -
  1014. -void comminsall(table l,Node *nn,char **aptr,char **bptr)
  1015. -{
  1016. -char *str3 = *aptr,*str = *bptr,*str2;
  1017. -Node n = *nn,where = n->last;
  1018. -table pl;
  1019. -int s31 = (*str3 == Qtick || *str3 == Qstring);
  1020. -
  1021. -    if (magic) magic = 2;
  1022. -    if (*str3 == Tick || *str3 == Qtick)
  1023. -        {
  1024. -        *str3 = '\0';
  1025. -        for (str2 = ++str3; *str3 != Tick && *str3 != Qtick; str3++);
  1026. -        *str3++ = '\0';
  1027. -        }
  1028. -    else
  1029. -        {
  1030. -        *str3++ = '\0';
  1031. -        for (str2 = ++str3; *str3 != Outpar; str3++);
  1032. -        *str3++ = '\0';
  1033. -        }
  1034. -    remnode(l,n);
  1035. -    if (!(pl = getoutput(str2,s31)))
  1036. -        {
  1037. -        magicerr();
  1038. -        zerr("parse error in command substitution");
  1039. -        errflag = 1;
  1040. -        return;
  1041. -        }
  1042. -    if (pl->first)
  1043. -        {
  1044. -        char *ptr;
  1045. -        Node tmp;
  1046. -
  1047. -        ptr = pl->first->dat;
  1048. -        pl->first->dat = dyncat(str,ptr);
  1049. -        free(ptr);
  1050. -        ptr = pl->last->dat;
  1051. -        *bptr = pl->last->dat = dyncat(ptr,str3);
  1052. -        *aptr = *bptr+strlen(str)+strlen(ptr)-1;
  1053. -        free(ptr);
  1054. -        tmp = where->next;
  1055. -        where->next = pl->first;
  1056. -        pl->last->next = tmp;
  1057. -        pl->first->last = where;
  1058. -        if (tmp)
  1059. -            tmp->last = pl->last;
  1060. -        else
  1061. -            l->last = pl->last;
  1062. -        /* free(tmp); */
  1063. -        *nn = pl->last;
  1064. -        free(pl);
  1065. -        }
  1066. -    else
  1067. -        {
  1068. -        insnode(l,where,*bptr = dyncat(str,str3));
  1069. -        *nn = where->next;
  1070. -        *aptr = *bptr+strlen(str)-1;
  1071. -        }
  1072. -}
  1073. -
  1074. -/* do simple parameter substitution */
  1075. -
  1076. -/*
  1077. -    consider an argument like this:
  1078. -
  1079. -    abcde${fgh:-ijk}lmnop
  1080. -
  1081. -    aptr will point to the $.
  1082. -    *bptr,ostr will point to the a.
  1083. -    t will point to the f.
  1084. -    u will point to the i.
  1085. -    s will point to the l (eventually).
  1086. -*/
  1087. -
  1088. -void parmsuber(char *aptr,char **bptr)
  1089. -{
  1090. -char *s = aptr,*t,*u,*val,*ostr = *bptr;
  1091. -int brs;            /* != 0 means ${...}, otherwise $... */
  1092. -int vlen;        /* the length of the name of the parameter */
  1093. -int colf;        /* != 0 means we found a colon after the name */
  1094. -int doub = 0;    /* != 0 means we have %%, not %, or ##, not # */
  1095. -
  1096. -    /* first, remove the $ so *bptr is pointing to a null-terminated
  1097. -        string containing the stuff before the $.  Then check for braces,
  1098. -        and get the parameter name and value, if any. */
  1099. -
  1100. -    *s++ = '\0';
  1101. -    if (brs = (*s == '{' || *s == Inbrace))
  1102. -        s++;
  1103. -    t = s;
  1104. -    if (istok(*s) || !isalnum(*s))
  1105. -        {
  1106. -        val = getsparmval(t,vlen = 1);
  1107. -        if (!val)
  1108. -            {
  1109. -            *(char *) aptr = '$';
  1110. -            if (brs)
  1111. -                s[-1] = '{';
  1112. -            return;
  1113. -            }
  1114. -        s++;
  1115. -        }
  1116. -    else
  1117. -        {
  1118. -        while (!istok(*s) && (isalnum(*s) || *s == '_'))
  1119. -            s++;
  1120. -        val = getsparmval(t,vlen = s-t);
  1121. -        }
  1122. -
  1123. -    /* val can still be NULL at this point. */
  1124. -
  1125. -    if (colf = *s == ':')
  1126. -        s++;
  1127. -    
  1128. -    /* check for ${..?...} or ${..=..} or one of those.  Only works
  1129. -        if the name is in braces. */
  1130. -
  1131. -    if (brs && (*s == '-' || *s == '=' || *s == '?' || *s == '+' || *s == '#' ||
  1132. -            *s == '%' || *s == Quest || *s == Pound))
  1133. -        {
  1134. -        if (*s == s[1])
  1135. -            {
  1136. -            s++;
  1137. -            doub = 1;
  1138. -            }
  1139. -        u = ++s;
  1140. -        if (brs)
  1141. -            while (*s != '}' && *s != Outbrace)
  1142. -                s++;
  1143. -        else
  1144. -            {
  1145. -            while (*s++);
  1146. -            s--;
  1147. -            }
  1148. -        *s = '\0';
  1149. -        switch (u[-1])
  1150. -            {
  1151. -            case '-':
  1152. -                if (!val || (colf && !*val))
  1153. -                    val = strdup(u);
  1154. -                break;
  1155. -            case '=':
  1156. -                if (!val || (colf && !*val))
  1157. -                    setparml(t,vlen,val = strdup(u));
  1158. -                break;
  1159. -            case '?':
  1160. -            case Quest:
  1161. -                if (!val || (colf && !*val))
  1162. -                    {
  1163. -                    magicerr();
  1164. -                    zerr("%s",(*u) ? u : "parameter not set");
  1165. -                    if (!interact)
  1166. -                        exit(1);
  1167. -                    else
  1168. -                        errflag = 1;
  1169. -                    return;
  1170. -                    }
  1171. -                break;
  1172. -            case '+':
  1173. -                if (!val || (colf && !*val))
  1174. -                    val = strdup("");
  1175. -                else
  1176. -                    val = strdup(u);
  1177. -                break;
  1178. -            case '#':
  1179. -            case Pound:
  1180. -                if (!val)
  1181. -                    val = strdup("");
  1182. -                getmatch(&val,u,doub);
  1183. -                break;
  1184. -            case '%':
  1185. -                if (!val)
  1186. -                    val = strdup("");
  1187. -                getmatch(&val,u,doub+2);
  1188. -                break;
  1189. -            }
  1190. -        }
  1191. -    else        /* no ${...=...} or anything, but possible modifiers. */
  1192. -        {
  1193. -        if (!val)
  1194. -            {
  1195. -            if (isset(NOUNSET))
  1196. -                {
  1197. -                zerr("parameter not set: %l",vlen,t);
  1198. -                errflag = 1;
  1199. -                return;
  1200. -                }
  1201. -            val = strdup("");
  1202. -            }
  1203. -        if (colf)
  1204. -            {
  1205. -            s--;
  1206. -            modify((void **) &val,&s);        /* do modifiers */
  1207. -            }
  1208. -        if (brs)
  1209. -            {
  1210. -            if (*s != '}' && *s != Outbrace)
  1211. -                {
  1212. -                zerr("closing brace expected");
  1213. -                errflag = 1;
  1214. -                return;
  1215. -                }
  1216. -            s++;
  1217. -            }
  1218. -        }
  1219. -    if (errflag)
  1220. -        {
  1221. -        free(ostr);
  1222. -        return;
  1223. -        }
  1224. -    *bptr = zalloc((char *) aptr-(*bptr)+strlen(val)+strlen(s)+1);
  1225. -    strcpy(*bptr,ostr);
  1226. -    strcat(*bptr,val);
  1227. -    strcat(*bptr,s);
  1228. -    free(ostr);
  1229. -    if (magic)
  1230. -        magic = 2;
  1231. -}
  1232. -
  1233. -/* arithmetic substitution */
  1234. -
  1235. -void arithsuber(void **aptr,char **bptr)
  1236. -{
  1237. -char *s = *aptr,*t,buf[16];
  1238. -long v;
  1239. -
  1240. -    *s = '\0';
  1241. -    for (; *s != Outbrack; s++);
  1242. -    *s++ = '\0';
  1243. -    v = matheval(*aptr+2);
  1244. -    sprintf(buf,"%ld",v);
  1245. -    t = zalloc(strlen(*bptr)+strlen(buf)+strlen(s)+1);
  1246. -    strcpy(t,*bptr);
  1247. -    strcat(t,buf);
  1248. -    strcat(t,s);
  1249. -    free(*bptr);
  1250. -    *bptr = t;
  1251. -}
  1252. -
  1253. -void modify(void **str,char **ptr)
  1254. -{
  1255. -char *ptr1,*ptr2,*ptr3,del,*lptr;
  1256. -int gbal;
  1257. - 
  1258. -    while (**ptr == ':')
  1259. -        {
  1260. -        lptr = *ptr;
  1261. -        (*ptr)++;
  1262. -        gbal = 0;
  1263. -here:
  1264. -        switch(*(*ptr)++)
  1265. -            {
  1266. -            case 'h':
  1267. -                while (remtpath(str) && gbal);
  1268. -                break;
  1269. -            case 'r':
  1270. -                while (remtext(str) && gbal);
  1271. -                break;
  1272. -            case 'e':
  1273. -                while (rembutext(str) && gbal);
  1274. -                break;
  1275. -            case 't':
  1276. -                while (remlpaths(str) && gbal);
  1277. -                break;
  1278. -            case 's':
  1279. -                if (last)
  1280. -                    free(last);
  1281. -                if (rast)
  1282. -                    free(rast);
  1283. -                ptr1 = *ptr;
  1284. -                del = *ptr1++;
  1285. -                for (ptr2 = ptr1; *ptr2 != del && *ptr2; ptr2++);
  1286. -                if (!*ptr2)
  1287. -                    {
  1288. -                    magicerr();
  1289. -                    zerr("bad subtitution");
  1290. -                    errflag = 1;
  1291. -                    return;
  1292. -                    }
  1293. -                *ptr2++ = '\0';
  1294. -                for (ptr3 = ptr2; *ptr3 != del && *ptr3; ptr3++);
  1295. -                if (*ptr3)
  1296. -                    *ptr3++ = '\0';
  1297. -                last = strdup(ptr1);
  1298. -                rast = strdup(ptr2);
  1299. -                *ptr = ptr3;
  1300. -            case '&':
  1301. -                if (last && rast)
  1302. -                    subststr(str,last,rast,gbal);
  1303. -                break;
  1304. -            case 'g':
  1305. -                gbal = 1;
  1306. -                goto here;
  1307. -            default:
  1308. -                *ptr = lptr;
  1309. -                return;
  1310. -            }
  1311. -        }
  1312. -}
  1313. -
  1314. -/* get a directory stack entry */
  1315. -
  1316. -char *dstackent(int val)
  1317. -{
  1318. -Node node;
  1319. - 
  1320. -    if ((val < 0 && !dirstack->first) || !val--)
  1321. -        return cwd;
  1322. -    if (val < 0)
  1323. -        node = dirstack->last;
  1324. -    else
  1325. -        for (node = dirstack->first; node && val; val--,node = node->next);
  1326. -    if (!node)
  1327. -        {
  1328. -        magicerr();
  1329. -        zerr("not enough dir stack entries.");
  1330. -        errflag = 1;
  1331. -        return NULL;
  1332. -        }
  1333. -    return node->dat;
  1334. -}
  1335. - 
  1336. -void execshfunc(comm comm)
  1337. -{
  1338. -table tab,oldlocals;
  1339. -Node n;
  1340. -char *s;
  1341. -
  1342. -    tab = pparms;
  1343. -    oldlocals = locallist;
  1344. -    locallist = newtable();
  1345. -    for (n = tab->first; n; n = n->next);
  1346. -    pparms = comm->args;
  1347. -    runlist(comm->left);
  1348. -    retflag = 0;
  1349. -    comm->left = NULL;
  1350. -    pparms = tab;
  1351. -    while (s = getnode(locallist))
  1352. -        {
  1353. -        void *z = remhnode(s,parmhtab);
  1354. -        if (z)
  1355. -            freepm(z);
  1356. -        }
  1357. -    free(locallist);
  1358. -    locallist = oldlocals;
  1359. -}
  1360. -
  1361. -/* make an alias hash table node */
  1362. -
  1363. -struct anode *mkanode(char *txt,int cmflag)
  1364. -{
  1365. -struct anode *ptr = (void *) alloc(sizeof(struct anode));
  1366. -
  1367. -    ptr->text  = txt;
  1368. -    ptr->cmd = cmflag;
  1369. -    ptr->inuse = 0;
  1370. -    return ptr;
  1371. -}
  1372. -
  1373. -/* perform TAB substitution */
  1374. -
  1375. -char *docompsubs(char *str,int *i)
  1376. -{
  1377. -table fake,curt = curtab;
  1378. -char *s,*t;
  1379. -int ct = 0;
  1380. -
  1381. -    for (s = str; *s; s++)
  1382. -        for (t = tokens; *t; t++)
  1383. -            if (*s == *t)
  1384. -                {
  1385. -                *s = (t-tokens)+Pound;
  1386. -                break;
  1387. -                }
  1388. -    curtab = NULL;
  1389. -    magic = 1;
  1390. -    fake = newtable();
  1391. -    addnode(fake,str);
  1392. -    prefork(fake);
  1393. -    if (!errflag)
  1394. -        postfork(fake,GLOB);
  1395. -    if (fake->first && fake->first->next)
  1396. -        ct = 1;
  1397. -    t = s = buildline(fake);
  1398. -    free(fake);
  1399. -    rl_prep_terminal();
  1400. -    if (errflag)
  1401. -        {
  1402. -        rl_on_new_line();
  1403. -        rl_redisplay();
  1404. -        errflag = 0;
  1405. -        magic = 0;
  1406. -        curtab = curt;
  1407. -        *i = 0;
  1408. -        return NULL;
  1409. -        }
  1410. -    *i = (magic == 2) + ct;
  1411. -    magic = 0;
  1412. -    curtab = curt;
  1413. -    untokenize(s);
  1414. -    return s;
  1415. -}
  1416. -
  1417. -/* perform substitution on the command name */
  1418. -
  1419. -void docmdsubs(char **str)
  1420. -{
  1421. -table fake;
  1422. -char *s = strdup(*str);
  1423. -
  1424. -    fake = newtable();
  1425. -    addnode(fake,*str);
  1426. -    prefork(fake);
  1427. -    if (!errflag) postfork(fake,GLOB);
  1428. -    if (errflag)
  1429. -        {
  1430. -        free(fake);
  1431. -        free(s);
  1432. -        return;
  1433. -        }
  1434. -    if (fake->first && fake->first->next)
  1435. -        {
  1436. -        zerr("%s: ambiguous",s);
  1437. -        errflag = 1;
  1438. -        free(fake);
  1439. -        free(s);
  1440. -        return;
  1441. -        }
  1442. -    *str = getnode(fake);
  1443. -    free(s);
  1444. -    free(fake);
  1445. -}
  1446. -
  1447. -/* perform substitution on the variables */
  1448. -
  1449. -void dovarsubs(char **str)
  1450. -{
  1451. -table fake;
  1452. -char *s;
  1453. -
  1454. -    fake = newtable();
  1455. -    addnode(fake,*str);
  1456. -    prefork(fake);
  1457. -    if (!errflag) postfork(fake,GLOB);
  1458. -    if (errflag)
  1459. -        return;
  1460. -    s = buildline(fake);
  1461. -    untokenize(s);
  1462. -    *str = s;
  1463. -    free(fake);
  1464. -}
  1465. -
  1466. End of subst.c
  1467. echo subst.pro 1>&2
  1468. sed 's/^-//' >subst.pro <<'End of subst.pro'
  1469. -void prefork(table list);
  1470. -void postfork(table list,int globstat);
  1471. -void *nstrdup(void *s);
  1472. -void parminsall(table l,Node *nn,char **aptr,char **bptr);
  1473. -char *dynread(char stop);
  1474. -int filesub(void **namptr);
  1475. -char *gethome(char *user,int len);
  1476. -char *completehome(char *user,int len);
  1477. -char *getsparmval(char *s,int len);
  1478. -void setparml(char *s,int len,char *v);
  1479. -void comminsall(table l,Node *nn,char **aptr,char **bptr);
  1480. -void parmsuber(char *aptr,char **bptr);
  1481. -void arithsuber(void **aptr,char **bptr);
  1482. -void modify(void **str,char **ptr);
  1483. -char *dstackent(int val);
  1484. -void execshfunc(comm comm);
  1485. -struct anode *mkanode(char *txt,int cmflag);
  1486. -char *docompsubs(char *str,int *i);
  1487. -void docmdsubs(char **str);
  1488. -void dovarsubs(char **str);
  1489. End of subst.pro
  1490. echo table.c 1>&2
  1491. sed 's/^-//' >table.c <<'End of table.c'
  1492. -/*
  1493. -
  1494. -    table.c - linked list and hash table management
  1495. -
  1496. -    This file is part of zsh, the Z shell.
  1497. -
  1498. -   zsh is free software; no one can prevent you from reading the source
  1499. -   code, or giving it to someone else.
  1500. -   This file is copyrighted under the GNU General Public License, which
  1501. -   can be found in the file called COPYING.
  1502. -
  1503. -   Copyright (C) 1990 Paul Falstad
  1504. -
  1505. -   zsh is distributed in the hope that it will be useful, but
  1506. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  1507. -   responsibility to anyone for the consequences of using it or for
  1508. -   whether it serves any particular purpose or works at all, unless he
  1509. -   says so in writing.  Refer to the GNU General Public License
  1510. -   for full details.
  1511. -
  1512. -   Everyone is granted permission to copy, modify and redistribute
  1513. -   zsh, but only under the conditions described in the GNU General Public
  1514. -   License.   A copy of this license is supposed to have been given to you
  1515. -   along with zsh so you can know your rights and responsibilities.
  1516. -   It should be in a file named COPYING.
  1517. -
  1518. -   Among other things, the copyright notice and this notice must be
  1519. -   preserved on all copies.
  1520. -
  1521. -*/
  1522. -
  1523. -#include "zsh.h"
  1524. -#include "funcs.h"
  1525. -
  1526. -/* get an empty linked list header */
  1527. -
  1528. -table newtable()
  1529. -{
  1530. -table list;
  1531. - 
  1532. -    list = alloc(sizeof(*list));
  1533. -    list->first = 0;
  1534. -    list->last = (Node) list;
  1535. -    return list;
  1536. -}
  1537. -
  1538. -/* get an empty hash table */
  1539. -
  1540. -htable newhtable(int size)
  1541. -{
  1542. -htable ret;
  1543. - 
  1544. -    ret = alloc(sizeof(struct xhtab));
  1545. -    ret->hsize = size;
  1546. -    ret->nodes = alloc(size*sizeof(struct hnode *));
  1547. -    return ret;
  1548. -}
  1549. - 
  1550. -/* Peter Weinberger's hash function */
  1551. -
  1552. -int hasher(char *s)
  1553. -{
  1554. -unsigned hash = 0,g;
  1555. - 
  1556. -    for (; *s; s++)
  1557. -        {
  1558. -        hash = (hash << 4) + *s;
  1559. -        if (g = hash & 0xf0000000)
  1560. -            {
  1561. -            hash ^= g;
  1562. -            hash ^= g >> 24;
  1563. -            }
  1564. -        }
  1565. -    return hash;
  1566. -}
  1567. -
  1568. -/* add a node to a hash table */
  1569. -
  1570. -void addhnode(char *nam,void *dat,htable ht,void (*freefunc)(void *))
  1571. -{
  1572. -int hval = hasher(nam) % ht->hsize;
  1573. -struct hnode *hp = ht->nodes[hval],*hn;
  1574. - 
  1575. -    for (; hp; hp = hp->hchain)
  1576. -        if (!strcmp(hp->nam,nam))
  1577. -            {
  1578. -            freefunc(hp->dat);
  1579. -            hp->dat = dat;
  1580. -            free(nam);
  1581. -            return;
  1582. -            }
  1583. -    hn = (void *) alloc(sizeof(struct hnode));
  1584. -    hn->nam = nam;
  1585. -    hn->dat = dat;
  1586. -    hn->hchain = ht->nodes[hval];
  1587. -    ht->nodes[hval] = hn;
  1588. -    if (++ht->ct == ht->hsize*4)
  1589. -        expandhtab(ht);
  1590. -}
  1591. -
  1592. -/* expand hash tables when they get too many entries */
  1593. -
  1594. -void expandhtab(htable ht)
  1595. -{
  1596. -struct hnode *hp,**arr,**ha,*hn;
  1597. -int osize = ht->hsize,nsize = osize*8;
  1598. -
  1599. -    ht->hsize = nsize;
  1600. -    arr = ht->nodes;
  1601. -    ht->nodes = alloc(nsize*sizeof(struct hnode *));
  1602. -    for (ha = arr; osize; osize--,ha++)
  1603. -        for (hn = *ha; hn; )
  1604. -            {
  1605. -            addhnode(hn->nam,hn->dat,ht,NULL);
  1606. -            hp = hn->hchain;
  1607. -            free(hn);
  1608. -            hn = hp;
  1609. -            }
  1610. -    free(arr);
  1611. -}
  1612. -
  1613. -/* get an entry in a hash table */
  1614. -
  1615. -void *gethnode(char *nam,htable ht)
  1616. -{
  1617. -int hval = hasher(nam) % ht->hsize;
  1618. -struct hnode *hn = ht->nodes[hval];
  1619. - 
  1620. -    for (; hn; hn = hn->hchain)
  1621. -        if (!strcmp(hn->nam,nam))
  1622. -            return hn->dat;
  1623. -    return NULL;
  1624. -}
  1625. - 
  1626. -void freehtab(htable ht,void (*freefunc)(void *))
  1627. -{
  1628. -int val;
  1629. -struct hnode *hn,**hptr = &ht->nodes[0],*next;
  1630. - 
  1631. -    for (val = ht->hsize; val; val--,hptr++)
  1632. -        for (hn = *hptr; hn; )
  1633. -            {
  1634. -            next = hn->hchain;
  1635. -            freefunc(hn);
  1636. -            hn = next;
  1637. -            }
  1638. -}
  1639. -
  1640. -/* remove a hash table entry and return a pointer to it */
  1641. -
  1642. -void *remhnode(char *nam,htable ht)
  1643. -{
  1644. -int hval = hasher(nam) % ht->hsize;
  1645. -struct hnode *hn = ht->nodes[hval],*hp;
  1646. -void *dat;
  1647. -
  1648. -    if (!hn)
  1649. -        return NULL;
  1650. -    if (!strcmp(hn->nam,nam))
  1651. -        {
  1652. -        ht->nodes[hval] = hn->hchain;
  1653. -        dat = hn->dat;
  1654. -        free(hn->nam);
  1655. -        free(hn);
  1656. -        ht->ct--;
  1657. -        return dat;
  1658. -        }
  1659. -    for (hp = hn, hn = hn->hchain; hn; hn = (hp = hn)->hchain)
  1660. -        if (!strcmp(hn->nam,nam))
  1661. -            {
  1662. -            hp->hchain = hn->hchain;
  1663. -            dat = hn->dat;
  1664. -            free(hn->nam);
  1665. -            free(hn);
  1666. -            ht->ct--;
  1667. -            return dat;
  1668. -            }
  1669. -    return NULL;
  1670. -}
  1671. - 
  1672. -void *zalloc(int l)
  1673. -{
  1674. -void *z;
  1675. - 
  1676. -    if (!(z = malloc(l)))
  1677. -        {
  1678. -        zerr("fatal error: out of memory: restarting");
  1679. -        execl(MYSELF,"zsh","-f",(void *) 0);
  1680. -        exit(1);
  1681. -        }
  1682. -    return z;
  1683. -}
  1684. -
  1685. -void *alloc(int l)
  1686. -{
  1687. -void *z;
  1688. - 
  1689. -    if (!(z = calloc(l,1)))
  1690. -        {
  1691. -        zerr("fatal error: out of memory: restarting");
  1692. -        execl(MYSELF,"zsh","-f",(void *) 0);
  1693. -        exit(1);
  1694. -        }
  1695. -    return z;
  1696. -}
  1697. -
  1698. -/* add a node to the end of a linked list */
  1699. -
  1700. -void addnode(table list,void *str)
  1701. -{
  1702. -    insnode(list,list->last,str);
  1703. -}
  1704. -
  1705. -/* insert a node in a linked list after 'last' */
  1706. -
  1707. -void insnode(table list,Node last,void *dat)
  1708. -{
  1709. -Node tmp;
  1710. - 
  1711. -    tmp = last->next;
  1712. -    last->next = alloc(sizeof(*tmp));
  1713. -    last->next->last = last;
  1714. -    last->next->dat = dat;
  1715. -    last->next->next = tmp;
  1716. -    if (tmp)
  1717. -        tmp->last = last->next;
  1718. -    else
  1719. -        list->last = last->next;
  1720. -}
  1721. -
  1722. -/* remove a node from a linked list */
  1723. -
  1724. -void *remnode(table list,Node nd)
  1725. -{
  1726. -void *dat;
  1727. -
  1728. -    nd->last->next = nd->next;
  1729. -    if (nd->next)
  1730. -        nd->next->last = nd->last;
  1731. -    else
  1732. -        list->last = nd->last;
  1733. -    free(nd);
  1734. -    dat = nd->dat;
  1735. -    return dat;
  1736. -}
  1737. -
  1738. -/* delete a character in a string */
  1739. -
  1740. -void chuck(char *str)
  1741. -{
  1742. -    while (str[0] = str[1])
  1743. -        str++;
  1744. -}
  1745. -
  1746. -/* get a node in a linked list */
  1747. -
  1748. -void *getnode(table list)
  1749. -{
  1750. -void *dat;
  1751. -Node node = list->first;
  1752. - 
  1753. -    if (!node)
  1754. -        return NULL;
  1755. -    dat = node->dat;
  1756. -    list->first = node->next;
  1757. -    if (node->next)
  1758. -        node->next->last = (Node) list;
  1759. -    else
  1760. -        list->last = (Node) list;
  1761. -    free(node);
  1762. -    return dat;
  1763. -}
  1764. -
  1765. -/* != 0 if the linked list has at least one entry */
  1766. -
  1767. -int full(table list)
  1768. -{
  1769. -    return list->first != NULL;
  1770. -}
  1771. - 
  1772. -void freetable(table tab,void (*freefunc)(void *))
  1773. -{
  1774. -Node node = tab->first,next;
  1775. - 
  1776. -    while (node)
  1777. -        {
  1778. -        next = node->next;
  1779. -        freefunc(node);
  1780. -        node = next;
  1781. -        }
  1782. -    free(tab);
  1783. -}
  1784. - 
  1785. -char *strdup(char *str)
  1786. -{
  1787. -char *ret = zalloc(strlen(str)+1);
  1788. - 
  1789. -    strcpy(ret,str);
  1790. -    return ret;
  1791. -}
  1792. -
  1793. -#ifndef STRSTR
  1794. -const char *strstr(const char *s,const char *t)
  1795. -{
  1796. -const char *p1,*p2;
  1797. - 
  1798. -    for (; *s; s++)
  1799. -        {
  1800. -        for (p1 = s, p2 = t; *p2; p1++,p2++)
  1801. -            if (*p1 != *p2)
  1802. -                break;
  1803. -        if (!*p2)
  1804. -             return (char *) s;
  1805. -        }
  1806. -    return NULL;
  1807. -}
  1808. -#endif
  1809. -
  1810. End of table.c
  1811. echo table.pro 1>&2
  1812. sed 's/^-//' >table.pro <<'End of table.pro'
  1813. -table newtable();
  1814. -htable newhtable(int size);
  1815. -int hasher(char *s) /* copied from Programming in C++, p14 */;
  1816. -void addhnode(char *nam,void *dat,htable ht,void (*freefunc)(void *));
  1817. -void expandhtab(htable ht);
  1818. -void *gethnode(char *nam,htable ht);
  1819. -void freehtab(htable ht,void (*freefunc)(void *));
  1820. -void *remhnode(char *nam,htable ht);
  1821. -void *zalloc(int l);
  1822. -void *alloc(int l);
  1823. -void addnode(table list,void *str);
  1824. -void insnode(table list,Node last,void *dat);
  1825. -void *remnode(table list,Node nd);
  1826. -void chuck(char *str);
  1827. -void *getnode(table list);
  1828. -int full(table list);
  1829. -void freetable(table tab,void (*freefunc)(void *));
  1830. -char *strdup(char *str);
  1831. -/*const char *strstr(const char *s,const char *t); */
  1832. End of table.pro
  1833. echo test.c 1>&2
  1834. sed 's/^-//' >test.c <<'End of test.c'
  1835. -/*
  1836. -
  1837. -    test.c - the test builtin
  1838. -
  1839. -    This file is part of zsh, the Z shell.
  1840. -
  1841. -   zsh is free software; no one can prevent you from reading the source
  1842. -   code, or giving it to someone else.
  1843. -   This file is copyrighted under the GNU General Public License, which
  1844. -   can be found in the file called COPYING.
  1845. -
  1846. -   Copyright (C) 1990 Paul Falstad
  1847. -
  1848. -   zsh is distributed in the hope that it will be useful, but
  1849. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  1850. -   responsibility to anyone for the consequences of using it or for
  1851. -   whether it serves any particular purpose or works at all, unless he
  1852. -   says so in writing.  Refer to the GNU General Public License
  1853. -   for full details.
  1854. -
  1855. -   Everyone is granted permission to copy, modify and redistribute
  1856. -   zsh, but only under the conditions described in the GNU General Public
  1857. -   License.   A copy of this license is supposed to have been given to you
  1858. -   along with zsh so you can know your rights and responsibilities.
  1859. -   It should be in a file named COPYING.
  1860. -
  1861. -   Among other things, the copyright notice and this notice must be
  1862. -   preserved on all copies.
  1863. -
  1864. -*/
  1865. -
  1866. -#include "zsh.h"
  1867. -
  1868. -#ifndef F_OK
  1869. -#define F_OK 00
  1870. -#define R_OK 04
  1871. -#define W_OK 02
  1872. -#define X_OK 01
  1873. -#endif
  1874. -
  1875. -#include "test.pro"
  1876. -#include "table.pro"
  1877. -
  1878. -static char **arg;
  1879. -static int efg;
  1880. -
  1881. -void die(char *str)
  1882. -{
  1883. -    if (!efg)
  1884. -        zerrnam("test",str);
  1885. -    efg = 1;
  1886. -}
  1887. -
  1888. -int test(comm comm)
  1889. -{
  1890. -Node n;
  1891. -int t0;
  1892. -char **av,**ap;
  1893. -
  1894. -    for (n = comm->args->first, t0 = 0; n; n = n->next,t0++);
  1895. -    ap = av = (char **) zalloc((sizeof(char *))*(t0+1));
  1896. -    for (n = comm->args->first; n; n = n->next)
  1897. -        *ap++ = n->dat;
  1898. -    *ap = NULL;
  1899. -    t0 = testmain(av);
  1900. -    free(av);
  1901. -    return t0;
  1902. -}
  1903. -
  1904. -int testmain(char **argv)
  1905. -{
  1906. -int ret,isbrack;
  1907. -    
  1908. -    efg = 0;
  1909. -    arg = argv+1;
  1910. -    ret = testexpr();
  1911. -    if (efg)
  1912. -        return 1;
  1913. -    isbrack = !strcmp(*argv,"[");
  1914. -    if (isbrack)
  1915. -        {
  1916. -        if (*arg && !strcmp(*arg,"]") && !arg[1])
  1917. -            return !ret;
  1918. -        }
  1919. -    else
  1920. -        if (!*arg)
  1921. -            return !ret;
  1922. -    die("bad test format");
  1923. -    return 1;
  1924. -}
  1925. -
  1926. -int testexpr(void)
  1927. -{
  1928. -int ret = testexpr2(),ret2;
  1929. -
  1930. -    if (*arg && !strcmp(*arg,"-o"))
  1931. -        {
  1932. -        arg++;
  1933. -        ret2 = testexpr2();
  1934. -        if (efg)
  1935. -            return 0;
  1936. -        ret = ret || ret2;
  1937. -        }
  1938. -    return ret;
  1939. -}
  1940. -
  1941. -int testexpr2(void)
  1942. -{
  1943. -int ret = testexpr3(),ret2;
  1944. -
  1945. -    if (*arg && !strcmp(*arg,"-a"))
  1946. -        {
  1947. -        arg++;
  1948. -        ret2 = testexpr2();
  1949. -        if (efg)
  1950. -            return 0;
  1951. -        ret = ret && ret2;
  1952. -        }
  1953. -    return ret;
  1954. -}
  1955. -
  1956. -int testexpr3(void)
  1957. -{
  1958. -    if (*arg && !strcmp(*arg,"!"))
  1959. -        {
  1960. -        arg++;
  1961. -        return !testexpr3();
  1962. -        }
  1963. -    return testexpr4();
  1964. -}
  1965. -
  1966. -int testexpr4(void)
  1967. -{
  1968. -int ret,t0,t1;
  1969. -struct stat *st;
  1970. -char buf[16],*op;
  1971. -
  1972. -    if (!*arg)
  1973. -        {
  1974. -        die("expression expected");
  1975. -        return 0;
  1976. -        }
  1977. -    if (!strcmp(*arg,"("))
  1978. -        {
  1979. -        arg++;
  1980. -        ret = testexpr();
  1981. -        if (!*arg || strcmp(*arg,")"))
  1982. -            {
  1983. -            die("')' expected");
  1984. -            return 0;
  1985. -            }
  1986. -        arg++;
  1987. -        return ret;
  1988. -        }
  1989. -    if (**arg == '-' && !(*arg)[2])
  1990. -        {
  1991. -        switch((*arg++)[1])
  1992. -            {
  1993. -            case 'a': return(doaccess(F_OK));
  1994. -            case 'b': return(S_ISBLK(dostat()));
  1995. -            case 'c': return(S_ISCHR(dostat()));
  1996. -            case 'd': return(S_ISDIR(dostat()));
  1997. -            case 'f': return(S_ISREG(dostat()));
  1998. -            case 'g': return(!!(dostat() & S_ISGID));
  1999. -            case 'k': return(!!(dostat() & S_ISVTX));
  2000. -            case 'L': return(S_ISLNK(dostat()));
  2001. -            case 'p': return(S_ISFIFO(dostat()));
  2002. -            case 'r': return(doaccess(R_OK));
  2003. -            case 's': return((st = getstat()) && !!(st->st_size));
  2004. -            case 'S': return(S_ISSOCK(dostat()));
  2005. -            case 'u': return(!!(dostat() & S_ISUID));
  2006. -            case 'w': return(doaccess(W_OK));
  2007. -            case 'x': return(doaccess(X_OK));
  2008. -            case 'O': return((st = getstat()) && st->st_uid == geteuid());
  2009. -            case 'G': return((st = getstat()) && st->st_gid == getegid());
  2010. -            case 't': {
  2011. -                int t0 = 1;
  2012. -
  2013. -                if (*arg && isdigit(**arg))
  2014. -                    t0 = atoi(*arg++);
  2015. -                return isatty(t0);
  2016. -                }
  2017. -            case 'z':
  2018. -                if (!*arg)
  2019. -                    {
  2020. -                    die("string expected");
  2021. -                    return 0;
  2022. -                    }
  2023. -                return !strlen(*arg++);
  2024. -            case 'n':
  2025. -                if (!*arg)
  2026. -                    {
  2027. -                    die("string expected");
  2028. -                    return 0;
  2029. -                    }
  2030. -                return !!strlen(*arg++);
  2031. -            case 'l':
  2032. -                sprintf(buf,"%d",strlen(*arg));
  2033. -                *arg = buf;
  2034. -                break;
  2035. -            }
  2036. -        }
  2037. -    if (!arg[1] || !strcmp(arg[1],"-o") || !strcmp(arg[1],"-a") ||
  2038. -            !strcmp(arg[1],"]") || !strcmp(arg[1],")"))
  2039. -        return(!!strlen(*arg++));
  2040. -    if (!arg[2])
  2041. -        {
  2042. -        die("bad expression");
  2043. -        return 0;
  2044. -        }
  2045. -    if (!strcmp(arg[1],"-nt"))
  2046. -        {
  2047. -        time_t a;
  2048. -
  2049. -        if (!(st = getstat()))
  2050. -            {
  2051. -            arg += 2;
  2052. -            return 0;
  2053. -            }
  2054. -        a = st->st_mtime;
  2055. -        arg++;
  2056. -        if (!(st = getstat()))
  2057. -            {
  2058. -            arg += 2;
  2059. -            return 0;
  2060. -            }
  2061. -        return a > st->st_mtime;
  2062. -        }
  2063. -    if (!strcmp(arg[1],"-ot"))
  2064. -        {
  2065. -        time_t a;
  2066. -
  2067. -        if (!(st = getstat()))
  2068. -            {
  2069. -            arg += 2;
  2070. -            return 0;
  2071. -            }
  2072. -        a = st->st_mtime;
  2073. -        arg++;
  2074. -        if (!(st = getstat()))
  2075. -            {
  2076. -            arg += 2;
  2077. -            return 0;
  2078. -            }
  2079. -        return a < st->st_mtime;
  2080. -        }
  2081. -    if (!strcmp(arg[1],"-ef"))
  2082. -        {
  2083. -        dev_t d;
  2084. -        ino_t i;
  2085. -
  2086. -        if (!(st = getstat()))
  2087. -            {
  2088. -            arg += 2;
  2089. -            return 0;
  2090. -            }
  2091. -        d = st->st_dev;
  2092. -        i = st->st_ino;
  2093. -        arg++;
  2094. -        if (!(st = getstat()))
  2095. -            {
  2096. -            arg += 2;
  2097. -            return 0;
  2098. -            }
  2099. -        return d == st->st_dev && i == st->st_ino;
  2100. -        }
  2101. -    if (!strcmp(arg[1],"~="))
  2102. -        {
  2103. -        arg += 3;
  2104. -        return patmatch(arg[-3],arg[-1]);
  2105. -        }
  2106. -    if (!strcmp(arg[1],"="))
  2107. -        {
  2108. -        arg += 3;
  2109. -        return !strcmp(arg[-3],arg[-1]);
  2110. -        }
  2111. -    if (!strcmp(arg[1],"!="))
  2112. -        {
  2113. -        arg += 3;
  2114. -        return !!strcmp(arg[-3],arg[-1]);
  2115. -        }
  2116. -    t0 = atoi(arg[0]);
  2117. -    op = arg[1];
  2118. -    arg += 2;
  2119. -    if (!strcmp(*arg,"-l"))
  2120. -        {
  2121. -        if (!arg[1])
  2122. -            {
  2123. -            die("string expected");
  2124. -            return 0;
  2125. -            }
  2126. -        t1 = strlen(arg[1]);
  2127. -        arg += 2;
  2128. -        }
  2129. -    else
  2130. -        t1 = atoi(*arg++);
  2131. -    if (!strcmp(op,"-eq"))
  2132. -        return t0 == t1;
  2133. -    if (!strcmp(op,"-ne"))
  2134. -        return t0 != t1;
  2135. -    if (!strcmp(op,"-lt"))
  2136. -        return t0 < t1;
  2137. -    if (!strcmp(op,"-le"))
  2138. -        return t0 <= t1;
  2139. -    if (!strcmp(op,"-gt"))
  2140. -        return t0 > t1;
  2141. -    if (!strcmp(op,"-ge"))
  2142. -        return t0 >= t1;
  2143. -    if (!efg)
  2144. -        zerrnam("test","unrecognized operator: %s",op);
  2145. -    efg = 1;
  2146. -    return 0;
  2147. -}
  2148. -
  2149. -int doaccess(int c)
  2150. -{
  2151. -    if (!*arg)
  2152. -        {
  2153. -        die("filename expected");
  2154. -        return 0;
  2155. -        }
  2156. -    return !access(*arg++,c);
  2157. -}
  2158. -
  2159. -struct stat *getstat(void)
  2160. -{
  2161. -static struct stat st;
  2162. -
  2163. -    if (!*arg)
  2164. -        {
  2165. -        die("filename expected");
  2166. -        return NULL;
  2167. -        }
  2168. -    if (!strncmp(*arg,"/dev/fd/",8))
  2169. -        {
  2170. -        if (fstat(atoi((*arg++)+8),&st))
  2171. -            return NULL;
  2172. -        }
  2173. -    else if (lstat(*arg++,&st))
  2174. -        return NULL;
  2175. -    return &st;
  2176. -}
  2177. -
  2178. -unsigned short dostat(void)
  2179. -{
  2180. -struct stat *st;
  2181. -
  2182. -    if (!(st = getstat()))
  2183. -        return 0;
  2184. -    return st->st_mode;
  2185. -}
  2186. -
  2187. End of test.c
  2188. echo test.pro 1>&2
  2189. sed 's/^-//' >test.pro <<'End of test.pro'
  2190. -void die(char *str);
  2191. -int test(comm comm);
  2192. -int testmain(char **argv);
  2193. -int testexpr(void);
  2194. -int testexpr2(void);
  2195. -int testexpr3(void);
  2196. -int testexpr4(void);
  2197. -int doaccess(int c);
  2198. -struct stat *getstat(void);
  2199. -unsigned short dostat(void);
  2200. End of test.pro
  2201. echo utils.c 1>&2
  2202. sed 's/^-//' >utils.c <<'End of utils.c'
  2203. -/*
  2204. -
  2205. -    utils.c - miscellaneous utilities
  2206. -
  2207. -    This file is part of zsh, the Z shell.
  2208. -
  2209. -   zsh is free software; no one can prevent you from reading the source
  2210. -   code, or giving it to someone else.
  2211. -   This file is copyrighted under the GNU General Public License, which
  2212. -   can be found in the file called COPYING.
  2213. -
  2214. -   Copyright (C) 1990 Paul Falstad
  2215. -
  2216. -   zsh is distributed in the hope that it will be useful, but
  2217. -   WITHOUT ANY WARRANTY.  No author or distributor accepts
  2218. -   responsibility to anyone for the consequences of using it or for
  2219. -   whether it serves any particular purpose or works at all, unless he
  2220. -   says so in writing.  Refer to the GNU General Public License
  2221. -   for full details.
  2222. -
  2223. -   Everyone is granted permission to copy, modify and redistribute
  2224. -   zsh, but only under the conditions described in the GNU General Public
  2225. -   License.   A copy of this license is supposed to have been given to you
  2226. -   along with zsh so you can know your rights and responsibilities.
  2227. -   It should be in a file named COPYING.
  2228. -
  2229. -   Among other things, the copyright notice and this notice must be
  2230. -   preserved on all copies.
  2231. -
  2232. -*/
  2233. -
  2234. -#include "zsh.h"
  2235. -#include "funcs.h"
  2236. -#include <pwd.h>
  2237. -#include <stdarg.h> /* had to change this to stdarg.h.old on one machine */
  2238. -#include <errno.h>
  2239. -#include <sys/dir.h>
  2240. -#include <fcntl.h>
  2241. -
  2242. -/* add vars to the parm hash table */
  2243. -
  2244. -void addvars(table vars)
  2245. -{
  2246. -char *s1,*s2;
  2247. -Node node;
  2248. -
  2249. -    for (node = vars->first; node; node = node->next)
  2250. -        {
  2251. -        s1 = node->dat;
  2252. -        untokenize(s1);
  2253. -        node = node->next;
  2254. -        s2 = node->dat;
  2255. -        dovarsubs(&s2);
  2256. -        if (errflag)
  2257. -            break;
  2258. -        untokenize(s2);
  2259. -        setparm(s1,s2,0,0);
  2260. -        }
  2261. -    free(vars);
  2262. -}
  2263. -
  2264. -/* set a parameter to an integer value */
  2265. -
  2266. -void setiparm(char *s,long v,int isint)
  2267. -{
  2268. -struct pmnode *pmn,*pmo;
  2269. -
  2270. -    if (!strcmp(s,"RANDOM"))
  2271. -        {
  2272. -        srand((unsigned long) v);
  2273. -        return;
  2274. -        }
  2275. -    if (!strcmp(s,"SECONDS"))
  2276. -        {
  2277. -        shtimer = v+time(NULL);
  2278. -        return;
  2279. -        }
  2280. -    if (pmo = gethnode(s,parmhtab))
  2281. -        {
  2282. -        char buf[12];
  2283. -
  2284. -        pmn = alloc(sizeof *pmn);
  2285. -        if (pmn->isint = pmo->isint | isint)
  2286. -            pmn->u.val = v;
  2287. -        else
  2288. -            {
  2289. -            sprintf(buf,"%ld",v);
  2290. -            pmn->u.str = strdup(buf);
  2291. -            }
  2292. -        addhnode(s,pmn,parmhtab,freepm);
  2293. -        }
  2294. -    else if (getenv(s) || (opts[ALLEXPORT] == OPT_SET))
  2295. -        {
  2296. -        char buf[12];
  2297. -
  2298. -        sprintf(buf,"%ld",v);
  2299. -        putenv(tricat(s,"=",buf));
  2300. -        }
  2301. -    else
  2302. -        {
  2303. -        char buf[12];
  2304. -
  2305. -        pmn = alloc(sizeof *pmn);
  2306. -        if (pmn->isint = isint)
  2307. -            pmn->u.val = v;
  2308. -        else
  2309. -            {
  2310. -            sprintf(buf,"%ld",v);
  2311. -            pmn->u.str = strdup(buf);
  2312. -            }
  2313. -        addhnode(s,pmn,parmhtab,freepm);
  2314. -        addlocal(s);
  2315. -        }
  2316. -    if (!strcmp(s,"PERIOD"))
  2317. -        {
  2318. -        period = v*60;
  2319. -        lastperiod = time(NULL)+period;
  2320. -        }
  2321. -    if (!strcmp(s,"HISTSIZE"))
  2322. -        {
  2323. -        tevs = v;
  2324. -        if (tevs <= 2)
  2325. -            tevs = 2;
  2326. -        }
  2327. -}
  2328. -
  2329. -/* set a parameter to a string value */
  2330. -
  2331. -void setparm(char *s,char *t,int ex,int isint)
  2332. -{
  2333. -struct pmnode *pmn,*pmo;
  2334. -
  2335. -    if (!strcmp(s,"RANDOM"))
  2336. -        {
  2337. -        srand((unsigned long) atol(t));
  2338. -        return;
  2339. -        }
  2340. -    if (!strcmp(s,"SECONDS"))
  2341. -        {
  2342. -        shtimer = atol(t)+time(NULL);
  2343. -        return;
  2344. -        }
  2345. -    if (ex && gethnode(s,parmhtab))
  2346. -        freepm(remhnode(s,parmhtab));
  2347. -    if (pmo = gethnode(s,parmhtab))
  2348. -        {
  2349. -        pmn = alloc(sizeof *pmn);
  2350. -        if (pmn->isint = pmo->isint | isint)
  2351. -            {
  2352. -            pmn->u.val = matheval(t);
  2353. -            free(t);
  2354. -            t = NULL;
  2355. -            }
  2356. -        else
  2357. -            pmn->u.str = t;
  2358. -        addhnode(s,pmn,parmhtab,freepm);
  2359. -        }
  2360. -    else if (ex || getenv(s) || (opts[ALLEXPORT] == OPT_SET))
  2361. -        putenv(tricat(s,"=",t));
  2362. -    else
  2363. -        {
  2364. -        pmn = alloc(sizeof *pmn);
  2365. -        if (pmn->isint = isint)
  2366. -            {
  2367. -            pmn->u.val = matheval(t);
  2368. -            free(t);
  2369. -            t = NULL;
  2370. -            }
  2371. -        else
  2372. -            pmn->u.str = t;
  2373. -        addhnode(s,pmn,parmhtab,freepm);
  2374. -#if 0
  2375. -        addlocal(s);
  2376. -#endif
  2377. -        }
  2378. -    if (!t)
  2379. -        return;
  2380. -    if (!strcmp(s,"PATH"))
  2381. -        parsepath();
  2382. -    if (!strcmp(s,"CDPATH"))
  2383. -        parsecdpath();
  2384. -    if (!strcmp(s,"IFS"))
  2385. -        {
  2386. -        free(ifs);
  2387. -        ifs = strdup(t);
  2388. -        }
  2389. -    if (!strcmp(s,"PERIOD"))
  2390. -        {
  2391. -        period = atoi(t)*60;
  2392. -        lastperiod = time(NULL)+period;
  2393. -        }
  2394. -    if (!strcmp(s,"HISTSIZE"))
  2395. -        {
  2396. -        tevs = atoi(t);
  2397. -        if (tevs <= 2)
  2398. -            tevs = 2;
  2399. -        }
  2400. -    if (!strcmp(s,"HOME"))
  2401. -        {
  2402. -        free(home);
  2403. -        home = xsymlink(t);
  2404. -        }
  2405. -    if (!strcmp(s,"MAIL") || !strcmp(s,"MAILCHECK") || !strcmp(s,"MAILPATH"))
  2406. -        lastmailcheck = 0;
  2407. -}
  2408. -
  2409. -void unsetparm(char *s)
  2410. -{
  2411. -char **pp;
  2412. -
  2413. -    if (!strcmp(s,"HOME"))
  2414. -        return;
  2415. -    if (!strcmp(s,"PERIOD"))
  2416. -        period = 0;
  2417. -    if (!strcmp(s,"HISTSIZE"))
  2418. -        tevs = 1;
  2419. -    if (gethnode(s,parmhtab))
  2420. -        {
  2421. -        freepm(remhnode(s,parmhtab));
  2422. -        return;
  2423. -        }
  2424. -    for (pp = environ; *pp; pp++)
  2425. -        if (!strncmp(*pp,s,strlen(s)) && (*pp)[strlen(s)] == '=')
  2426. -            {
  2427. -            while (pp[0] = pp[1])
  2428. -                pp++;
  2429. -            return;
  2430. -            }
  2431. -}
  2432. -
  2433. -/* get the integer value of a parameter */
  2434. -
  2435. -long getiparm(char *s)
  2436. -{
  2437. -struct pmnode *pmn;
  2438. -char *t;
  2439. -
  2440. -    if (!isalpha(*s) && !s[1])
  2441. -        {
  2442. -        t = getsparmval(s,1);
  2443. -        return (t) ? atoi(t) : 0;
  2444. -        }
  2445. -    if (s[0] == 'T' && s[1] == 'C' && !s[4])    /* TCxx */
  2446. -        return tgetnum(s+2);
  2447. -    if (!strcmp(s,"RANDOM"))
  2448. -        return rand() & 0x7fff;
  2449. -    if (!strcmp(s,"LINENO"))
  2450. -        return lineno;
  2451. -    if (!strcmp(s,"SECONDS"))
  2452. -        return time(NULL)-shtimer;
  2453. -    if (pmn = gethnode(s,parmhtab))
  2454. -        {
  2455. -        if (pmn->isint)
  2456. -            return pmn->u.val;
  2457. -        return atol(pmn->u.str);
  2458. -        }
  2459. -    return atol(getenv(s));
  2460. -}
  2461. -
  2462. -/* get the string value of a parameter */
  2463. -
  2464. -char *getparm(char *s)
  2465. -{
  2466. -struct pmnode *pmn;
  2467. -
  2468. -    if (!isalpha(*s) && !s[1])
  2469. -        return getsparmval(s,1);
  2470. -    if (s[0] == 'T' && s[1] == 'C' && !s[4])    /* TCxx */
  2471. -        {
  2472. -        static char buf[1024];
  2473. -        char *ss = buf;
  2474. -        int t0;
  2475. -
  2476. -        if (tgetstr(s+2,&ss))
  2477. -            return buf;
  2478. -        if ((t0 = tgetnum(s+2)) != -1)
  2479. -            {
  2480. -            sprintf(buf,"%d",t0);
  2481. -            return buf;
  2482. -            }
  2483. -        return NULL;
  2484. -        }
  2485. -    if (!strcmp(s,"LINENO"))
  2486. -        {
  2487. -        static char buf[8];
  2488. -
  2489. -        sprintf(buf,"%d",lineno);
  2490. -        return buf;
  2491. -        }
  2492. -    if (!strcmp(s,"RANDOM"))
  2493. -        {
  2494. -        static char buf[8];
  2495. -
  2496. -        sprintf(buf,"%d",rand() & 0x7fff);
  2497. -        return buf;
  2498. -        }
  2499. -    if (!strcmp(s,"SECONDS"))
  2500. -        {
  2501. -        static char buf[12];
  2502. -
  2503. -        sprintf(buf,"%ld",time(NULL)-shtimer);
  2504. -        return buf;
  2505. -        }
  2506. -    if (pmn = gethnode(s,parmhtab))
  2507. -        {
  2508. -        static char buf[12];
  2509. -
  2510. -        if (pmn->isint)
  2511. -            {
  2512. -            sprintf(buf,"%ld",pmn->u.val);
  2513. -            return buf;
  2514. -            }
  2515. -        return pmn->u.str;
  2516. -        }
  2517. -    return getenv(s);
  2518. -}
  2519. -
  2520. -/* parse the PATH parameter into directory names in a array of
  2521. -    strings and create the command hash table */
  2522. -
  2523. -void parsepath(void)
  2524. -{
  2525. -char *pptr = getparm("PATH"),*ptr;
  2526. -
  2527. -    if (path)
  2528. -        {
  2529. -        while(pathct)
  2530. -            free(path[--pathct]);
  2531. -        free(path);
  2532. -        }
  2533. -    for (pathct = 1, ptr = pptr; *ptr; ptr++)
  2534. -        if (*ptr == ':')
  2535. -            pathct++;
  2536. -    path = (char **) zalloc(pathct*sizeof(char *));
  2537. -    pathct = 0;
  2538. -    ptr = pptr;
  2539. -    while(pptr)
  2540. -        {
  2541. -        ptr = strchr(pptr,':');
  2542. -        if (ptr)
  2543. -            *ptr = '\0';
  2544. -        path[pathct] = strdup(pptr);
  2545. -        if (ptr)
  2546. -            {
  2547. -            *ptr = ':';
  2548. -            pptr = ptr+1;
  2549. -            }
  2550. -        else
  2551. -            pptr = NULL;
  2552. -        if (!*path[pathct])
  2553. -            {
  2554. -            free(path[pathct]);
  2555. -            path[pathct] = strdup(".");
  2556. -            }
  2557. -        pathsub(&path[pathct]);
  2558. -        if (*path[pathct] != '/' && strcmp(path[pathct],"."))
  2559. -            {
  2560. -#ifdef PATH_WARNINGS
  2561. -            zerr("PATH component not absolute pathname: %s",path[pathct]);
  2562. -#endif
  2563. -            free(path[pathct--]);
  2564. -            }
  2565. -        pathct++;
  2566. -        }
  2567. -    createchtab();
  2568. -}
  2569. -
  2570. -void parsecdpath(void)
  2571. -{
  2572. -char *pptr = getparm("CDPATH"),*ptr;
  2573. -
  2574. -    if (cdpath)
  2575. -        {
  2576. -        while(cdpathct)
  2577. -            free(cdpath[--cdpathct]);
  2578. -        free(cdpath);
  2579. -        }
  2580. -    if (pptr == NULL)
  2581. -        {
  2582. -        cdpath = (char **) zalloc(sizeof(char *));
  2583. -        cdpath[0] = strdup(".");
  2584. -        cdpathct = 1;
  2585. -        return;
  2586. -        }
  2587. -    for (cdpathct = 2, ptr = pptr; *ptr; ptr++)
  2588. -        if (*ptr == ':')
  2589. -            cdpathct++;
  2590. -    cdpath = (char **) zalloc(cdpathct*sizeof(char *));
  2591. -    cdpath[0] = strdup(".");
  2592. -    cdpathct = 1;
  2593. -    ptr = pptr;
  2594. -    while (pptr)
  2595. -        {
  2596. -        ptr = strchr(pptr,':');
  2597. -        if (ptr)
  2598. -            *ptr = '\0';
  2599. -        cdpath[cdpathct] = strdup(pptr);
  2600. -        if (ptr)
  2601. -            {
  2602. -            *ptr = ':';
  2603. -            pptr = ptr+1;
  2604. -            }
  2605. -        else
  2606. -            pptr = NULL;
  2607. -        pathsub(&cdpath[cdpathct]);
  2608. -        if (*cdpath[cdpathct] != '/')
  2609. -            {
  2610. -#ifdef PATH_WARNINGS
  2611. -            zerr("CDPATH component not absolute pathname: %s",cdpath[cdpathct]);
  2612. -#endif
  2613. -            free(cdpath[cdpathct--]);
  2614. -            }
  2615. -        cdpathct++;
  2616. -        }
  2617. -}
  2618. -
  2619. -/* source a file */
  2620. -
  2621. -int source(char *s)
  2622. -{
  2623. -int fd,cj = curjob,iact = opts[INTERACTIVE];
  2624. -FILE *obshin = bshin;
  2625. -
  2626. -    fd = SHIN;
  2627. -    opts[INTERACTIVE] = OPT_UNSET;
  2628. -    if ((SHIN = movefd(open(s,O_RDONLY))) == -1)
  2629. -        {
  2630. -        SHIN = fd;
  2631. -        curjob = cj;
  2632. -        opts[INTERACTIVE] = iact;
  2633. -        return 1;
  2634. -        }
  2635. -    bshin = fdopen(SHIN,"r");
  2636. -    loop();
  2637. -    fclose(bshin);
  2638. -    opts[INTERACTIVE] = iact;
  2639. -    bshin = obshin;
  2640. -    SHIN = fd;
  2641. -    peek = EMPTY;
  2642. -    curjob = cj;
  2643. -    errflag = 0;
  2644. -    retflag = 0;
  2645. -    return 0;
  2646. -}
  2647. -
  2648. -/* try to source a file in our home directory */
  2649. -
  2650. -void sourcehome(char *s)
  2651. -{
  2652. -char buf[MAXPATHLEN];
  2653. -
  2654. -    sprintf(buf,"%s/%s",getparm("HOME"),s);
  2655. -    (void) source(buf);
  2656. -}
  2657. -
  2658. -/* print an error */
  2659. -
  2660. -void zerrnam(char *cmd, char *fmt, ...)
  2661. -{
  2662. -va_list ap;
  2663. -char *str;
  2664. -int num;
  2665. -
  2666. -    va_start(ap,fmt);
  2667. -    fputs(cmd,stderr);
  2668. -    putc(':',stderr);
  2669. -    putc(' ',stderr);
  2670. -    while (*fmt)
  2671. -        if (*fmt == '%')
  2672. -            {
  2673. -            fmt++;
  2674. -            switch(*fmt++)
  2675. -                {
  2676. -                case 's':    /* string */
  2677. -                    str = va_arg(ap,char *);
  2678. -                    while (*str)
  2679. -                        niceputc(*str++,stderr);
  2680. -                    break;
  2681. -                case 'l':    /* string with a length */
  2682. -                    num = va_arg(ap,int);
  2683. -                    str = va_arg(ap,char *);
  2684. -                    while (num--)
  2685. -                        niceputc(*str++,stderr);
  2686. -                    break;
  2687. -                case 'd':    /* number */
  2688. -                    num = va_arg(ap,int);
  2689. -                    fprintf(stderr,"%d",num);
  2690. -                    break;
  2691. -                case '%':
  2692. -                    putc('%',stderr);
  2693. -                    break;
  2694. -                case 'c':    /* char */
  2695. -                    num = va_arg(ap,int);
  2696. -                    niceputc(num,stderr);
  2697. -                    break;
  2698. -                case 'e':    /* system error */
  2699. -                    num = va_arg(ap,int);
  2700. -                    if (num == EINTR)
  2701. -                        {
  2702. -                        fputs("interrupt\n",stderr);
  2703. -                        errflag = 1;
  2704. -                        return;
  2705. -                        }
  2706. -                    fputc(tolower(sys_errlist[num][0]),stderr);
  2707. -                    fputs(sys_errlist[num]+1,stderr);
  2708. -                    break;
  2709. -                }
  2710. -            }
  2711. -        else
  2712. -            putc(*fmt++,stderr);
  2713. -    putc('\n',stderr);
  2714. -    va_end(ap);
  2715. -}
  2716. -
  2717. -void zerr(char *fmt,...)
  2718. -{
  2719. -va_list ap;
  2720. -char *str;
  2721. -int num;
  2722. -
  2723. -    va_start(ap,fmt);
  2724. -    fputs("zsh: ",stderr);
  2725. -    while (*fmt)
  2726. -        if (*fmt == '%')
  2727. -            {
  2728. -            fmt++;
  2729. -            switch(*fmt++)
  2730. -                {
  2731. -                case 's':
  2732. -                    str = va_arg(ap,char *);
  2733. -                    while (*str)
  2734. -                        niceputc(*str++,stderr);
  2735. -                    break;
  2736. -                case 'l':
  2737. -                    num = va_arg(ap,int);
  2738. -                    str = va_arg(ap,char *);
  2739. -                    while (num--)
  2740. -                        niceputc(*str++,stderr);
  2741. -                    break;
  2742. -                case 'd':
  2743. -                    num = va_arg(ap,int);
  2744. -                    fprintf(stderr,"%d",num);
  2745. -                    break;
  2746. -                case '%':
  2747. -                    putc('%',stderr);
  2748. -                    break;
  2749. -                case 'c':
  2750. -                    num = va_arg(ap,int);
  2751. -                    niceputc(num,stderr);
  2752. -                    break;
  2753. -                case 'e':
  2754. -                    num = va_arg(ap,int);
  2755. -                    if (num == EINTR)
  2756. -                        {
  2757. -                        fputs("interrupt\n",stderr);
  2758. -                        errflag = 1;
  2759. -                        return;
  2760. -                        }
  2761. -                    fputc(tolower(sys_errlist[num][0]),stderr);
  2762. -                    fputs(sys_errlist[num]+1,stderr);
  2763. -                    break;
  2764. -                }
  2765. -            }
  2766. -        else
  2767. -            putc(*fmt++,stderr);
  2768. -    putc('\n',stderr);
  2769. -    va_end(ap);
  2770. -}
  2771. -
  2772. -void niceputc(int c,FILE *f)
  2773. -{
  2774. -    if (istok(c))
  2775. -        {
  2776. -        if (c >= Pound && c <= Qtick)
  2777. -            putc(tokens[c-Pound],f);
  2778. -        return;
  2779. -        }
  2780. -    c &= 0x7f;
  2781. -    if (c >= ' ' && c < '\x7f')
  2782. -        putc(c,f);
  2783. -    else if (c == '\n')
  2784. -        {
  2785. -        putc('\\',f);
  2786. -        putc('n',f);
  2787. -        }
  2788. -    else
  2789. -        {
  2790. -        putc('^',f);
  2791. -        putc(c|'A',f);
  2792. -        }
  2793. -}
  2794. -
  2795. -/* enable ^C interrupts */
  2796. -
  2797. -void intr(void)
  2798. -{
  2799. -struct sigvec vec = { handler,sigmask(SIGINT),SV_INTERRUPT };
  2800. -    
  2801. -    if (interact)
  2802. -        sigvec(SIGINT,&vec,NULL);
  2803. -    sigsetmask(0);
  2804. -}
  2805. -
  2806. -void noholdintr(void)
  2807. -{
  2808. -    intr();
  2809. -}
  2810. -
  2811. -void holdintr(void)
  2812. -{
  2813. -struct sigvec vec = { handler,sigmask(SIGINT),0 };
  2814. -
  2815. -    if (interact)
  2816. -        {
  2817. -        sigvec(SIGINT,&vec,NULL);
  2818. -        sigsetmask(0);
  2819. -        }
  2820. -}
  2821. -
  2822. -char *fgetline(char *buf,int len,FILE *in)
  2823. -{
  2824. -    if (!fgets(buf,len,in))
  2825. -        return NULL;
  2826. -    buf[len] = '\0';
  2827. -    buf[strlen(buf)-1] = '\0';
  2828. -    return buf;
  2829. -}
  2830. -
  2831. -/* get a symlink-free pathname for s relative to PWD */
  2832. -
  2833. -char *findcwd(char *s)
  2834. -{
  2835. -char *t;
  2836. -
  2837. -    if (*s == '/')
  2838. -        return xsymlink(s);
  2839. -    s = tricat((cwd[1]) ? cwd : "","/",s);
  2840. -    t = xsymlink(s);
  2841. -    free(s);
  2842. -    return t;
  2843. -}
  2844. -
  2845. -static char xbuf[MAXPATHLEN];
  2846. -
  2847. -/* expand symlinks in s, and remove other weird things */
  2848. -
  2849. -char *xsymlink(char *s)
  2850. -{
  2851. -    if (*s != '/')
  2852. -        return NULL;
  2853. -    strcpy(xbuf,"");
  2854. -    if (xsymlinks(s+1))
  2855. -        return strdup(s);
  2856. -    if (!*xbuf)
  2857. -        return strdup("/");
  2858. -    return strdup(xbuf);
  2859. -}
  2860. -
  2861. -char **slashsplit(char *s)
  2862. -{
  2863. -char *t,**r,**q;
  2864. -int t0;
  2865. -
  2866. -    if (!*s)
  2867. -        return (char **) calloc(sizeof(char **),1);
  2868. -    for (t = s, t0 = 0; *t; t++)
  2869. -        if (*t == '/')
  2870. -            t0++;
  2871. -    q  = r = (char **) zalloc(sizeof(char **)*(t0+2));
  2872. -    while (t = strchr(s,'/'))
  2873. -        {
  2874. -        *t = '\0';
  2875. -        *q++ = strdup(s);
  2876. -        *t = '/';
  2877. -        while (*t == '/')
  2878. -            t++;
  2879. -        if (!*t)
  2880. -            {
  2881. -            *q = NULL;
  2882. -            return r;
  2883. -            }
  2884. -        s = t;
  2885. -        }
  2886. -    *q++ = strdup(s);
  2887. -    *q = NULL;
  2888. -    return r;
  2889. -}
  2890. -
  2891. -int islink(char *s)
  2892. -{
  2893. -char xbuf[MAXPATHLEN];
  2894. -
  2895. -    if (readlink(s,xbuf,1) == -1 && errno == EINVAL)
  2896. -        return 0;
  2897. -    return 1;
  2898. -}
  2899. -
  2900. -int xsymlinks(char *s)
  2901. -{
  2902. -char **pp,**opp;
  2903. -char xbuf2[MAXPATHLEN],xbuf3[MAXPATHLEN];
  2904. -int t0;
  2905. -
  2906. -    opp = pp = slashsplit(s);
  2907. -    for (; *pp; pp++)
  2908. -        {
  2909. -        if (!strcmp(*pp,"."))
  2910. -            {
  2911. -            free(*pp);
  2912. -            continue;
  2913. -            }
  2914. -        if (!strcmp(*pp,".."))
  2915. -            {
  2916. -            char *p;
  2917. -
  2918. -            free(*pp);
  2919. -            if (!strcmp(xbuf,"/"))
  2920. -                continue;
  2921. -            p = xbuf+strlen(xbuf);
  2922. -            while (*--p != '/');
  2923. -            *p = '\0';
  2924. -            continue;
  2925. -            }
  2926. -        sprintf(xbuf2,"%s/%s",xbuf,*pp);
  2927. -        t0 = readlink(xbuf2,xbuf3,MAXPATHLEN);
  2928. -        if (t0 == -1)
  2929. -            {
  2930. -            if (errno != EINVAL)
  2931. -                {
  2932. -                while (*pp)
  2933. -                    free(*pp++);
  2934. -                free(opp);
  2935. -                return 1;
  2936. -                }
  2937. -            strcat(xbuf,"/");
  2938. -            strcat(xbuf,*pp);
  2939. -            free(*pp);
  2940. -            }
  2941. -        else
  2942. -            {
  2943. -            xbuf3[t0] = '\0'; /* STUPID */
  2944. -            if (*xbuf3 == '/')
  2945. -                {
  2946. -                strcpy(xbuf,"");
  2947. -                if (xsymlinks(xbuf3+1))
  2948. -                    return 1;
  2949. -                }
  2950. -            else
  2951. -                if (xsymlinks(xbuf3))
  2952. -                    return 1;
  2953. -            free(*pp);
  2954. -            }
  2955. -        }
  2956. -    free(opp);
  2957. -    return 0;
  2958. -}
  2959. -
  2960. -void printdir(char *s)
  2961. -{
  2962. -int t0;
  2963. -
  2964. -    if (!strncmp(s,home,t0 = strlen(home)))
  2965. -        {
  2966. -        putchar('~');
  2967. -        fputs(s+t0,stdout);
  2968. -        }
  2969. -    else
  2970. -        fputs(s,stdout);
  2971. -}
  2972. -
  2973. -
  2974. -int ddifftime(time_t t1,time_t t2)
  2975. -{
  2976. -    return ((long) t2-(long) t1);
  2977. -}
  2978. -
  2979. -/* see if jobs need printing */
  2980. -
  2981. -void scanjobs(void)
  2982. -{
  2983. -int t0;
  2984. -
  2985. -    for (t0 = 1; t0 != MAXJOB; t0++)
  2986. -        if (jobtab[t0].stat & STAT_CHANGED)
  2987. -            printjob(jobtab+t0,0);
  2988. -}
  2989. -
  2990. -/* do pre-prompt stuff */
  2991. -
  2992. -void preprompt(void)
  2993. -{
  2994. -int diff;
  2995. -list list;
  2996. -char *mc = getparm("MAILCHECK"),*wc = getparm("LOGCHECK");
  2997. -struct schnode *sch,*schl;
  2998. -
  2999. -    if (unset(NOTIFY))
  3000. -        scanjobs();
  3001. -    if (errflag)
  3002. -        return;
  3003. -    if (list = gethnode("precmd",shfunchtab))
  3004. -        newrunlist(list);
  3005. -    if (errflag)
  3006. -        return;
  3007. -    if (period && (time(NULL) > lastperiod+period) &&
  3008. -            (list = gethnode("periodic",shfunchtab)))
  3009. -        {
  3010. -        newrunlist(list);
  3011. -        lastperiod = time(NULL);
  3012. -        }
  3013. -    if (errflag)
  3014. -        return;
  3015. -    if (getparm("WATCH"))
  3016. -        {
  3017. -        diff = (int) ddifftime(lastwatch,time(NULL));
  3018. -        if (diff > ((wc) ? atoi(wc)*60 : 300))
  3019. -            {
  3020. -            lastwatch = time(NULL);
  3021. -            watch();
  3022. -            }
  3023. -        }
  3024. -    if (errflag)
  3025. -        return;
  3026. -    diff = (int) ddifftime(lastmailcheck,time(NULL));
  3027. -    if (diff > ((mc) ? atoi(mc) : 60))
  3028. -        {
  3029. -        lastmailcheck = time(NULL);
  3030. -        if (getparm("MAILPATH"))
  3031. -            checkmailpath();
  3032. -        else
  3033. -            checkmail();
  3034. -        }
  3035. -    for (schl = (struct schnode *) &scheds, sch = scheds; sch;
  3036. -            sch = (schl = sch)->next)
  3037. -        {
  3038. -        if (sch->time < time(NULL))
  3039. -            {
  3040. -            execstring(sch->cmd);
  3041. -            schl->next = sch->next;
  3042. -            free(sch);
  3043. -            }
  3044. -        if (errflag)
  3045. -            return;
  3046. -        }
  3047. -}
  3048. - 
  3049. -void checkmail(void)
  3050. -{
  3051. -struct stat st;
  3052. -char *s;
  3053. -
  3054. -    if (!(s = getparm("MAIL")))
  3055. -        return;
  3056. -    if (stat(s,&st) == -1)
  3057. -        {
  3058. -        if (errno != ENOENT)
  3059. -            zerr("%e: %s",errno,getparm("MAIL"));
  3060. -        lastmailval = 0;
  3061. -        lastmailsize = 0;
  3062. -        return;
  3063. -        }
  3064. -    else
  3065. -        if (lastmailval != -1 && lastmailval < st.st_mtime &&
  3066. -                lastmailsize < st.st_size)
  3067. -            zerr("you have new mail.");
  3068. -    lastmailval = st.st_mtime;
  3069. -    lastmailsize = st.st_size;
  3070. -}
  3071. -
  3072. -void checkfirstmail(void)
  3073. -{
  3074. -struct stat st;
  3075. -char *s;
  3076. -
  3077. -    if (!(s = getparm("MAIL")))
  3078. -        return;
  3079. -    if (stat(s,&st) == -1)
  3080. -        {
  3081. -        if (errno != ENOENT)
  3082. -            zerr("%e: %s",errno,getparm("MAIL"));
  3083. -        lastmailval = 0;
  3084. -        lastmailsize = 0;
  3085. -        return;
  3086. -        }
  3087. -    lastmailval = st.st_mtime;
  3088. -    lastmailsize = st.st_size;
  3089. -    zerr("you have mail.");
  3090. -}
  3091. - 
  3092. -void checkmailpath(void)
  3093. -{
  3094. -struct stat st;
  3095. -char *s = getparm("MAILPATH"),*v,*u,c,d;
  3096. -
  3097. -    for (;;)
  3098. -        {
  3099. -        for (v = s; *v && *v != '?' && *v != ':'; v++);
  3100. -        c = *v;
  3101. -        *v = '\0';
  3102. -        if (c != '?')
  3103. -            u = NULL;
  3104. -        else
  3105. -            {
  3106. -            for (u = v+1; *u && *u != ':'; u++);
  3107. -            d = *u;
  3108. -            *u = '\0';
  3109. -            }
  3110. -        if (stat(s,&st) == -1)
  3111. -            {
  3112. -            if (errno != ENOENT)
  3113. -                zerr("%e: %s",errno,getparm("MAIL"));
  3114. -            }
  3115. -        else
  3116. -            if (lastmailval != -1 && lastmailval < st.st_mtime &&
  3117. -                    lastmailsize < st.st_size)
  3118. -                if (!u)
  3119. -                    fprintf(stderr,"You have new mail.\n");
  3120. -                else
  3121. -                    {
  3122. -                    char *z = u;
  3123. -
  3124. -                    while (*z)
  3125. -                        if (*z == '$' && z[1] == '_')
  3126. -                            {
  3127. -                            fprintf(stderr,"%s",s);
  3128. -                            z += 2;
  3129. -                            }
  3130. -                        else
  3131. -                            fputc(*z++,stderr);
  3132. -                    fputc('\n',stderr);
  3133. -                    }
  3134. -        lastmailval = st.st_mtime;
  3135. -        lastmailsize = st.st_size;
  3136. -        *v = c;
  3137. -        if (u)
  3138. -            *u = d;
  3139. -        if (!c || (u && !d))
  3140. -            break;
  3141. -        v = (u) ? u+1 : v+1;
  3142. -        }
  3143. -}
  3144. -
  3145. -/* create command hash table */
  3146. -
  3147. -void createchtab(void)
  3148. -{
  3149. -int t0,dot = 0;
  3150. -struct direct *de;
  3151. -DIR *dir;
  3152. -struct chnode *cc;
  3153. -
  3154. -    holdintr();
  3155. -    if (chtab)
  3156. -        freehtab(chtab,freechnode);
  3157. -    chtab = newhtable(101);
  3158. -    for (t0 = 0; t0 != pathct; t0++)
  3159. -        if (!strcmp(".",path[t0]))
  3160. -            {
  3161. -            dot = 1;
  3162. -            break;
  3163. -            }
  3164. -    for (t0 = pathct-1; t0 >= 0; t0--)
  3165. -        if (!strcmp(".",path[t0]))
  3166. -            dot = 0;
  3167. -        else
  3168. -            {
  3169. -            dir = opendir(path[t0]);
  3170. -            if (!dir)
  3171. -                {
  3172. -                zerr("%e: %s",errno,path[t0]);
  3173. -                continue;
  3174. -                }
  3175. -            readdir(dir); readdir(dir);
  3176. -            while (de = readdir(dir))
  3177. -                {
  3178. -                cc = alloc(sizeof(struct chnode));
  3179. -                cc->type = (dot) ? EXCMD_POSTDOT : EXCMD_PREDOT;
  3180. -                cc->globstat = GLOB;
  3181. -                cc->u.nam = tricat(path[t0],"/",de->d_name);
  3182. -                addhnode(strdup(de->d_name),cc,chtab,freechnode);
  3183. -                }
  3184. -            closedir(dir);
  3185. -            }
  3186. -    addintern(chtab);
  3187. -    noholdintr();
  3188. -}
  3189. -
  3190. -void freechnode(void *a)
  3191. -{
  3192. -struct chnode *c = (struct chnode *) a;
  3193. -
  3194. -    if (c->type != BUILTIN)
  3195. -        free(c->u.nam);
  3196. -    free(c);
  3197. -}
  3198. -
  3199. -void freestr(void *a)
  3200. -{
  3201. -    free(a);
  3202. -}
  3203. -
  3204. -void freeanode(void *a)
  3205. -{
  3206. -struct anode *c = (struct anode *) a;
  3207. -
  3208. -    free(c->text);
  3209. -    free(c);
  3210. -}
  3211. -
  3212. -void freeredir(void *a)
  3213. -{
  3214. -struct fnode *f = (struct fnode *) a;
  3215. -
  3216. -    if (f)
  3217. -        {
  3218. -        if (f->type == HEREDOC)
  3219. -            close(f->u.fd2);
  3220. -        else
  3221. -            free(f->u.name);
  3222. -        free(f);
  3223. -        }
  3224. -}
  3225. -
  3226. -void freeshfunc(void *a)
  3227. -{
  3228. -    freelist((list) a);
  3229. -}
  3230. -
  3231. -void freepm(void *a)
  3232. -{
  3233. -struct pmnode *pm = a;
  3234. -
  3235. -    if (!pm->isint)
  3236. -        free(pm->u.str);
  3237. -    free(pm);
  3238. -}
  3239. -
  3240. -void restoretty(void)
  3241. -{
  3242. -    settyinfo(&shttyinfo);
  3243. -}
  3244. -
  3245. -void gettyinfo(struct ttyinfo *ti)
  3246. -{
  3247. -    if (jobbing)
  3248. -        {
  3249. -#ifndef BUGGY_GCC
  3250. -#ifdef TERMIOS
  3251. -        ioctl(SHTTY,TCGETS,&ti->termios);
  3252. -#else
  3253. -        ioctl(SHTTY,TIOCGETP,&ti->sgttyb);
  3254. -        ioctl(SHTTY,TIOCGETC,&ti->tchars);
  3255. -        ioctl(SHTTY,TIOCGLTC,&ti->ltchars);
  3256. -#endif
  3257. -        ioctl(SHTTY,TIOCGWINSZ,&ti->winsize);
  3258. -#else
  3259. -#ifdef TERMIOS
  3260. -        ioctl(SHTTY,    (    0x40000000    |((sizeof( struct termios)&0xff        )<<16)|('T'<<8)| 8)  ,&ti->termios);
  3261. -#else
  3262. -        ioctl(SHTTY,(0x40000000|((sizeof(struct sgttyb)&0x1fff)<<16)|
  3263. -            ('t'<<8)|8),&ti->sgttyb);
  3264. -        ioctl(SHTTY,(0x40000000|((sizeof(struct tchars)&0x1fff)<<16)|
  3265. -            ('t'<<8)|18),&ti->tchars);
  3266. -        ioctl(SHTTY,(0x40000000|((sizeof(struct ltchars)&0x1fff)<<16)|
  3267. -            ('t'<<8)|116),&ti->ltchars);
  3268. -#endif
  3269. -        ioctl(SHTTY,(    0x40000000    |((sizeof( struct winsize)&0xff        )<<16)|('t'<<8)| 104)     ,&ti->winsize);
  3270. -#endif
  3271. -        }
  3272. -}
  3273. -
  3274. -void settyinfo(struct ttyinfo *ti)
  3275. -{
  3276. -    if (jobbing)
  3277. -        {
  3278. -#ifndef BUGGY_GCC
  3279. -#ifdef TERMIOS
  3280. -        ioctl(SHTTY,TCSETS,&ti->termios);
  3281. -#else
  3282. -        ioctl(SHTTY,TIOCSETP,&ti->sgttyb);
  3283. -        ioctl(SHTTY,TIOCSETC,&ti->tchars);
  3284. -        ioctl(SHTTY,TIOCSLTC,&ti->ltchars);
  3285. -#endif
  3286. -        ioctl(SHTTY,TIOCSWINSZ,&ti->winsize);
  3287. -#else
  3288. -#ifdef TERMIOS
  3289. -        ioctl(SHTTY,    (    0x80000000    |((sizeof( struct termios)&0xff        )<<16)|('T'<<8)| 9)  ,&ti->termios);
  3290. -#else
  3291. -        ioctl(SHTTY,(0x80000000|((sizeof( struct sgttyb)&0x1fff)<<16)|
  3292. -            ('t'<<8)|9),&ti->sgttyb);
  3293. -        ioctl(SHTTY,(0x80000000|((sizeof(struct tchars)&0x1fff)<<16)|
  3294. -            ('t'<<8)|17),&ti->tchars);
  3295. -        ioctl(SHTTY,(0x80000000|((sizeof(struct ltchars)&0x1fff)<<16)|
  3296. -            ('t'<<8)|117),&ti->ltchars);
  3297. -#endif
  3298. -        ioctl(SHTTY,(    0x80000000    |((sizeof( struct winsize)&0xff        )<<16)|('t'<<8)| 103)     ,&ti->winsize);
  3299. -#endif
  3300. -        }
  3301. -}
  3302. -
  3303. -int zyztem(char *s,char *t)
  3304. -{
  3305. -#ifdef WAITPID
  3306. -int pid,statusp;
  3307. -
  3308. -    if (!(pid = fork()))
  3309. -        {
  3310. -        s = tricat(s," ",t);
  3311. -        execl("/bin/sh","sh","-c",s,(char *) 0);
  3312. -        _exit(1);
  3313. -        }
  3314. -    waitpid(pid,&statusp,WUNTRACED);
  3315. -    if (WIFEXITED(SP(statusp)))
  3316. -        return WEXITSTATUS(SP(statusp));
  3317. -    return 1;
  3318. -#else
  3319. -    if (!waitfork())
  3320. -        {
  3321. -        s = tricat(s," ",t);
  3322. -        execl("/bin/sh","sh","-c",s,(char *) 0);
  3323. -        _exit(1);
  3324. -        }
  3325. -    return 0;
  3326. -#endif
  3327. -}
  3328. -
  3329. -#ifndef WAITPID
  3330. -
  3331. -/* fork a process and wait for it to complete without confusing
  3332. -    the SIGCHLD handler */
  3333. -
  3334. -int waitfork(void)
  3335. -{
  3336. -int pipes[2];
  3337. -char x;
  3338. -
  3339. -    pipe(pipes);
  3340. -    if (!fork())
  3341. -        {
  3342. -        close(pipes[0]);
  3343. -        signal(SIGCHLD,SIG_DFL);
  3344. -        if (!fork())
  3345. -            return 0;
  3346. -        wait(NULL);
  3347. -        _exit(0);
  3348. -        }
  3349. -    close(pipes[1]);
  3350. -    read(pipes[0],&x,1);
  3351. -    close(pipes[0]);
  3352. -    return 1;
  3353. -}
  3354. -
  3355. -#endif
  3356. -
  3357. -/* move a fd to a place >= 10 */
  3358. -
  3359. -int movefd(int fd)
  3360. -{
  3361. -int fe;
  3362. -
  3363. -    if (fd == -1)
  3364. -        return fd;
  3365. -    if ((fe = dup(fd)) < 10)
  3366. -        fe = movefd(fe);
  3367. -    close(fd);
  3368. -    return fe;
  3369. -}
  3370. -
  3371. -/* move fd x to y */
  3372. -
  3373. -void redup(int x,int y)
  3374. -{
  3375. -    if (x != y)
  3376. -        {
  3377. -        dup2(x,y);
  3378. -        close(x);
  3379. -        }
  3380. -}
  3381. -
  3382. -void settrap(char *s,int empty)
  3383. -{
  3384. -int t0;
  3385. -
  3386. -    if (strncmp(s,"TRAP",4))
  3387. -        return;
  3388. -    for (t0 = 0; t0 != SIGCOUNT+2; t0++)
  3389. -        if (!strcmp(s+4,sigs[t0]))
  3390. -            {
  3391. -            if (jobbing && (t0 == SIGTTOU || t0 == SIGTSTP || t0 == SIGTTIN
  3392. -                    || t0 == SIGPIPE))
  3393. -                {
  3394. -                zerr("can't trap SIG%s in interactive shells",s);
  3395. -                return;
  3396. -                }
  3397. -            if (empty)
  3398. -                {
  3399. -                sigtrapped[t0] = 2;
  3400. -                if (t0 && t0 < SIGCOUNT && t0 != SIGCHLD)
  3401. -                    {
  3402. -                    signal(t0,SIG_IGN);
  3403. -                    sigtrapped[t0] = 2;
  3404. -                    }
  3405. -                }
  3406. -            else
  3407. -                {
  3408. -                if (t0 && t0 < SIGCOUNT && t0 != SIGCHLD)
  3409. -                    signal(t0,handler);
  3410. -                sigtrapped[t0] = 1;
  3411. -                }
  3412. -            return;
  3413. ---cut here---cut here---cut here---
  3414.