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