home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume23 / rc / part02 < prev    next >
Text File  |  1991-10-18  |  57KB  |  2,566 lines
  1. Newsgroups: comp.sources.misc
  2. From: byron@archone.tamu.edu (Byron Rakitzis)
  3. Subject:  v23i062:  rc - A Plan 9 shell reimplementation, v1.2, Part02/06
  4. Message-ID: <1991Oct18.034306.2126@sparky.imd.sterling.com>
  5. X-Md4-Signature: e40b03bf1de892a0f76ae6f7a5d1c497
  6. Date: Fri, 18 Oct 1991 03:43:06 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: byron@archone.tamu.edu (Byron Rakitzis)
  10. Posting-number: Volume 23, Issue 62
  11. Archive-name: rc/part02
  12. Environment: UNIX
  13. Supersedes: rc: Volume 20, Issue 10-13
  14.  
  15. #!/bin/sh
  16. # do not concatenate these parts, unpack them in order with /bin/sh
  17. # file execve.c continued
  18. #
  19. if test ! -r _shar_seq_.tmp; then
  20.     echo 'Please unpack part 1 first!'
  21.     exit 1
  22. fi
  23. (read Scheck
  24.  if test "$Scheck" != 2; then
  25.     echo Please unpack part "$Scheck" next!
  26.     exit 1
  27.  else
  28.     exit 0
  29.  fi
  30. ) < _shar_seq_.tmp || exit 1
  31. if test ! -f _shar_wnt_.tmp; then
  32.     echo 'x - still skipping execve.c'
  33. else
  34. echo 'x - continuing file execve.c'
  35. sed 's/^X//' << 'SHAR_EOF' >> 'execve.c' &&
  36. X
  37. /*
  38. X   NOTE: this file depends on a hack in footobar.c which places two free spots before
  39. X   av[][] so that execve does not have to call malloc.
  40. */
  41. X
  42. #include "rc.h"
  43. #include <errno.h>
  44. #include "lex.h"
  45. #include "open.h"
  46. X
  47. #define giveupif(x) { if (x) goto fail; }
  48. X
  49. int my_execve(const char *path, const char **av, const char **ev) {
  50. X    int fd, len, fst, snd, end;
  51. X    boolean noarg;
  52. X    char pb[256]; /* arbitrary but generous limit */
  53. X
  54. X    execve(path, av, ev);
  55. X
  56. X    if (errno != ENOEXEC)
  57. X        return -1;
  58. X
  59. X    fd = rc_open(path, FROM);
  60. X
  61. X    giveupif(fd < 0);
  62. X
  63. X    len = read(fd, pb, sizeof pb);
  64. X    close(fd);
  65. X
  66. X    /*
  67. X       This execve() rejects all scripts which don't begin with #!
  68. X       This may have to be changed on some systems.
  69. X    */
  70. X
  71. X    giveupif(len <= 0 || pb[0] != '#' || pb[1] != '!');
  72. X
  73. X    for (fst = 2; fst < len && (pb[fst] == ' ' || pb[fst] == '\t'); fst++)
  74. X        ; /* skip leading whitespace */
  75. X
  76. X    giveupif(fst == len);
  77. X
  78. X    for (snd = fst; snd < len && pb[snd] != ' ' && pb[snd] != '\t' && pb[snd] != '\n'; snd++)
  79. X        ; /* skip first arg */
  80. X
  81. X    giveupif(snd == len);
  82. X
  83. X    noarg = (pb[snd] == '\n');
  84. X
  85. X    pb[snd++] = '\0'; /* null terminate the first arg */
  86. X
  87. X    if (!noarg) {
  88. X        while (snd < len && (pb[snd] == ' ' || pb[snd] == '\t'))
  89. X            snd++; /* skip whitespace to second arg */
  90. X
  91. X        giveupif(snd == len);
  92. X
  93. X        noarg = (pb[snd] == '\n'); /* could have trailing whitespace after only one arg */
  94. X
  95. X        if (!noarg) {
  96. X            for (end = snd; end < len && pb[end] != ' ' && pb[end] != '\t' && pb[end] != '\n'; end++)
  97. X                ; /* skip to the end of the second arg */
  98. X
  99. X            giveupif(end == len);
  100. X
  101. X            if (pb[end] == '\n') {
  102. X                pb[end] = '\0'; /* null terminate the first arg */
  103. X            } else {        /* else check for a spurious third arg */
  104. X                pb[end++] = '\0';
  105. X
  106. X                while (end < len && (pb[end] == ' ' || pb[end] == '\t'))
  107. X                    end++;
  108. X
  109. X                giveupif(end == len || pb[end] != '\n');
  110. X            }
  111. X        }
  112. X    }
  113. X
  114. X    *av = path;
  115. X
  116. X    if (!noarg)
  117. X        *--av = pb + snd;
  118. X    *--av = pb + fst;
  119. X
  120. X    execve(*av, av, ev);
  121. X    return -1;
  122. X
  123. fail:    errno = ENOEXEC;
  124. X    return -1;
  125. }
  126. SHAR_EOF
  127. echo 'File execve.c is complete' &&
  128. chmod 0644 execve.c ||
  129. echo 'restore of execve.c failed'
  130. Wc_c="`wc -c < 'execve.c'`"
  131. test 2017 -eq "$Wc_c" ||
  132.     echo 'execve.c: original size 2017, current size' "$Wc_c"
  133. rm -f _shar_wnt_.tmp
  134. fi
  135. # ============= fn.c ==============
  136. if test -f 'fn.c' -a X"$1" != X"-c"; then
  137.     echo 'x - skipping fn.c (File already exists)'
  138.     rm -f _shar_wnt_.tmp
  139. else
  140. > _shar_wnt_.tmp
  141. echo 'x - extracting fn.c (Text)'
  142. sed 's/^X//' << 'SHAR_EOF' > 'fn.c' &&
  143. /*
  144. X   fn.c: functions for adding and deleting functions from the symbol table.
  145. X   Support for signal handlers is also found here.
  146. */
  147. X
  148. #include "rc.h"
  149. #include <signal.h>
  150. #ifdef PROTECT_JOB
  151. #include <sys/ioctl.h>
  152. #endif
  153. #include "utils.h"
  154. #include "status.h"
  155. #include "tree.h"
  156. #include "hash.h"
  157. #include "footobar.h"
  158. #include "walk.h"
  159. #include "nalloc.h"
  160. #include "sigmsgs.h"
  161. #include "builtins.h"
  162. #include "input.h"
  163. X
  164. static void fn_handler(int);
  165. X
  166. static Node *handlers[NUMOFSIGNALS], null_function;
  167. static boolean runexit = FALSE;
  168. X
  169. /* set signals to default values for rc. this means that interactive shells ignore SIGQUIT, etc. */
  170. X
  171. void inithandler() {
  172. X    if (interactive) {
  173. #ifdef PROTECT_JOB
  174. X        if (dashell) {
  175. X            extern int ioctl(int, long,...);
  176. X
  177. X            setpgrp(rc_pid, rc_pid);
  178. X            ioctl(2, TIOCSPGRP, &rc_pid);
  179. X        }
  180. #endif
  181. X
  182. X        signal(SIGINT, sig);
  183. X        if (!dashdee) {
  184. X            signal(SIGQUIT, SIG_IGN);
  185. X            handlers[SIGQUIT] = &null_function;
  186. X            signal(SIGTERM, SIG_IGN);
  187. X            handlers[SIGTERM] = &null_function;
  188. X        }
  189. X    }
  190. X    null_function.type = BODY;
  191. X    null_function.u[0].p = null_function.u[1].p = NULL;
  192. }
  193. X
  194. /* only run this in a child process! resets signals to their default values */
  195. X
  196. void setsigdefaults() {
  197. X    int i;
  198. X
  199. X    /*
  200. X       General housekeeping: (setsigdefaults happens after fork(), so it's a convenient
  201. X       place to clean up)
  202. X    */
  203. X
  204. X    interactive = FALSE;
  205. X    if (histstr != NULL) {    /* Close an open history file */
  206. X        close(histfd);
  207. X        histstr = NULL; /* But prevent re-closing of the same file-descriptor */
  208. X    }
  209. X
  210. X    /* Restore signals to SIG_DFL */
  211. X
  212. X    for (i = 1; i < NUMOFSIGNALS; i++) { /* signal 0 is never used (bogus) */
  213. X        if (handlers[i] != NULL) {
  214. X            handlers[i] = NULL;
  215. X            signal(i, SIG_DFL);
  216. X        }
  217. X    }
  218. X    signal(SIGINT, SIG_DFL); /* sigint is special because its handler is normally        */
  219. X                 /* set to NULL, which doesn't get caught in the above loop    */
  220. X    runexit = FALSE; /* No sigexit on subshells */
  221. }
  222. X
  223. /* rc's exit. if runexit is set, run the sigexit function. */
  224. X
  225. void rc_exit(int stat) {
  226. X    static char *sigexit[2] = { "sigexit", NULL };
  227. X
  228. X    if (runexit) {
  229. X        runexit = FALSE;
  230. X        funcall(sigexit);
  231. X        exit(getstatus());
  232. X    } else {
  233. X        exit(stat);
  234. X    }
  235. }
  236. X
  237. /* the signal handler for all functions. calls walk() */
  238. X
  239. static void fn_handler(int s) {
  240. X    if (s < 0 || s >= NUMOFSIGNALS)
  241. X        rc_error("unknown signal!?");
  242. X
  243. X    signal(s, fn_handler); /* sgi seems to require re-signalling */
  244. X    walk(handlers[s], TRUE);
  245. }
  246. X
  247. /*
  248. X   assign a function in Node form. Check to see if the function is also a signal, and set the
  249. X   signal vectors appropriately.
  250. */
  251. X
  252. void fnassign(char *name, Node *def) {
  253. X    Node *newdef = treecpy(def == NULL ? &null_function : def, ealloc); /* important to do the treecopy first */
  254. X    Function *new = get_fn_place(name);
  255. X    int i;
  256. X
  257. X    new->def = newdef;
  258. X    new->extdef = NULL;
  259. X
  260. X    if (strncmp(name, "sig", sizeof "sig" - 3) == 0) { /* slight optimization */
  261. #ifdef NOSIGCLD /* System V machines treat SIGCLD very specially */
  262. X        if (streq(name, "sigcld"))
  263. X            rc_error("can't trap SIGCLD");
  264. #endif
  265. X        if (streq(name, "sigexit"))
  266. X            runexit = TRUE;
  267. X        for (i = 1; i < NUMOFSIGNALS; i++) /* zero is a bogus signal */
  268. X            if (streq(signals[i][0], name)) {
  269. X                if (newdef != NULL) {
  270. X                    handlers[i] = newdef;
  271. X                    signal(i, fn_handler);
  272. X                } else {
  273. X                    handlers[i] = &null_function;
  274. X                    signal(i, SIG_IGN);
  275. X                }
  276. X                break;
  277. X            }
  278. X    }
  279. }
  280. X
  281. /* assign a function from the environment. store just the external representation */
  282. X
  283. void fnassign_string(char *extdef) {
  284. X    char *name = get_name(extdef+3); /* +3 to skip over "fn_" */
  285. X    Function *new;
  286. X
  287. X    if (name == NULL)
  288. X        return;
  289. X
  290. X    new = get_fn_place(name);
  291. X    new->def = NULL;
  292. X    new->extdef = ecpy(extdef);
  293. }
  294. X
  295. /* return a function in Node form, evaluating an entry from the environment if necessary */
  296. X
  297. Node *fnlookup(char *name) {
  298. X    Function *look = lookup_fn(name);
  299. X    Node *ret;
  300. X
  301. X    if (look == NULL)
  302. X        return NULL; /* not found */
  303. X    if (look->def != NULL)
  304. X        return look->def;
  305. X    if (look->extdef == NULL) /* function was set to null, e.g., fn foo {} */
  306. X        return &null_function;
  307. X
  308. X    ret = parse_fn(name, look->extdef);
  309. X
  310. X    if (ret == NULL) {
  311. X        efree(look->extdef);
  312. X        look->extdef = NULL;
  313. X        return &null_function;
  314. X    } else {
  315. X        return look->def = treecpy(ret, ealloc); /* Need to take it out of talloc space */
  316. X    }
  317. }
  318. X
  319. /* return a function in string form (used by makeenv) */
  320. X
  321. char *fnlookup_string(char *name) {
  322. X    Function *look = lookup_fn(name);
  323. X
  324. X    if (look == NULL)
  325. X        return NULL;
  326. X    if (look->extdef != NULL)
  327. X        return look->extdef;
  328. X    return look->extdef = fun2str(name, look->def);
  329. }
  330. X
  331. /*
  332. X   remove a function from the symbol table. If it also defines a signal handler, restore the signal handler
  333. X   to its default value.
  334. */
  335. X
  336. void fnrm(char *name) {
  337. X    int i;
  338. X
  339. X    for (i = 1; i < NUMOFSIGNALS; i++) /* signal 0 unused */
  340. X        if (streq(signals[i][0], name)) {
  341. X            handlers[i] = NULL;
  342. X            if (i == SIGINT)
  343. X                signal(i, sig); /* restore default signal handler for rc */
  344. X            else if ((i == SIGQUIT || i == SIGTERM) && !dashdee) {
  345. X                handlers[i] = &null_function;
  346. X                signal(i, SIG_IGN);     /* ditto */
  347. X            } else {
  348. X                signal(i, SIG_DFL);
  349. X            }
  350. X        }
  351. X
  352. X    if (streq(name, "sigexit"))
  353. X        runexit = FALSE;
  354. X
  355. X    delete_fn(name);
  356. }
  357. X
  358. void whatare_all_signals() {
  359. X    int i;
  360. X
  361. X    for (i = 1; i < NUMOFSIGNALS; i++)
  362. X        if (*signals[i][0] != '\0')
  363. X            if (handlers[i] == NULL)
  364. X                fprint(1, "fn %s\n", signals[i][0]);
  365. X            else
  366. X                fprint(1, "fn %s {%s}\n", strprint(signals[i][0], FALSE, FALSE), ptree(handlers[i]));
  367. }
  368. X
  369. void prettyprint_fn(int fd, char *name, Node *n) {
  370. X    fprint(fd, "fn %s {%s}\n", strprint(name, FALSE, FALSE), ptree(n));
  371. }
  372. SHAR_EOF
  373. chmod 0644 fn.c ||
  374. echo 'restore of fn.c failed'
  375. Wc_c="`wc -c < 'fn.c'`"
  376. test 5485 -eq "$Wc_c" ||
  377.     echo 'fn.c: original size 5485, current size' "$Wc_c"
  378. rm -f _shar_wnt_.tmp
  379. fi
  380. # ============= footobar.c ==============
  381. if test -f 'footobar.c' -a X"$1" != X"-c"; then
  382.     echo 'x - skipping footobar.c (File already exists)'
  383.     rm -f _shar_wnt_.tmp
  384. else
  385. > _shar_wnt_.tmp
  386. echo 'x - extracting footobar.c (Text)'
  387. sed 's/^X//' << 'SHAR_EOF' > 'footobar.c' &&
  388. /*
  389. X   footobar.c: a collection of functions to convert internal representations of
  390. X   variables and functions to external representations, and vice versa
  391. */
  392. X
  393. #include "rc.h"
  394. #include "utils.h"
  395. #include "lex.h"
  396. #include "footobar.h"
  397. #include "nalloc.h"
  398. #include "input.h"
  399. #include "list.h"
  400. X
  401. #define FSCHAR '\1'
  402. #define FSSTRING "\1"
  403. X
  404. static char *getenvw(char *, boolean);
  405. static void funcat(char *);
  406. static void strtree(Node *);
  407. X
  408. static char *fun;
  409. static SIZE_T funsize, funpos;
  410. X
  411. #ifdef PROTECT_ENV
  412. /* octalize -- protect an exported name from brain-dead shells */
  413. X
  414. static char hexchar[] = "0123456789abcdef";
  415. X
  416. static char *octalize(char *name) {
  417. X    int c;
  418. X    static char namebuf[1000];
  419. X    char *s = namebuf;
  420. X
  421. X    while (1) {
  422. X        c = *(unsigned char *) name++;
  423. X        if (c == '\0') {
  424. X            *s++ = '\0';
  425. X            return namebuf;
  426. X        }
  427. X        if (!dnw[c] && c != '*') {
  428. X            if (c != '_')
  429. X                *s++ = c;
  430. X            else if (*name != '_')
  431. X                *s++ = c;
  432. X            else
  433. X                goto fallthrough;
  434. X        } else {
  435. X    fallthrough:    *s++ = '_';
  436. X            *s++ = '_';
  437. X            *s++ = hexchar[(c >> 4) & 0xf];
  438. X            *s++ = hexchar[c & 0xf];
  439. X        }
  440. X    }
  441. }
  442. #endif
  443. X
  444. /* a specialized strcat, used in strtree */
  445. X
  446. static void funcat(char *s) {
  447. X    SIZE_T l = strlen(s);
  448. X    char *new;
  449. X
  450. X    if (l + funpos > funsize) {
  451. X        new = nalloc(funsize *= 2);
  452. X        memcpy(new, fun, funpos);
  453. X        new[funpos] = 0;
  454. X        fun = new;
  455. X    }
  456. X    strcpy(fun + funpos, s);
  457. X    funpos += l;
  458. }
  459. X
  460. /* used to turn a function in Node * form into something we can export to the environment */
  461. X
  462. char *fun2str(char *name, Node *s) {
  463. #ifdef PROTECT_ENV
  464. X    name = octalize(name);
  465. #endif
  466. X    fun = nalloc(funsize = 512);
  467. X    funpos = 0;
  468. X    funcat("fn_");
  469. X    funcat(name);
  470. X    funcat("={");
  471. X    strtree(s);
  472. X    funcat("}");
  473. X    return ecpy(fun); /* put into malloc space */
  474. }
  475. X
  476. /* ptree is used by whatis in order to print the definition of a function to the terminal */
  477. X
  478. char *ptree(Node *s) {
  479. X    fun = nalloc(funsize = 512);
  480. X    funpos = 0;
  481. X    fun[0] = 0;
  482. X    strtree(s);
  483. X    return fun;
  484. }
  485. X
  486. /* save some code space by gathering this operation in a function */
  487. X
  488. static void catredir(int i) {
  489. X    switch (i) {
  490. X    case CREATE: funcat(">"); break;
  491. X    case APPEND: funcat(">>"); break;
  492. X    case HEREDOC: funcat("<<"); break;
  493. X    case HERESTRING: funcat("<<<"); break;
  494. X    case FROM: funcat("<"); break;
  495. X    }
  496. }
  497. X
  498. /* convert a function in Node * form into something rc can parse (and humans can read?) */
  499. X
  500. static void strtree(Node *n) {
  501. X    int defaultfd;
  502. X    char b[16];
  503. X
  504. X    if (n == NULL) {
  505. X        funcat("()");
  506. X        return;
  507. X    }
  508. X
  509. X    switch (n->type) {
  510. X    case rDUP:
  511. X        catredir(n->u[0].i);
  512. X        if (n->u[2].i != -1)
  513. X            sprint(b, "[%d=%d]", n->u[1].i, n->u[2].i);
  514. X        else
  515. X            sprint(b, "[%d=]", n->u[1].i);
  516. X        funcat(b);
  517. X        break;
  518. X    case rWORD:
  519. X        funcat(strprint(n->u[0].s, FALSE, FALSE));
  520. X        break;
  521. X    case QWORD:
  522. X        funcat(strprint(n->u[0].s, TRUE, FALSE));
  523. X        break;
  524. X    case BACKQ:
  525. X        if (n->u[0].p != NULL && n->u[0].p->type == VAR
  526. X            && n->u[0].p->u[0].p != NULL && n->u[0].p->u[0].p->type == rWORD
  527. X            && streq(n->u[0].p->u[0].p->u[0].s,"ifs")) {
  528. X            funcat("`{");
  529. X        } else {
  530. X            funcat("``");
  531. X            strtree(n->u[0].p);
  532. X            funcat("{");
  533. X        }
  534. X        strtree(n->u[1].p);
  535. X        funcat("}");
  536. X        break;
  537. X    case rBANG:
  538. X        funcat("! ");
  539. X        strtree(n->u[0].p);
  540. X        break;
  541. X    case rCASE:
  542. X        funcat("case ");
  543. X        strtree(n->u[0].p);
  544. X        break;
  545. X    case CBODY:
  546. X        if (n->u[0].p != NULL) {
  547. X            strtree(n->u[0].p);
  548. X            funcat(";");
  549. X        }
  550. X        if (n->u[1].p != NULL)
  551. X            strtree(n->u[1].p);
  552. X        break;
  553. X    case NOWAIT:
  554. X        strtree(n->u[0].p);
  555. X        funcat("&");
  556. X        break;
  557. X    case rCOUNT:
  558. X        funcat("$#");
  559. X        strtree(n->u[0].p);
  560. X        break;
  561. X    case rFLAT:
  562. X        funcat("$^");
  563. X        strtree(n->u[0].p);
  564. X        break;
  565. X    case RMFN:
  566. X        funcat("fn ");
  567. X        strtree(n->u[0].p);
  568. X        break;
  569. X    case rSUBSHELL:
  570. X        funcat("@ ");
  571. X        strtree(n->u[0].p);
  572. X        break;
  573. X    case VAR:
  574. X        funcat("$");
  575. X        strtree(n->u[0].p);
  576. X        break;
  577. X    case rANDAND:
  578. X        strtree(n->u[0].p);
  579. X        funcat("&&");
  580. X        strtree(n->u[1].p);
  581. X        break;
  582. X    case ASSIGN:
  583. X        strtree(n->u[0].p);
  584. X        funcat("=");
  585. X        strtree(n->u[1].p);
  586. X        break;
  587. X    case BODY:
  588. X        if (n->u[1].p != NULL)
  589. X            funcat("{");
  590. X        strtree(n->u[0].p);
  591. X        if (n->u[1].p != NULL) {
  592. X            funcat(";");
  593. X            strtree(n->u[1].p);
  594. X            funcat("}");
  595. X        }
  596. X        break;
  597. X    case BRACE:
  598. X        funcat("{");
  599. X        strtree(n->u[0].p);
  600. X        funcat("}");
  601. X        if (n->u[1].p != NULL)
  602. X            strtree(n->u[1].p);
  603. X        break;
  604. X    case CONCAT:
  605. X        strtree(n->u[0].p);
  606. X        funcat("^");
  607. X        strtree(n->u[1].p);
  608. X        break;
  609. X    case rELSE:
  610. X        funcat("{");
  611. X        strtree(n->u[0].p);
  612. X        funcat("}else ");
  613. X        strtree(n->u[1].p);
  614. X        break;
  615. X    case EPILOG:
  616. X    case PRE:
  617. X        strtree(n->u[0].p);
  618. X        if (n->u[1].p != NULL) {
  619. X            funcat(" ");
  620. X            strtree(n->u[1].p);
  621. X        }
  622. X        break;
  623. X    case NEWFN:
  624. X        funcat("fn ");
  625. X        strtree(n->u[0].p);
  626. X        funcat(" {");
  627. X        strtree(n->u[1].p);
  628. X        funcat("}");
  629. X        break;
  630. X    case rIF:
  631. X        funcat("if(");
  632. X        strtree(n->u[0].p);
  633. X        funcat(")");
  634. X        strtree(n->u[1].p);
  635. X        break;
  636. X    case rOROR:
  637. X        strtree(n->u[0].p);
  638. X        funcat("||");
  639. X        strtree(n->u[1].p);
  640. X        break;
  641. X    case ARGS:
  642. X        strtree(n->u[0].p);
  643. X        funcat(" ");
  644. X        strtree(n->u[1].p);
  645. X        break;
  646. X    case rSWITCH:
  647. X        funcat("switch(");
  648. X        strtree(n->u[0].p);
  649. X        funcat("){");
  650. X        strtree(n->u[1].p);
  651. X        funcat("}");
  652. X        break;
  653. X    case MATCH:
  654. X        funcat("~ ");
  655. X        strtree(n->u[0].p);
  656. X        funcat(" ");
  657. X        strtree(n->u[1].p);
  658. X        break;
  659. X    case VARSUB:
  660. X        funcat("$");
  661. X        strtree(n->u[0].p);
  662. X        funcat("(");
  663. X        strtree(n->u[1].p);
  664. X        funcat(")");
  665. X        break;
  666. X    case rWHILE:
  667. X        funcat("while(");
  668. X        strtree(n->u[0].p);
  669. X        funcat(")");
  670. X        strtree(n->u[1].p);
  671. X        break;
  672. X    case LAPPEND:
  673. X        funcat("(");
  674. X        strtree(n->u[0].p);
  675. X        funcat(" ");
  676. X        strtree(n->u[1].p);
  677. X        funcat(")");
  678. X        break;
  679. X    case FORIN:
  680. X        funcat("for(");
  681. X        strtree(n->u[0].p);
  682. X        funcat(" in ");
  683. X        strtree(n->u[1].p);
  684. X        funcat(")");
  685. X        strtree(n->u[2].p);
  686. X        break;
  687. X    case rPIPE:
  688. X        funcat("{");
  689. X        strtree(n->u[2].p);
  690. X        if (n->u[0].i == 1) {
  691. X            if (n->u[1].i == 0)
  692. X                sprint(b, "}|{");
  693. X            else
  694. X                sprint(b, "}|[1=%d]{", n->u[1].p);
  695. X        } else {
  696. X            if (n->u[1].i == 0)
  697. X                sprint(b, "}|[%d]{", n->u[0].p);
  698. X            else
  699. X                sprint(b, "}|[%d=%d]{", n->u[0].i, n->u[1].i);
  700. X        }
  701. X        funcat(b);
  702. X        strtree(n->u[3].p);
  703. X        funcat("}");
  704. X        break;
  705. X    case NMPIPE:
  706. X        defaultfd = (n->u[0].i == CREATE || n->u[0].i == APPEND);
  707. X        catredir(n->u[0].i);
  708. X        if (n->u[1].i != defaultfd) {
  709. X            sprint(b, "[%d]{", n->u[1].i);
  710. X            funcat(b);
  711. X        } else
  712. X            funcat("{");
  713. X        strtree(n->u[2].p);
  714. X        funcat("}");
  715. X        break;
  716. X    case rREDIR:
  717. X        defaultfd = (n->u[0].i == CREATE || n->u[0].i == APPEND);
  718. X        catredir(n->u[0].i);
  719. X        if (n->u[1].i != defaultfd) {
  720. X            sprint(b, "[%d]", n->u[1].i);
  721. X            funcat(b);
  722. X        }
  723. X        strtree(n->u[2].p);
  724. X        break;
  725. X     }
  726. }
  727. X
  728. /* convert a List to a string, separating it with ^A characters. Used for exporting variables to the environment */
  729. X
  730. char *list2str(char *name, List *s) {
  731. X    SIZE_T size;
  732. X    List *t;
  733. X    char *w;
  734. X
  735. #ifdef PROTECT_ENV
  736. X    name = octalize(name);
  737. #endif
  738. X    size = strlen(name) + listlen(s);
  739. X
  740. X    w = ealloc(size + 2);
  741. X    t = s;
  742. X    strcpy(w, name);
  743. X    strcat(w, "=");
  744. X    strcat(w, t->w);
  745. X    for (s = s->n; s != NULL; s = s->n) {
  746. X        strcat(w, FSSTRING);
  747. X        strcat(w, s->w);
  748. X    }
  749. X    return w;
  750. }
  751. X
  752. /* convert a List to an array, for execve() */
  753. X
  754. char **list2array(List *s, boolean print) {
  755. X    char **av;
  756. X    int i;
  757. X
  758. X    /* 4 == 1 for the null terminator + 2 for the fake execve() + 1 for defaulting to sh */
  759. X
  760. X    av = nalloc((listnel(s) + 4) * sizeof (char *));
  761. X
  762. X    av += 3; /* hide the two free spots from rc (two for #! emulation, one for defaulting to sh) */
  763. X
  764. X    if (print)
  765. X        fprint(2, "%l\n", s);
  766. X
  767. X    for (i = 0; s != NULL; i++) {
  768. X        av[i] = s->w;
  769. X        s = s->n;
  770. X    }
  771. X    av[i] = NULL;
  772. X    return av;
  773. }
  774. X
  775. /* figure out the name of a variable given an environment string. copy this into malloc space */
  776. X
  777. char *get_name(char *s) {
  778. X    int c;
  779. X    SIZE_T i;
  780. X    char *r, *namebuf;
  781. #ifdef PROTECT_ENV
  782. X    char *h1, *h2;
  783. #endif
  784. X
  785. X    for (i = 0; s[i] != '\0' && s[i] != '='; i++)
  786. X        ;
  787. X
  788. X    if (s[i] == '\0')
  789. X        return NULL;
  790. X
  791. X    r = namebuf = ealloc(i + 1);
  792. X
  793. X    while (1)
  794. X        switch (c = *s++) {
  795. X        case '=':
  796. X            *r++ = '\0';
  797. X            return namebuf;
  798. #ifdef PROTECT_ENV
  799. X        case '_':
  800. X            if (*s == '_' && (h1 = strchr(hexchar, s[1])) != NULL && (h2 = strchr(hexchar, s[2])) != NULL) {
  801. X                *r++ = ((h1 - hexchar) << 4) | (h2 - hexchar);
  802. X                s += 3;
  803. X                break;
  804. X            }
  805. X            /* FALLTHROUGH */
  806. #endif
  807. X        default:
  808. X            *r++ = c;
  809. X            break;
  810. X        }
  811. }
  812. X
  813. /* get the next word from a variable's value as represented in the environment. */
  814. X
  815. static char *getenvw(char *s, boolean saw_alpha) {
  816. X    char *r;
  817. X    SIZE_T i,j;
  818. X
  819. X    for (i = j = 0; s[i] != '\0' && s[i] != FSCHAR; i++)
  820. X        ;
  821. X
  822. X    if (i == 0)
  823. X        if(s[i] == '\0' && !saw_alpha)
  824. X            return NULL;
  825. X        else {
  826. X            r = enew(char);
  827. X            *r = '\0';
  828. X            return r;
  829. X        }
  830. X
  831. X    r = ealloc(i + j + 1);
  832. X
  833. X    r[i + j] = '\0';
  834. X
  835. X    while (i > 0) {
  836. X        --i;
  837. X        r[i + j] = s[i];
  838. X    }
  839. X    return r;
  840. }
  841. X
  842. /* take an environment entry for a variable (elements ^A separated) and turn it into a List */
  843. X
  844. List *parse_var(char *name, char *extdef) {
  845. X    List *r, *top;
  846. X    char *f;
  847. X    boolean saw_alpha;
  848. X
  849. X    top = r = enew(List);
  850. X    extdef = strchr(extdef, '=') + 1;
  851. X
  852. X
  853. X    if ((f = getenvw(extdef, FALSE)) == NULL)
  854. X        return NULL;
  855. X
  856. X    while (1) {
  857. X        r->w = f;
  858. X        r->m = NULL;
  859. X        extdef += strlen(f);
  860. X        if (*extdef == FSCHAR) {
  861. X            extdef++;
  862. X            saw_alpha = TRUE;
  863. X        } else {
  864. X            saw_alpha = FALSE;
  865. X        }
  866. X        if ((f = getenvw(extdef, saw_alpha)) == NULL) {
  867. X            r->n = NULL;
  868. X            break;
  869. X        }
  870. X        r = r->n = enew(List);
  871. X    }
  872. X    return top;
  873. }
  874. X
  875. /* get an environment entry for a function and have rc parse it. */
  876. X
  877. Node *parse_fn(char *name, char *extdef) {
  878. X    Node *def;
  879. X    int i;
  880. X    char *s, old[4];
  881. X
  882. X    s = strchr(extdef, '=');
  883. X
  884. X    if (s == NULL)
  885. X        return NULL;
  886. X
  887. X    s -= 3;
  888. X
  889. X    for (i = 0; i < 4; i++)
  890. X        old[i] = s[i];
  891. X    s[0] = 'f';
  892. X    s[1] = 'n';
  893. X    s[2] = ' ';
  894. X    s[3] = 'x';
  895. X
  896. X    def = parseline(s);
  897. X    for (i = 0; i < 4; i++)
  898. X        s[i] = old[i];
  899. X
  900. X    if (def == NULL || def->type != NEWFN)
  901. X        return NULL;
  902. X    else
  903. X        return def->u[1].p;
  904. }
  905. SHAR_EOF
  906. chmod 0644 footobar.c ||
  907. echo 'restore of footobar.c failed'
  908. Wc_c="`wc -c < 'footobar.c'`"
  909. test 9420 -eq "$Wc_c" ||
  910.     echo 'footobar.c: original size 9420, current size' "$Wc_c"
  911. rm -f _shar_wnt_.tmp
  912. fi
  913. # ============= footobar.h ==============
  914. if test -f 'footobar.h' -a X"$1" != X"-c"; then
  915.     echo 'x - skipping footobar.h (File already exists)'
  916.     rm -f _shar_wnt_.tmp
  917. else
  918. > _shar_wnt_.tmp
  919. echo 'x - extracting footobar.h (Text)'
  920. sed 's/^X//' << 'SHAR_EOF' > 'footobar.h' &&
  921. extern char *fun2str(char *, Node *);
  922. extern char *ptree(Node *);
  923. extern char *list2str(char *, List *);
  924. extern char **list2array(List *, boolean);
  925. extern char *get_name(char *);
  926. extern List *parse_var(char *, char *);
  927. extern Node *parse_fn(char *, char *);
  928. SHAR_EOF
  929. chmod 0644 footobar.h ||
  930. echo 'restore of footobar.h failed'
  931. Wc_c="`wc -c < 'footobar.h'`"
  932. test 258 -eq "$Wc_c" ||
  933.     echo 'footobar.h: original size 258, current size' "$Wc_c"
  934. rm -f _shar_wnt_.tmp
  935. fi
  936. # ============= getopt.c ==============
  937. if test -f 'getopt.c' -a X"$1" != X"-c"; then
  938.     echo 'x - skipping getopt.c (File already exists)'
  939.     rm -f _shar_wnt_.tmp
  940. else
  941. > _shar_wnt_.tmp
  942. echo 'x - extracting getopt.c (Text)'
  943. sed 's/^X//' << 'SHAR_EOF' > 'getopt.c' &&
  944. /* getopt routine courtesy of David Sanderson */
  945. #include "rc.h"
  946. #include "utils.h"
  947. #include "getopt.h"
  948. X
  949. int     opterr = 1;
  950. int     optind = 1;
  951. int     optopt;
  952. char    *optarg;
  953. X 
  954. int getopt(int argc, char **argv, char *opts) {
  955. X        static int sp = 1;
  956. X        int c;
  957. X        char *cp;
  958. X 
  959. X    if (optind == 0) /* reset getopt() */
  960. X        optind = sp = 1;
  961. X
  962. X        if (sp == 1)
  963. X                if(optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0') {
  964. X                        return -1;
  965. X                } else if (strcmp(argv[optind], "--") == 0) {
  966. X                        optind++;
  967. X                        return -1;
  968. X                }
  969. X        optopt = c = argv[optind][sp];
  970. X        if (c == ':' || (cp=strchr(opts, c)) == 0) {
  971. X                fprint(2, "%s: illegal option -- %c\n", argv[0], c);
  972. X                if (argv[optind][++sp] == '\0') {
  973. X                        optind++;
  974. X                        sp = 1;
  975. X                }
  976. X                return '?';
  977. X        }
  978. X        if (*++cp == ':') {
  979. X                if(argv[optind][sp+1] != '\0') {
  980. X                        optarg = &argv[optind++][sp+1];
  981. X                } else if(++optind >= argc) {
  982. X                        fprint(2, "%s: option requires an argument -- %c\n", argv[0], c);
  983. X                        sp = 1;
  984. X                        return '?';
  985. X                } else
  986. X                        optarg = argv[optind++];
  987. X                sp = 1;
  988. X        } else {
  989. X                if (argv[optind][++sp] == '\0') {
  990. X                        sp = 1;
  991. X                        optind++;
  992. X                }
  993. X                optarg = 0;
  994. X        }
  995. X        return c;
  996. }
  997. SHAR_EOF
  998. chmod 0644 getopt.c ||
  999. echo 'restore of getopt.c failed'
  1000. Wc_c="`wc -c < 'getopt.c'`"
  1001. test 1619 -eq "$Wc_c" ||
  1002.     echo 'getopt.c: original size 1619, current size' "$Wc_c"
  1003. rm -f _shar_wnt_.tmp
  1004. fi
  1005. # ============= getopt.h ==============
  1006. if test -f 'getopt.h' -a X"$1" != X"-c"; then
  1007.     echo 'x - skipping getopt.h (File already exists)'
  1008.     rm -f _shar_wnt_.tmp
  1009. else
  1010. > _shar_wnt_.tmp
  1011. echo 'x - extracting getopt.h (Text)'
  1012. sed 's/^X//' << 'SHAR_EOF' > 'getopt.h' &&
  1013. extern int getopt(int, char **, char *);
  1014. X
  1015. extern int optind, opterr, optopt;
  1016. extern char *optarg;
  1017. SHAR_EOF
  1018. chmod 0644 getopt.h ||
  1019. echo 'restore of getopt.h failed'
  1020. Wc_c="`wc -c < 'getopt.h'`"
  1021. test 98 -eq "$Wc_c" ||
  1022.     echo 'getopt.h: original size 98, current size' "$Wc_c"
  1023. rm -f _shar_wnt_.tmp
  1024. fi
  1025. # ============= glob.c ==============
  1026. if test -f 'glob.c' -a X"$1" != X"-c"; then
  1027.     echo 'x - skipping glob.c (File already exists)'
  1028.     rm -f _shar_wnt_.tmp
  1029. else
  1030. > _shar_wnt_.tmp
  1031. echo 'x - extracting glob.c (Text)'
  1032. sed 's/^X//' << 'SHAR_EOF' > 'glob.c' &&
  1033. /* glob.c: rc's (ugly) globber. This code is not elegant, but it works */
  1034. X
  1035. #include <sys/types.h>
  1036. #include <sys/stat.h>
  1037. #include "rc.h"
  1038. #include "glob.h"
  1039. #include "glom.h"
  1040. #include "nalloc.h"
  1041. #include "utils.h"
  1042. #include "match.h"
  1043. #include "footobar.h"
  1044. #include "list.h"
  1045. #ifdef NODIRENT
  1046. #include <sys/dir.h>
  1047. #define dirent direct /* need to get the struct declaraction right */
  1048. #else
  1049. #include <dirent.h>
  1050. #endif
  1051. X
  1052. static List *dmatch(char *, char *, char *);
  1053. static List *doglob(char *, char *);
  1054. static List *lglob(List *, char *, char *, SIZE_T);
  1055. static List *sort(List *);
  1056. X
  1057. /*
  1058. X   matches a list of words s against a list of patterns p. Returns true iff
  1059. X   a pattern in p matches a word in s. null matches null, but otherwise null
  1060. X   patterns match nothing.
  1061. */
  1062. X
  1063. boolean lmatch(List *s, List *p) {
  1064. X    List *q;
  1065. X    int i;
  1066. X    boolean okay;
  1067. X
  1068. X    if (s == NULL) {
  1069. X        if (p == NULL) /* null matches null */
  1070. X            return TRUE;
  1071. X        for (; p != NULL; p = p->n) { /* one or more stars match null */
  1072. X            if (*p->w != '\0') { /* the null string is a special case; it does *not* match () */
  1073. X                okay = TRUE;
  1074. X                for (i = 0; p->w[i] != '\0'; i++)
  1075. X                    if (p->w[i] != '*' || p->m[i] != 1) {
  1076. X                        okay = FALSE;
  1077. X                        break;
  1078. X                    }
  1079. X                if (okay)
  1080. X                    return TRUE;
  1081. X            }
  1082. X        }
  1083. X        return FALSE;
  1084. X    }
  1085. X
  1086. X    for (; s != NULL; s = s->n)
  1087. X        for (q = p; q != NULL; q = q->n)
  1088. X            if (match(q->w, q->m, s->w))
  1089. X                return TRUE;
  1090. X    return FALSE;
  1091. }
  1092. X
  1093. /* Matches a pattern p against the contents of directory d */
  1094. X
  1095. static List *dmatch(char *d, char *p, char *m) {
  1096. X    boolean matched = FALSE;
  1097. X    List *top, *r;
  1098. X    DIR *dirp;
  1099. X    struct dirent *dp;
  1100. X    struct stat s;
  1101. X    /* prototypes for XXXdir functions. comment out if necessary */
  1102. X    extern DIR *opendir(const char *);
  1103. X    extern struct dirent *readdir(DIR *);
  1104. X    extern int closedir(DIR *);
  1105. X
  1106. X    /* opendir succeeds on regular files on some systems, so the stat() call is necessary (sigh) */
  1107. X    if (stat(d, &s) < 0 || (s.st_mode & S_IFMT) != S_IFDIR)
  1108. X        return NULL;
  1109. X    if ((dirp = opendir(d)) == NULL)
  1110. X        return NULL;
  1111. X
  1112. X    top = r = NULL;
  1113. X
  1114. X    while ((dp = readdir(dirp)) != NULL)
  1115. X        if ((*dp->d_name != '.' || *p == '.') && match(p, m, dp->d_name)) { /* match ^. explicitly */
  1116. X            matched = TRUE;
  1117. X            if (top == NULL)
  1118. X                top = r = nnew(List);
  1119. X            else
  1120. X                r = r->n = nnew(List);
  1121. X            r->w = ncpy(dp->d_name);
  1122. X            r->m = NULL;
  1123. X        }
  1124. X
  1125. X    closedir(dirp);
  1126. X
  1127. X    if (!matched)
  1128. X        return NULL;
  1129. X
  1130. X    r->n = NULL;
  1131. X    return top;
  1132. }
  1133. X
  1134. /*
  1135. X   lglob() globs a pattern agains a list of directory roots. e.g., (/tmp /usr /bin) "*"
  1136. X   will return a list with all the files in /tmp, /usr, and /bin. NULL on no match.
  1137. X   slashcount indicates the number of slashes to stick between the directory and the
  1138. X   matched name. e.g., for matching ////tmp/////foo*
  1139. */
  1140. X
  1141. static List *lglob(List *s, char *p, char *m, SIZE_T slashcount) {
  1142. X    List *q, *r, *top, foo;
  1143. X    static List slash;
  1144. X    static SIZE_T slashsize = 0;
  1145. X
  1146. X    if (slashcount + 1 > slashsize) {
  1147. X        slash.w = ealloc(slashcount + 1);
  1148. X        slashsize = slashcount;
  1149. X    }
  1150. X    slash.w[slashcount] = '\0';
  1151. X    while (slashcount > 0)
  1152. X        slash.w[--slashcount] = '/';
  1153. X
  1154. X    for (top = r = NULL; s != NULL; s = s->n) {
  1155. X        q = dmatch(s->w, p, m);
  1156. X        if (q != NULL) {
  1157. X            foo.w = s->w;
  1158. X            foo.m = NULL;
  1159. X            foo.n = NULL;
  1160. X            if (!(s->w[0] == '/' && s->w[1] == '\0')) /* need to separate */
  1161. X                q = concat(&slash, q);          /* dir/name with slash */
  1162. X            q = concat(&foo, q);
  1163. X            if (r == NULL)
  1164. X                top = r = q;
  1165. X            else
  1166. X                r->n = q;
  1167. X            while (r->n != NULL)
  1168. X                r = r->n;
  1169. X        }
  1170. X    }
  1171. X    return top;
  1172. }
  1173. X
  1174. /*
  1175. X   Doglob globs a pathname in pattern form against a unix path. Returns the original
  1176. X   pattern (cleaned of metacharacters) on failure, or the globbed string(s).
  1177. */
  1178. X
  1179. static List *doglob(char *w, char *m) {
  1180. X    static char *dir = NULL, *pattern = NULL, *metadir = NULL, *metapattern = NULL;
  1181. X    static SIZE_T dsize = 0;
  1182. X    char *d, *p, *md, *mp;
  1183. X    SIZE_T psize;
  1184. X    char *s = w;
  1185. X    List firstdir;
  1186. X    List *matched;
  1187. X    int slashcount;
  1188. X
  1189. X    if ((psize = strlen(w) + 1) > dsize || dir == NULL) {
  1190. X        efree(dir); efree(pattern); efree(metadir); efree(metapattern);
  1191. X        dir = ealloc(psize);
  1192. X        pattern = ealloc(psize);
  1193. X        metadir = ealloc(psize);
  1194. X        metapattern = ealloc(psize);
  1195. X        dsize = psize;
  1196. X    }
  1197. X
  1198. X    d = dir;
  1199. X    p = pattern;
  1200. X    md = metadir;
  1201. X    mp = metapattern;
  1202. X
  1203. X    if (*s == '/') {
  1204. X        while (*s == '/')
  1205. X            *d++ = *s++, *md++ = *m++;
  1206. X    } else {
  1207. X        while (*s != '/' && *s != '\0')
  1208. X            *d++ = *s++, *md++ = *m++; /* get first directory component */
  1209. X    }
  1210. X    *d = '\0';
  1211. X
  1212. X    /*
  1213. X       Special case: no slashes in the pattern, i.e., open the current directory.
  1214. X       Remember that w cannot consist of slashes alone (the other way *s could be
  1215. X       zero) since doglob gets called iff there's a metacharacter to be matched
  1216. X    */
  1217. X    if (*s == '\0') {
  1218. X        matched = dmatch(".", dir, metadir);
  1219. X        goto end;
  1220. X    }
  1221. X
  1222. X    if (*w == '/') {
  1223. X        firstdir.w = dir;
  1224. X        firstdir.m = metadir;
  1225. X        firstdir.n = NULL;
  1226. X        matched = &firstdir;
  1227. X    } else {
  1228. X        /*
  1229. X           we must glob against current directory,
  1230. X           since the first character is not a slash.
  1231. X        */
  1232. X        matched = dmatch(".", dir, metadir);
  1233. X    }
  1234. X
  1235. X    do {
  1236. X        for (slashcount = 0; *s == '/'; s++, m++)
  1237. X            slashcount++; /* skip slashes */
  1238. X
  1239. X        while (*s != '/' && *s != '\0')
  1240. X            *p++ = *s++, *mp++ = *m++; /* get pattern */
  1241. X        *p = '\0';
  1242. X
  1243. X        matched = lglob(matched, pattern, metapattern, slashcount);
  1244. X
  1245. X        p = pattern, mp = metapattern;
  1246. X    } while (*s != '\0');
  1247. X
  1248. end:    if (matched == NULL) {
  1249. X        matched = nnew(List);
  1250. X        matched->w = w;
  1251. X        matched->m = NULL;
  1252. X        matched->n = NULL;
  1253. X    }
  1254. X    return matched;
  1255. }
  1256. X
  1257. /*
  1258. X   Globs a list; checks to see if each element in the list has a metacharacter. If it
  1259. X   does, it is globbed, and the output is sorted.
  1260. */
  1261. X
  1262. List *glob(List *s) {
  1263. X    List *top, *r;
  1264. X    boolean meta;
  1265. X
  1266. X    for (r = s, meta = FALSE; r != NULL; r = r->n)
  1267. X        if (r->m != NULL)
  1268. X            meta = TRUE;
  1269. X
  1270. X    if (!meta)
  1271. X        return s; /* don't copy lists with no metacharacters in them */
  1272. X
  1273. X    for (top = r = NULL; s != NULL; s = s->n) {
  1274. X        if (s->m == NULL) { /* no metacharacters; just tack on to the return list */
  1275. X            if (top == NULL) {
  1276. X                top = r = nnew(List);
  1277. X            } else {
  1278. X                r->n = nnew(List);
  1279. X                r = r->n;
  1280. X            }
  1281. X            r->w = s->w;
  1282. X        } else {
  1283. X            if (top == NULL)
  1284. X                top = r = sort(doglob(s->w, s->m));
  1285. X            else
  1286. X                r->n = sort(doglob(s->w, s->m));
  1287. X            while (r->n != NULL)
  1288. X                r = r->n;
  1289. X        }
  1290. X    }
  1291. X
  1292. X    r->n = NULL;
  1293. X    return top;
  1294. }
  1295. X
  1296. static List *sort(List *s) {
  1297. X    SIZE_T nel = listnel(s);
  1298. X
  1299. X    if (nel > 1) {
  1300. X        char **a;
  1301. X        List *t;
  1302. X
  1303. X        qsort(a = list2array(s, FALSE), nel, sizeof(char *), starstrcmp);
  1304. X
  1305. X        for (t = s; t != NULL; t = t->n)
  1306. X            t->w = *a++;
  1307. X    }
  1308. X
  1309. X    return s;
  1310. }
  1311. SHAR_EOF
  1312. chmod 0644 glob.c ||
  1313. echo 'restore of glob.c failed'
  1314. Wc_c="`wc -c < 'glob.c'`"
  1315. test 6378 -eq "$Wc_c" ||
  1316.     echo 'glob.c: original size 6378, current size' "$Wc_c"
  1317. rm -f _shar_wnt_.tmp
  1318. fi
  1319. # ============= glob.h ==============
  1320. if test -f 'glob.h' -a X"$1" != X"-c"; then
  1321.     echo 'x - skipping glob.h (File already exists)'
  1322.     rm -f _shar_wnt_.tmp
  1323. else
  1324. > _shar_wnt_.tmp
  1325. echo 'x - extracting glob.h (Text)'
  1326. sed 's/^X//' << 'SHAR_EOF' > 'glob.h' &&
  1327. extern boolean lmatch(List *, List *);
  1328. extern List *glob(List *);
  1329. SHAR_EOF
  1330. chmod 0644 glob.h ||
  1331. echo 'restore of glob.h failed'
  1332. Wc_c="`wc -c < 'glob.h'`"
  1333. test 66 -eq "$Wc_c" ||
  1334.     echo 'glob.h: original size 66, current size' "$Wc_c"
  1335. rm -f _shar_wnt_.tmp
  1336. fi
  1337. # ============= glom.c ==============
  1338. if test -f 'glom.c' -a X"$1" != X"-c"; then
  1339.     echo 'x - skipping glom.c (File already exists)'
  1340.     rm -f _shar_wnt_.tmp
  1341. else
  1342. > _shar_wnt_.tmp
  1343. echo 'x - extracting glom.c (Text)'
  1344. sed 's/^X//' << 'SHAR_EOF' > 'glom.c' &&
  1345. /* glom.c: builds an argument list out of words, variables, etc. */
  1346. X
  1347. #include <sys/types.h>
  1348. #include <sys/stat.h>
  1349. #ifndef S_IFIFO
  1350. #ifndef DEVFD
  1351. #define NOCMDARG
  1352. #endif
  1353. #endif
  1354. #include "rc.h"
  1355. #include "utils.h"
  1356. #include "nalloc.h"
  1357. #include "glom.h"
  1358. #include "hash.h"
  1359. #include "walk.h"
  1360. #include "status.h"
  1361. #include "exec.h"
  1362. #include "lex.h"
  1363. #include "open.h"
  1364. #include "list.h"
  1365. #include "wait.h"
  1366. X
  1367. static List *backq(Node *, Node *);
  1368. static List *bqinput(List *, int);
  1369. static List *count(List *);
  1370. static List *mkcmdarg(Node *);
  1371. X
  1372. Rq *redirq = NULL;
  1373. Fq *fifoq = NULL;
  1374. X
  1375. List *word(char *w, char *m) {
  1376. X    List *s;
  1377. X
  1378. X    if (w == NULL)
  1379. X        return NULL;
  1380. X
  1381. X    s = nnew(List);
  1382. X    s->w = w;
  1383. X    s->m = m;
  1384. X    s->n = NULL;
  1385. X    return s;
  1386. }
  1387. X
  1388. /*
  1389. X   Append list s2 to list s1 by copying s1 and making the new copy
  1390. X   point at s2.
  1391. */
  1392. X
  1393. List *append(List *s1, List *s2) {
  1394. X    List *r, *top;
  1395. X
  1396. X    if (s1 == NULL)
  1397. X        return s2;
  1398. X    if (s2 == NULL)
  1399. X        return s1;
  1400. X
  1401. X    r = top = nnew(List);
  1402. X    while (1) {
  1403. X        r->w = s1->w;
  1404. X        r->m = s1->m;
  1405. X        if ((s1 = s1->n) == NULL)
  1406. X            break;
  1407. X        r = r->n = nnew(List);
  1408. X    }
  1409. X
  1410. X    r->n = s2;
  1411. X
  1412. X    return top;
  1413. }
  1414. X
  1415. List *concat(List *s1, List *s2) {
  1416. X    int n1, n2;
  1417. X    SIZE_T y,z;
  1418. X    List *n, *s;
  1419. X
  1420. X    if (s1 == NULL)
  1421. X        return s2;
  1422. X    if (s2 == NULL)
  1423. X        return s1;
  1424. X
  1425. X    n1 = listnel(s1);
  1426. X    n2 = listnel(s2);
  1427. X
  1428. X    if (n1 != n2 && n1 != 1 && n2 != 1)
  1429. X        rc_error("bad concatenation");
  1430. X
  1431. X    n = s = nnew(List);
  1432. X
  1433. X    while (1) {
  1434. X        z = strlen(s1->w) + strlen(s2->w) + 1;
  1435. X        n->w = nalloc(z);
  1436. X        strcpy(n->w,s1->w);
  1437. X        strcat(n->w,s2->w);
  1438. X        if (s1->m == NULL && s2->m == NULL) {
  1439. X            n->m = NULL;
  1440. X        } else {
  1441. X            n->m = nalloc(z);
  1442. X            y = strlen(s1->w);
  1443. X            if (s1->m == NULL)
  1444. X                clear(n->m, y);
  1445. X            else
  1446. X                memcpy(n->m, s1->m, y);
  1447. X            if (s2->m == NULL)
  1448. X                clear(n->m + y, strlen(s2->w));
  1449. X            else
  1450. X                memcpy(n->m + y, s2->m, strlen(s2->w));
  1451. X            n->m[z] = 0;
  1452. X        }
  1453. X        if (n1 > 1)
  1454. X            s1 = s1->n;
  1455. X        if (n2 > 1)
  1456. X            s2 = s2->n;
  1457. X        if (s1 == NULL || s2 == NULL || (n1 == 1  && n2 == 1)) {
  1458. X            n->n = NULL;
  1459. X            return s;
  1460. X        }
  1461. X        n->n = nnew(List);
  1462. X        n = n->n;
  1463. X    }
  1464. }
  1465. X
  1466. List *varsub(List *v, List *subs) {
  1467. X    int i,j;
  1468. X    int n;
  1469. X    List *r,*s;
  1470. X    List *top,*cat;
  1471. X
  1472. X    n = listnel(v);
  1473. X
  1474. X    top = cat = NULL;
  1475. X
  1476. X    for (s = subs; s != NULL; s = s->n) {
  1477. X        i = a2u(s->w);
  1478. X        if (i < 1)
  1479. X            rc_error("bad subscript");
  1480. X        if (i <= n) {
  1481. X            for (j = 1, r = v; j != i; j++, r = r->n)
  1482. X                ; /* loop until r == v(i) */
  1483. X            if (top == NULL) {
  1484. X                top = cat = nnew(List);
  1485. X            } else {
  1486. X                cat->n = nnew(List);
  1487. X                cat = cat->n;
  1488. X            }
  1489. X            cat->w = r->w;
  1490. X            cat->m = r->m;
  1491. X        }
  1492. X    }
  1493. X
  1494. X    if (top == NULL)
  1495. X        return NULL;
  1496. X
  1497. X    cat->n = NULL;
  1498. X    return top;
  1499. }
  1500. X
  1501. List *flatten(List *s) {
  1502. X    List *r;
  1503. X
  1504. X    if (s == NULL || s->n == NULL)
  1505. X        return s;
  1506. X
  1507. X    r = nnew(List);
  1508. X    r->w = nalloc(listlen(s) + 1);
  1509. X    r->m = NULL; /* flattened lists come from variables, so no meta */
  1510. X    r->n = NULL;
  1511. X
  1512. X    strcpy(r->w, s->w);
  1513. X
  1514. X    do {
  1515. X        s = s->n;
  1516. X        strcat(r->w, " ");
  1517. X        strcat(r->w, s->w);
  1518. X    } while (s->n != NULL);
  1519. X
  1520. X    return r;
  1521. }
  1522. X
  1523. static List *count(List *l) {
  1524. X    List *s = nnew(List);
  1525. X    char buf[16];
  1526. X
  1527. X    s->w = sprint(buf, "%d", listnel(l));
  1528. X    s->w = ncpy(s->w);
  1529. X    s->n = NULL;
  1530. X    s->m = NULL;
  1531. X    return s;
  1532. }
  1533. X
  1534. void assign(List *s1, List *s2, boolean stack) {
  1535. X    List *val = s2;
  1536. X
  1537. X    if (s1 == NULL)
  1538. X        rc_error("null variable name");
  1539. X    if (s1->n != NULL)
  1540. X        rc_error("multi-word variable name");
  1541. X    if (*s1->w == '\0')
  1542. X        rc_error("zero-length variable name");
  1543. X    if (a2u(s1->w) != -1)
  1544. X        rc_error("numeric variable name");
  1545. X    if (strchr(s1->w, '=') != NULL)
  1546. X        rc_error("'=' in variable name");
  1547. X    if (s1->w[0] == '*' && s1->w[1] == '\0')
  1548. X        val = append(varlookup("0"), s2); /* preserve $0 when * is assigned explicitly */
  1549. X
  1550. X
  1551. X    if (s2 != NULL || stack) {
  1552. X        if (dashex)
  1553. X            prettyprint_var(2, s1->w, val);
  1554. X        varassign(s1->w, val, stack);
  1555. X        alias(s1->w, val, stack);
  1556. X    } else {
  1557. X        if (dashex)
  1558. X            prettyprint_var(2, s1->w, NULL);
  1559. X        varrm(s1->w, stack);
  1560. X    }
  1561. }
  1562. X
  1563. /*
  1564. X   The following two functions are by the courtesy of Paul Haahr,
  1565. X   who could not stand the incompetence of my own backquote implementation.
  1566. */
  1567. X
  1568. #define BUFSIZE    ((SIZE_T) 1000)
  1569. X
  1570. static List *bqinput(List *ifs, int fd) {
  1571. X    char *end, *bufend, *s;
  1572. X    List *r, *top, *prev;
  1573. X    SIZE_T remain, bufsize;
  1574. X    char isifs[256];
  1575. X    int n;
  1576. X    int state; /* a simple FSA is used to read in data */
  1577. X
  1578. X    clear(isifs, sizeof isifs);
  1579. X    isifs['\0'] = 1;
  1580. X    for (r = ifs; r != NULL; r = r->n)
  1581. X        for (s = r->w; *s != '\0'; s++)
  1582. X            isifs[*(unsigned char *)s] = 1;
  1583. X
  1584. X    remain = bufsize = BUFSIZE;
  1585. X    top = r = nnew(List);
  1586. X    r->w = end = nalloc(bufsize + 1);
  1587. X    r->m = NULL;
  1588. X    state = 0;
  1589. X    prev = NULL;
  1590. X
  1591. X    while (1) {
  1592. X        if (remain == 0) { /* is the string bigger than the buffer? */
  1593. X            SIZE_T m = end - r->w;
  1594. X            char *buf;
  1595. X
  1596. X            while (bufsize < m + BUFSIZE)
  1597. X                bufsize *= 2;
  1598. X            buf = nalloc(bufsize + 1);
  1599. X            memcpy(buf, r->w, m);
  1600. X            r->w = buf;
  1601. X            end = &buf[m];
  1602. X            remain = bufsize - m;
  1603. X        }
  1604. X
  1605. X        n = read(fd, end, remain);
  1606. X
  1607. X        if (n <= 0) {
  1608. X            if (n == -1) {
  1609. X                uerror("backquote read");
  1610. X                rc_error(NULL);
  1611. X            }
  1612. X    /* break */    break;
  1613. X        }
  1614. X
  1615. X        remain -= n;
  1616. X
  1617. X        for (bufend = &end[n]; end < bufend; end++)
  1618. X            switch (state) {
  1619. X            case 0:
  1620. X                if (!isifs[*(unsigned char *)end]) {
  1621. X                    state = 1;
  1622. X                    r->w = end;
  1623. X                }
  1624. X                break;
  1625. X            case 1:
  1626. X                if (isifs[*(unsigned char *)end]) {
  1627. X                    state = 0;
  1628. X                    *end = '\0';
  1629. X                    prev = r;
  1630. X                    r = r->n = nnew(List);
  1631. X                    r->w = end+1;
  1632. X                    r->m = NULL;
  1633. X                }
  1634. X                break;
  1635. X            }
  1636. X    }
  1637. X
  1638. X    if (state == 1) { /* terminate last string */
  1639. X        *end = '\0';
  1640. X        r->n = NULL;
  1641. X    } else {
  1642. X        if (prev == NULL) /* no input at all? */
  1643. X            top = NULL;
  1644. X        else
  1645. X            prev->n = NULL; /* else terminate list */
  1646. X    }
  1647. X        
  1648. X    return top;
  1649. }
  1650. X
  1651. static List *backq(Node *ifsnode, Node *n) {
  1652. X    int p[2], pid, sp;
  1653. X    List *result, *ifs;
  1654. X
  1655. X    if (n == NULL)
  1656. X        return NULL;
  1657. X
  1658. X    if (pipe(p) < 0) {
  1659. X        uerror("pipe");
  1660. X        rc_error(NULL);
  1661. X    }
  1662. X
  1663. X    if ((pid = rc_fork()) == 0) {
  1664. X        setsigdefaults();
  1665. X        dup2(p[1],1);
  1666. X        close(p[0]);
  1667. X        close(p[1]);
  1668. X        redirq = NULL;
  1669. X        fifoq = NULL;
  1670. X        walk(n, FALSE);
  1671. X        exit(getstatus());
  1672. X    }
  1673. X
  1674. X    ifs = glom(ifsnode);
  1675. X    close(p[1]);
  1676. X    result = bqinput(ifs, p[0]);
  1677. X    close(p[0]);
  1678. X    rc_wait4(pid, &sp);
  1679. X    statprint(sp);
  1680. X    return result;
  1681. }
  1682. X
  1683. void qredir(Node *n) {
  1684. X    Rq *next;
  1685. X
  1686. X    if (redirq == NULL) {
  1687. X        next = redirq = nnew(Rq);
  1688. X    } else {
  1689. X        for (next = redirq; next->n != NULL; next = next->n)
  1690. X            ;
  1691. X        next->n = nnew(Rq);
  1692. X        next = next->n;
  1693. X    }
  1694. X
  1695. X    next->r = n;
  1696. X    next->n = NULL;
  1697. }
  1698. X
  1699. #ifdef NOCMDARG
  1700. static List *mkcmdarg(Node *n) {
  1701. X    rc_error("named pipes are not supported");
  1702. X    return NULL;
  1703. }
  1704. #else
  1705. #ifndef DEVFD
  1706. static List *mkcmdarg(Node *n) {
  1707. X    int fd, pid;
  1708. X    char *name, buf[32];
  1709. X    List *ret = nnew(List);
  1710. X    Fq *f = nnew(Fq);
  1711. X    static int fifonumber = 0;
  1712. X
  1713. X    name = sprint(buf,"/tmp/rc%d.%d", getpid(), fifonumber++);
  1714. X    name = ncpy(name);
  1715. X
  1716. X    if (mknod(name, S_IFIFO | 0644, 0) < 0) {
  1717. X        uerror("mknod");
  1718. X        return NULL;
  1719. X    }
  1720. X
  1721. X    if ((pid = rc_fork()) == 0) {
  1722. X        setsigdefaults();
  1723. X        /* fd = rc_open(name, CREATE); */
  1724. X        fd = rc_open(name, (n->u[0].i != FROM) ? FROM : CREATE); /* stupid hack */
  1725. X        if (fd < 0) {
  1726. X            uerror("open");
  1727. X            exit(1);
  1728. X        }
  1729. X        if (dup2(fd, (n->u[0].i == FROM)) < 0) { /* same stupid hack */
  1730. X            uerror("dup2");
  1731. X            exit(1);
  1732. X        }
  1733. X        close(fd);
  1734. X        redirq = NULL;
  1735. X        fifoq = NULL;
  1736. X        walk(n->u[2].p, FALSE);
  1737. X        exit(getstatus());
  1738. X    }
  1739. X
  1740. X    f->pid = pid;
  1741. X    f->name = name;
  1742. X    f->n = fifoq;
  1743. X    fifoq = f;
  1744. X
  1745. X    ret->w = name;
  1746. X    ret->m = NULL;
  1747. X    ret->n = NULL;
  1748. X
  1749. X    return ret;
  1750. }
  1751. #else
  1752. static List *mkcmdarg(Node *n) {
  1753. X    char *name, buf[32];
  1754. X    List *ret = nnew(List);
  1755. X    int p[2];
  1756. X
  1757. X    if (pipe(p) < 0) {
  1758. X        uerror("pipe");
  1759. X        return NULL;
  1760. X    }
  1761. X
  1762. X    if (rc_fork() == 0) {
  1763. X        setsigdefaults();
  1764. X
  1765. X        if (dup2(p[n->u[0].i == FROM], n->u[0].i == FROM) < 0) { /* stupid hack */
  1766. X            uerror("dup2");
  1767. X            exit(1);
  1768. X        }
  1769. X        close(p[n->u[0].i != FROM]);
  1770. X
  1771. X        redirq = NULL;
  1772. X        walk(n->u[2].p, FALSE);
  1773. X        exit(getstatus());
  1774. X    }
  1775. X
  1776. X    name = sprint(buf, "/dev/fd/%d", p[n->u[0].i != FROM]);
  1777. X    name = ncpy(name); /* ncpy evaluates the expression twice */
  1778. X    ret->w = name;
  1779. X    ret->m = NULL;
  1780. X    ret->n = NULL;
  1781. X
  1782. X    close(p[n->u[0].i == FROM]);
  1783. X
  1784. X    return ret;
  1785. }
  1786. #endif /* DEVFD */
  1787. #endif /* !NOCMDARG */
  1788. X
  1789. List *glom(Node *n) {
  1790. X    Node *words;
  1791. X    List *v, *first, *last;
  1792. X    boolean dollarstar;
  1793. X
  1794. X    if (n == NULL)
  1795. X        return NULL;
  1796. X
  1797. X    switch (n->type) {
  1798. X    case ARGS:
  1799. X    case LAPPEND:
  1800. X        words = n->u[0].p;
  1801. X        last = NULL;
  1802. X        while (words != NULL && (words->type == ARGS || words->type == LAPPEND)) {
  1803. X            if (words->u[1].p != NULL && words->u[1].p->type != rWORD && words->u[1].p->type != QWORD)
  1804. X                break;
  1805. X            first = glom(words->u[1].p);
  1806. X            if (first != NULL) {
  1807. X                first->n = last;
  1808. X                last = first;
  1809. X            }
  1810. X            words = words->u[0].p;
  1811. X        }
  1812. X        v = append(glom(words), last); /* force left to right evaluation */
  1813. X        return append(v, glom(n->u[1].p));
  1814. X    case BACKQ:
  1815. X        return backq(n->u[0].p,n->u[1].p);
  1816. X    case CONCAT:
  1817. X        first = glom(n->u[0].p); /* force left-to-right evaluation */
  1818. X        return concat(first, glom(n->u[1].p));
  1819. X    case rDUP:
  1820. X    case rREDIR:
  1821. X        qredir(n);
  1822. X        return NULL;
  1823. X    case rWORD: case QWORD:
  1824. X        return word(n->u[0].s,n->u[1].s);
  1825. X    case NMPIPE:
  1826. X        return mkcmdarg(n);
  1827. X    default:
  1828. X        break;
  1829. X    }
  1830. X
  1831. X    /*
  1832. X           the next three operations depend on the left-child of glom
  1833. X       to be a variable name. Therefore they are all treated here.
  1834. X       (previously each function looked up and checked the validity
  1835. X       of a variable name)
  1836. X    */
  1837. X
  1838. X    v = glom(n->u[0].p);
  1839. X    if (v == NULL)
  1840. X        rc_error("null variable name");
  1841. X    if (v->n != NULL)
  1842. X        rc_error("multi-word variable name");
  1843. X    if (*v->w == '\0')
  1844. X        rc_error("zero-length variable name");
  1845. X
  1846. X    dollarstar = (v->w[0] == '*' && v->w[1] == '\0');
  1847. X    v = varlookup(v->w);
  1848. X    if (dollarstar)
  1849. X        v = v->n;
  1850. X
  1851. X    switch (n->type) {
  1852. X    default:
  1853. X        fprint(2,"glom: this can't happen\n");
  1854. X        exit(1);
  1855. X        /* NOTREACHED */
  1856. X    case rCOUNT:
  1857. X        return count(v);
  1858. X    case rFLAT:
  1859. X        return flatten(v);
  1860. X    case VAR:
  1861. X        return v;
  1862. X    case VARSUB:
  1863. X        return varsub(v, glom(n->u[1].p));
  1864. X    }
  1865. X
  1866. }
  1867. SHAR_EOF
  1868. chmod 0644 glom.c ||
  1869. echo 'restore of glom.c failed'
  1870. Wc_c="`wc -c < 'glom.c'`"
  1871. test 9512 -eq "$Wc_c" ||
  1872.     echo 'glom.c: original size 9512, current size' "$Wc_c"
  1873. rm -f _shar_wnt_.tmp
  1874. fi
  1875. # ============= glom.h ==============
  1876. if test -f 'glom.h' -a X"$1" != X"-c"; then
  1877.     echo 'x - skipping glom.h (File already exists)'
  1878.     rm -f _shar_wnt_.tmp
  1879. else
  1880. > _shar_wnt_.tmp
  1881. echo 'x - extracting glom.h (Text)'
  1882. sed 's/^X//' << 'SHAR_EOF' > 'glom.h' &&
  1883. extern void assign(List *, List *, boolean);
  1884. extern void qredir(Node *);
  1885. extern List *append(List *, List*);
  1886. extern List *flatten(List *);
  1887. extern List *glom(Node *);
  1888. extern List *concat(List *, List *);
  1889. extern List *varsub(List *, List *);
  1890. extern List *word(char *, char *);
  1891. X
  1892. struct Fq {
  1893. X    int pid;
  1894. X    char *name;
  1895. X    Fq *n;
  1896. };
  1897. SHAR_EOF
  1898. chmod 0644 glom.h ||
  1899. echo 'restore of glom.h failed'
  1900. Wc_c="`wc -c < 'glom.h'`"
  1901. test 322 -eq "$Wc_c" ||
  1902.     echo 'glom.h: original size 322, current size' "$Wc_c"
  1903. rm -f _shar_wnt_.tmp
  1904. fi
  1905. # ============= hash.c ==============
  1906. if test -f 'hash.c' -a X"$1" != X"-c"; then
  1907.     echo 'x - skipping hash.c (File already exists)'
  1908.     rm -f _shar_wnt_.tmp
  1909. else
  1910. > _shar_wnt_.tmp
  1911. echo 'x - extracting hash.c (Text)'
  1912. sed 's/^X//' << 'SHAR_EOF' > 'hash.c' &&
  1913. /* hash.c: hash table support for functions and variables. */
  1914. X
  1915. /*
  1916. X   functions and variables are cached in both internal and external
  1917. X   form for performance. Thus a variable which is never "dereferenced"
  1918. X   with a $ is passed on to rc's children untouched. This is not so
  1919. X   important for variables, but is a big win for functions, where a call
  1920. X   to yyparse() is involved.
  1921. */
  1922. X
  1923. #include "rc.h"
  1924. #include "utils.h"
  1925. #include "hash.h"
  1926. #include "list.h"
  1927. #include "tree.h"
  1928. #include "footobar.h"
  1929. #include "sigmsgs.h"
  1930. X
  1931. static boolean var_exportable(char *);
  1932. static boolean fn_exportable(char *);
  1933. static int hash(char *, int);
  1934. static int find(char *, Htab *, int);
  1935. static void free_fn(Function *);
  1936. X
  1937. Htab *fp;
  1938. Htab *vp;
  1939. static int fused, fsize, vused, vsize;
  1940. static char **env;
  1941. static int bozosize;
  1942. static int envsize;
  1943. static boolean env_dirty = TRUE;
  1944. static char *dead = "";
  1945. X
  1946. #define HASHSIZE 64 /* rc was debugged with HASHSIZE == 2; 64 is about right for normal use */
  1947. X
  1948. void inithash() {
  1949. X    int i;
  1950. X    Htab *fpp, *vpp;
  1951. X
  1952. X    fp = ealloc(sizeof(Htab) * HASHSIZE);
  1953. X    vp = ealloc(sizeof(Htab) * HASHSIZE);
  1954. X    fused = vused = 0;
  1955. X    fsize = vsize = HASHSIZE;
  1956. X
  1957. X    for (vpp = vp, fpp = fp, i = 0; i < HASHSIZE; i++, vpp++, fpp++)
  1958. X        vpp->name = fpp->name = NULL;
  1959. }
  1960. X
  1961. #define ADV()   {if ((c = *s++) == '\0') break;}
  1962. X
  1963. /* hash function courtesy of paul haahr */
  1964. X
  1965. static int hash(char *s, int size) {
  1966. X    int n = 0;
  1967. X    int c;
  1968. X
  1969. X    while (1) {
  1970. X        ADV();
  1971. X        n += (c << 17) ^ (c << 11) ^ (c << 5) ^ (c >> 1);
  1972. X        ADV();
  1973. X        n ^= (c << 14) + (c << 7) + (c << 4) + c;
  1974. X        ADV();
  1975. X        n ^= (~c << 11) | ((c << 3) ^ (c >> 1));
  1976. X        ADV();
  1977. X        n -= (c << 16) | (c << 9) | (c << 2) | (c & 3);
  1978. X    }
  1979. X
  1980. X    if (n < 0)
  1981. X        n = ~n;
  1982. X
  1983. X    return n & (size - 1); /* need power of 2 size */
  1984. }
  1985. X
  1986. static boolean rehash(Htab *ht) {
  1987. X    int i,j,size;
  1988. X    int newsize,newused;
  1989. X    Htab *newhtab;
  1990. X
  1991. X    if (ht == fp) {
  1992. X        if (fsize > 2 * fused)
  1993. X            return FALSE;
  1994. X        size = fsize;
  1995. X    } else {
  1996. X        if (vsize > 2 * vused)
  1997. X            return FALSE;
  1998. X        size = vsize;
  1999. X    }
  2000. X
  2001. X
  2002. X    newsize = 2 * size;
  2003. X    newhtab = ealloc(newsize * sizeof(Htab));
  2004. X    for (i = 0; i < newsize; i++)
  2005. X        newhtab[i].name = NULL;
  2006. X
  2007. X    for (i = newused = 0; i < size; i++)
  2008. X        if (ht[i].name != NULL && ht[i].name != dead) {
  2009. X            newused++;
  2010. X            j = hash(ht[i].name, newsize);
  2011. X            while (newhtab[j].name != NULL) {
  2012. X                j++;
  2013. X                j &= (newsize - 1);
  2014. X            }
  2015. X            newhtab[j].name = ht[i].name;
  2016. X            newhtab[j].p = ht[i].p;
  2017. X        }
  2018. X
  2019. X    if (ht == fp) {
  2020. X        fused = newused;
  2021. X        fp = newhtab;
  2022. X        fsize = newsize;
  2023. X    } else {
  2024. X        vused = newused;
  2025. X        vp = newhtab;
  2026. X        vsize = newsize;
  2027. X    }
  2028. X
  2029. X    efree(ht);
  2030. X    return TRUE;
  2031. }
  2032. X
  2033. #define varfind(s) find(s,vp,vsize)
  2034. #define fnfind(s) find(s,fp,fsize)
  2035. X
  2036. static int find(char *s, Htab *ht, int size) {
  2037. X    int h = hash(s, size);
  2038. X
  2039. X    while (ht[h].name != NULL && !streq(ht[h].name,s)) {
  2040. X        h++;
  2041. X        h &= size - 1;
  2042. X    }
  2043. X
  2044. X    return h;
  2045. }
  2046. X
  2047. void *lookup(char *s, Htab *ht) {
  2048. X    int h = find(s, ht, ht == fp ? fsize : vsize);
  2049. X
  2050. X    return (ht[h].name == NULL) ? NULL : ht[h].p;
  2051. }
  2052. X
  2053. Function *get_fn_place(char *s) {
  2054. X    int h = fnfind(s);
  2055. X
  2056. X    env_dirty = TRUE;
  2057. X
  2058. X    if (fp[h].name == NULL) {
  2059. X        if (rehash(fp))
  2060. X            h = fnfind(s);
  2061. X        fused++;
  2062. X        fp[h].name = ecpy(s);
  2063. X        fp[h].p = enew(Function);
  2064. X    } else
  2065. X        free_fn(fp[h].p);
  2066. X
  2067. X    return fp[h].p;
  2068. }
  2069. X
  2070. Variable *get_var_place(char *s, boolean stack) {
  2071. X    Variable *new;
  2072. X    int h = varfind(s);
  2073. X
  2074. X    env_dirty = TRUE;
  2075. X
  2076. X    if (vp[h].name == NULL) {
  2077. X        if (rehash(vp))
  2078. X            h = varfind(s);
  2079. X        vused++;
  2080. X        vp[h].name = ecpy(s);
  2081. X        vp[h].p = enew(Variable);
  2082. X        ((Variable *)vp[h].p)->n = NULL;
  2083. X        return vp[h].p;
  2084. X    } else {
  2085. X        if (stack) {    /* increase the stack by 1 */
  2086. X            new = enew(Variable);
  2087. X            new->n = vp[h].p;
  2088. X            return vp[h].p = new;
  2089. X        } else {    /* trample the top of the stack */
  2090. X            new = vp[h].p;
  2091. X            efree(new->extdef);
  2092. X            listfree(new->def);
  2093. X            return new;
  2094. X        }
  2095. X    }
  2096. }
  2097. X
  2098. void delete_fn(char *s) {
  2099. X    int h = fnfind(s);
  2100. X
  2101. X    if (fp[h].name == NULL)
  2102. X        return; /* not found */
  2103. X
  2104. X    env_dirty = TRUE;
  2105. X
  2106. X    free_fn(fp[h].p);
  2107. X    efree(fp[h].p);
  2108. X    efree(fp[h].name);
  2109. X    if (fp[(h+1)&(fsize-1)].name == NULL) {
  2110. X        --fused;
  2111. X        fp[h].name = NULL;
  2112. X    } else {
  2113. X        fp[h].name = dead;
  2114. X    }
  2115. }
  2116. X
  2117. void delete_var(char *s, boolean stack) {
  2118. X    int h = varfind(s);
  2119. X    Variable *v;
  2120. X
  2121. X    if (vp[h].name == NULL)
  2122. X        return; /* not found */
  2123. X
  2124. X    env_dirty = TRUE;
  2125. X
  2126. X    v = vp[h].p;
  2127. X    efree(v->extdef);
  2128. X    listfree(v->def);
  2129. X
  2130. X    if (v->n != NULL) { /* This is the top of a stack */
  2131. X        if (stack) { /* pop */
  2132. X            vp[h].p = v->n;
  2133. X            efree(v);
  2134. X        } else { /* else just empty */
  2135. X            v->extdef = NULL;
  2136. X            v->def = NULL;
  2137. X        }
  2138. X    } else { /* needs to be removed from the hash table */
  2139. X        efree(v);
  2140. X        efree(vp[h].name);
  2141. X        if (vp[(h+1)&(vsize-1)].name == NULL) {
  2142. X            --vused;
  2143. X            vp[h].name = NULL;
  2144. X        } else {
  2145. X            vp[h].name = dead;
  2146. X        }
  2147. X    }
  2148. }
  2149. X
  2150. static void free_fn(Function *f) {
  2151. X    treefree(f->def);
  2152. X    efree(f->extdef);
  2153. }
  2154. X
  2155. void initenv(char **envp) {
  2156. X    int n;
  2157. X
  2158. X    for (n = 0; envp[n] != NULL; n++)
  2159. X        ;
  2160. X    n++; /* one for the null terminator */
  2161. X
  2162. X    if (n < HASHSIZE)
  2163. X        n = HASHSIZE;
  2164. X
  2165. X    env = ealloc((envsize = 2 * n) * sizeof (char *));
  2166. X
  2167. X    for (; *envp != NULL; envp++)
  2168. X        if (strncmp(*envp, "fn_", sizeof("fn_") - 1) == 0)
  2169. X            fnassign_string(*envp);
  2170. X        else
  2171. X            if (!varassign_string(*envp)) /* add to bozo env */
  2172. X                env[bozosize++] = *envp;
  2173. }
  2174. X
  2175. static boolean var_exportable(char *s) {
  2176. X    int i;
  2177. X    static char *notforexport[] = {
  2178. X        "apid", "pid", "apids", "*", "ifs"
  2179. X    };
  2180. X
  2181. X    for (i = 0; i < arraysize(notforexport); i++)
  2182. X        if (streq(s,notforexport[i]))
  2183. X            return FALSE;
  2184. X
  2185. X    return TRUE;
  2186. }
  2187. X
  2188. static boolean fn_exportable(char *s) {
  2189. X    int i;
  2190. X
  2191. X    if (strncmp(s,"sig",3) == 0) { /* small speed hack */
  2192. X        for (i = 0; i < NUMOFSIGNALS; i++)
  2193. X            if (streq(s, signals[i][0]))
  2194. X                return FALSE;
  2195. X
  2196. X        if (streq(s, "sigexit"))
  2197. X            return FALSE;
  2198. X    }
  2199. X
  2200. X    return TRUE;
  2201. }
  2202. X
  2203. char **makeenv() {
  2204. X    int ep, i;
  2205. X    char *v;
  2206. X
  2207. X    if (!env_dirty)
  2208. X        return env;
  2209. X
  2210. X    env_dirty = FALSE;
  2211. X    ep = bozosize;
  2212. X
  2213. X    if (vsize + fsize + 1 + bozosize > envsize) {
  2214. X        envsize = 2 * (bozosize + vsize + fsize + 1);
  2215. X        env = erealloc(env, envsize * sizeof(char *));
  2216. X    }
  2217. X
  2218. X    for (i = 0; i < vsize; i++) {
  2219. X        if (vp[i].name == NULL || vp[i].name == dead || !var_exportable(vp[i].name))
  2220. X            continue;
  2221. X        v = varlookup_string(vp[i].name);
  2222. X        if (v != NULL)
  2223. X            env[ep++] = v;
  2224. X    }
  2225. X    for (i = 0; i < fsize; i++) {
  2226. X        if (fp[i].name == NULL || fp[i].name == dead || !fn_exportable(fp[i].name))
  2227. X            continue;
  2228. X        env[ep++] = fnlookup_string(fp[i].name);
  2229. X    }
  2230. X    env[ep] = NULL;
  2231. X    qsort(env, ep, sizeof(char *), starstrcmp);
  2232. X    return env;
  2233. }
  2234. X
  2235. void whatare_all_vars() {
  2236. X    int i;
  2237. X    List *s;
  2238. X
  2239. X    for (i = 0; i < vsize; i++)
  2240. X        if (vp[i].name != NULL && (s = varlookup(vp[i].name)) != NULL)
  2241. X            prettyprint_var(1, vp[i].name, s);
  2242. X
  2243. X    for (i = 0; i < fsize; i++)
  2244. X        if (fp[i].name != NULL)
  2245. X            prettyprint_fn(1, fp[i].name, fnlookup(fp[i].name));
  2246. }
  2247. X
  2248. /* fake getenv() for readline() follows: */
  2249. X
  2250. #ifdef READLINE
  2251. char *getenv(const char *name) {
  2252. X    List *s;
  2253. X
  2254. X    if (name == NULL || vp == NULL || (s = varlookup((char *) name)) == NULL)
  2255. X        return NULL;
  2256. X
  2257. X    return s->w;
  2258. }
  2259. #endif
  2260. X
  2261. SHAR_EOF
  2262. chmod 0644 hash.c ||
  2263. echo 'restore of hash.c failed'
  2264. Wc_c="`wc -c < 'hash.c'`"
  2265. test 6760 -eq "$Wc_c" ||
  2266.     echo 'hash.c: original size 6760, current size' "$Wc_c"
  2267. rm -f _shar_wnt_.tmp
  2268. fi
  2269. # ============= hash.h ==============
  2270. if test -f 'hash.h' -a X"$1" != X"-c"; then
  2271.     echo 'x - skipping hash.h (File already exists)'
  2272.     rm -f _shar_wnt_.tmp
  2273. else
  2274. > _shar_wnt_.tmp
  2275. echo 'x - extracting hash.h (Text)'
  2276. sed 's/^X//' << 'SHAR_EOF' > 'hash.h' &&
  2277. typedef struct Function {
  2278. X    Node *def;
  2279. X    char *extdef;
  2280. } Function;
  2281. X
  2282. typedef struct Variable {
  2283. X    List *def;
  2284. X    char *extdef;
  2285. X    struct Variable *n;
  2286. } Variable;
  2287. X
  2288. typedef struct Htab {
  2289. X    char *name;
  2290. X    void *p;
  2291. } Htab;
  2292. X
  2293. extern Htab *fp, *vp;
  2294. X
  2295. #define lookup_fn(s) ((Function *) lookup(s,fp))
  2296. #define lookup_var(s) ((Variable *) lookup(s,vp))
  2297. X
  2298. extern void *lookup(char *, Htab *);
  2299. extern Function *get_fn_place(char *);
  2300. extern List *varlookup(char *);
  2301. extern Node *fnlookup(char *);
  2302. extern Variable *get_var_place(char *, boolean);
  2303. extern boolean varassign_string(char *);
  2304. extern char **makeenv(void);
  2305. extern char *fnlookup_string(char *);
  2306. extern char *varlookup_string(char *);
  2307. extern void alias(char *, List *, boolean);
  2308. extern void starassign(char *, char **, boolean);
  2309. extern void delete_fn(char *);
  2310. extern void delete_var(char *, boolean);
  2311. extern void fnassign(char *, Node *);
  2312. extern void fnassign_string(char *);
  2313. extern void fnrm(char *);
  2314. extern void initenv(char **);
  2315. extern void inithash(void);
  2316. extern void setsigdefaults(void);
  2317. extern void inithandler(void);
  2318. extern void varassign(char *, List *, boolean);
  2319. extern void varrm(char *, boolean);
  2320. extern void whatare_all_vars(void);
  2321. extern void whatare_all_signals(void);
  2322. extern void prettyprint_var(int, char *, List *);
  2323. extern void prettyprint_fn(int, char *, Node *);
  2324. SHAR_EOF
  2325. chmod 0644 hash.h ||
  2326. echo 'restore of hash.h failed'
  2327. Wc_c="`wc -c < 'hash.h'`"
  2328. test 1313 -eq "$Wc_c" ||
  2329.     echo 'hash.h: original size 1313, current size' "$Wc_c"
  2330. rm -f _shar_wnt_.tmp
  2331. fi
  2332. # ============= heredoc.c ==============
  2333. if test -f 'heredoc.c' -a X"$1" != X"-c"; then
  2334.     echo 'x - skipping heredoc.c (File already exists)'
  2335.     rm -f _shar_wnt_.tmp
  2336. else
  2337. > _shar_wnt_.tmp
  2338. echo 'x - extracting heredoc.c (Text)'
  2339. sed 's/^X//' << 'SHAR_EOF' > 'heredoc.c' &&
  2340. /* heredoc.c: heredoc slurping is done here */
  2341. X
  2342. #include "rc.h"
  2343. #include "lex.h"
  2344. #include "utils.h"
  2345. #include "nalloc.h"
  2346. #include "heredoc.h"
  2347. #include "tree.h"
  2348. #include "input.h"
  2349. #include "hash.h"
  2350. #include "glom.h"
  2351. X
  2352. struct Hq {
  2353. X    Node *doc;
  2354. X    char *name;
  2355. X    Hq *n;
  2356. X    boolean quoted;
  2357. } *hq;
  2358. X
  2359. static boolean dead = FALSE;
  2360. X
  2361. /*
  2362. X * read in a heredocument. A clever trick: skip over any partially matched end-of-file
  2363. X * marker storing only the number of characters matched. If the whole marker is matched,
  2364. X * return from readheredoc(). If only part of the marker is matched, copy that part into
  2365. X * the heredocument.
  2366. X *
  2367. X * BUG: if the eof string contains a newline, the state can get confused, and the
  2368. X * heredoc may continue past where it should.  on the other hand, /bin/sh seems to
  2369. X * never get out of its readheredoc() when the heredoc string contains a newline
  2370. X */
  2371. X
  2372. static char *readheredoc(char *eof) {
  2373. X    int c;
  2374. X    char *t, *buf, *bufend;
  2375. X    unsigned char *s;
  2376. X    SIZE_T bufsize;
  2377. X
  2378. X    t = buf = nalloc(bufsize = 512);
  2379. X    bufend = &buf[bufsize];
  2380. X    dead = FALSE;
  2381. X
  2382. #define    RESIZE(extra) { \
  2383. X        char *nbuf; \
  2384. X        bufsize = bufsize * 2 + extra; \
  2385. X        nbuf = nalloc(bufsize); \
  2386. X        memcpy(nbuf, buf, t - buf); \
  2387. X        t = nbuf + (t - buf); \
  2388. X        buf = nbuf; \
  2389. X        bufend = &buf[bufsize]; \
  2390. X    }
  2391. X    
  2392. X    for (;;) {
  2393. X        print_prompt2();
  2394. X        for (s = (unsigned char *) eof; (c = gchar()) == *s; s++)
  2395. X            ;
  2396. X        if (*s == '\0' && (c == '\n' || c == EOF)) {
  2397. X            *t++ = '\0';
  2398. X            return buf;
  2399. X        }
  2400. X        if (s != (unsigned char *) eof) {
  2401. X            SIZE_T len = s - (unsigned char *) eof;
  2402. X            if (t + len >= bufend)
  2403. X                RESIZE(len);
  2404. X            memcpy(t, eof, len);
  2405. X            t += len;
  2406. X        }
  2407. X        for (;; c = gchar()) {
  2408. X            if (c == EOF) {
  2409. X                yyerror("EOF inside heredoc");
  2410. X                dead = TRUE;
  2411. X                return NULL;
  2412. X            }
  2413. X            if (t + 1 >= bufend)
  2414. X                RESIZE(0);
  2415. X            *t++ = c;
  2416. X            if (c == '\n')
  2417. X                break;
  2418. X        }
  2419. X    }
  2420. }
  2421. X
  2422. /* parseheredoc -- turn a heredoc with variable references into a node chain */
  2423. X
  2424. static Node *parseheredoc(char *s) {
  2425. X    int c = *s;
  2426. X    Node *result = NULL;
  2427. X
  2428. X    while (TRUE) {
  2429. X        Node *node;
  2430. X
  2431. X        switch (c) {
  2432. X        default: {
  2433. X            char *begin = s;
  2434. X            while ((c = *s++) != '\0' && c != '$')
  2435. X                ;
  2436. X            *--s = '\0';
  2437. X            node = newnode(QWORD, begin, NULL);
  2438. X            break;
  2439. X        }
  2440. X        case '$': {
  2441. X            char *begin = ++s, *var;
  2442. X            c = *s++;
  2443. X            if (c == '$') {
  2444. X                node = newnode(QWORD, "$", NULL);
  2445. X                c = *s;
  2446. X            } else {
  2447. X                int len = 0;
  2448. X                do
  2449. X                    len++;
  2450. X                while (!dnw[c = *(unsigned char *) s++]);
  2451. X                if (c == '^')
  2452. X                    c = *s;
  2453. X                else
  2454. X                    s--;
  2455. X                var = nalloc(len + 1);
  2456. X                var[len] = '\0';
  2457. X                memcpy(var, begin, len);
  2458. X                node = newnode(rFLAT, newnode(rWORD, var, NULL));
  2459. X            }
  2460. X            break;
  2461. X        }
  2462. X        case '\0':
  2463. X            return result;
  2464. X        }
  2465. X
  2466. X        result = (result == NULL) ? node : newnode(CONCAT, result, node);
  2467. X    }
  2468. }
  2469. X
  2470. /* read in heredocs when yyparse hits a newline. called from yyparse */
  2471. X
  2472. int heredoc(int end) {
  2473. X    Hq *here;
  2474. X
  2475. X    if ((here = hq) != NULL) {
  2476. X        hq = NULL;
  2477. X        if (end) {
  2478. X            yyerror("EOF on command line with heredoc");
  2479. X            return FALSE;
  2480. X        }
  2481. X        do {
  2482. X            Node *n = here->doc;
  2483. X            char *s = readheredoc(here->name);
  2484. X            if (dead)
  2485. X                return FALSE;
  2486. X            n->u[2].p = here->quoted ? newnode(QWORD, s, NULL) : parseheredoc(s);
  2487. X            n->u[0].i = HERESTRING;
  2488. X        } while ((here = here->n) != NULL);
  2489. X    }
  2490. X    return TRUE;
  2491. }
  2492. X
  2493. /* queue pending heredocs into a queue. called from yyparse */
  2494. X
  2495. int qdoc(Node *name, Node *n) {
  2496. X    Hq *new, **prev;
  2497. X
  2498. X    if (name->type != rWORD && name->type != QWORD) {
  2499. X        yyerror("eof-marker must be a single literal word");
  2500. X        flushu();
  2501. X        return FALSE;
  2502. X    }
  2503. X
  2504. X    for (prev = &hq; (new = *prev) != NULL; prev = &new->n)
  2505. X        ;
  2506. X    *prev = new = nnew(Hq);
  2507. X
  2508. X    new->name = name->u[0].s;
  2509. X    new->quoted = (name->type == QWORD);
  2510. X    new->doc = n;
  2511. X    new->n = NULL;
  2512. X    return TRUE;
  2513. }
  2514. SHAR_EOF
  2515. chmod 0644 heredoc.c ||
  2516. echo 'restore of heredoc.c failed'
  2517. Wc_c="`wc -c < 'heredoc.c'`"
  2518. test 3622 -eq "$Wc_c" ||
  2519.     echo 'heredoc.c: original size 3622, current size' "$Wc_c"
  2520. rm -f _shar_wnt_.tmp
  2521. fi
  2522. # ============= heredoc.h ==============
  2523. if test -f 'heredoc.h' -a X"$1" != X"-c"; then
  2524.     echo 'x - skipping heredoc.h (File already exists)'
  2525.     rm -f _shar_wnt_.tmp
  2526. else
  2527. > _shar_wnt_.tmp
  2528. echo 'x - extracting heredoc.h (Text)'
  2529. sed 's/^X//' << 'SHAR_EOF' > 'heredoc.h' &&
  2530. extern int heredoc(int);
  2531. extern int qdoc(Node *, Node *);
  2532. X
  2533. typedef struct Hq Hq;
  2534. X
  2535. extern Hq *hq;
  2536. SHAR_EOF
  2537. chmod 0644 heredoc.h ||
  2538. echo 'restore of heredoc.h failed'
  2539. Wc_c="`wc -c < 'heredoc.h'`"
  2540. test 97 -eq "$Wc_c" ||
  2541.     echo 'heredoc.h: original size 97, current size' "$Wc_c"
  2542. rm -f _shar_wnt_.tmp
  2543. fi
  2544. # ============= hfix.awk ==============
  2545. if test -f 'hfix.awk' -a X"$1" != X"-c"; then
  2546.     echo 'x - skipping hfix.awk (File already exists)'
  2547.     rm -f _shar_wnt_.tmp
  2548. else
  2549. > _shar_wnt_.tmp
  2550. echo 'x - extracting hfix.awk (Text)'
  2551. sed 's/^X//' << 'SHAR_EOF' > 'hfix.awk' &&
  2552. /^extern void b_exec\(char \*\*\), funcall\(char \*\*\), b_dot\(char \*\*\), b_builtin\(char \*\*\);$/ {
  2553. SHAR_EOF
  2554. true || echo 'restore of hfix.awk failed'
  2555. fi
  2556. echo 'End of  part 2'
  2557. echo 'File hfix.awk is continued in part 3'
  2558. echo 3 > _shar_seq_.tmp
  2559. exit 0
  2560. exit 0 # Just in case...
  2561. -- 
  2562. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  2563. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  2564. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  2565. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  2566.