rsalz@uunet.uu.net (Rich Salz) (05/31/89)
Submitted-by: ka@june.cs.washington.edu (Kenneth Almquist) Posting-number: Volume 19, Issue 6 Archive-name: ash/part06 # This is part 6 of ash. To unpack, feed it into the shell (not csh). # The ash distribution consists of eight pieces. Be sure you get them all. # After you unpack everything, read the file README. echo extracting options.h cat > options.h <<\EOF /* * Copyright (C) 1989 by Kenneth Almquist. All rights reserved. * This file is part of ash, which is distributed under the terms specified * by the Ash General Public License. See the file named LICENSE. */ struct shparam { int nparam; /* number of positional parameters (without $0) */ char malloc; /* true if parameter list dynamicly allocated */ char **p; /* parameter list */ char **optnext; /* next parameter to be processed by getopts */ char *optptr; /* used by getopts */ }; extern const char optchar[10]; /* string specifying shell option characters */ extern char optval[10]; /* values of the corresponding options */ #define eflag optval[0] #define fflag optval[1] #define Iflag optval[2] #define iflag optval[3] #define jflag optval[4] #define nflag optval[5] #define sflag optval[6] #define xflag optval[7] #define zflag optval[8] extern char *minusc; /* argument to -c option */ extern char *arg0; /* $0 */ extern struct shparam shellparam; /* $@ */ extern char **argptr; /* argument list for builtin commands */ extern char *optarg; /* set by nextopt */ extern char *optptr; /* used by nextopt */ #ifdef __STDC__ void procargs(int, char **); void setparam(char **); void freeparam(struct shparam *); int nextopt(char *); #else void procargs(); void setparam(); void freeparam(); int nextopt(); #endif EOF if test `wc -c < options.h` -ne 1370 then echo 'options.h is the wrong size' fi echo extracting options.c cat > options.c <<\EOF /* * Copyright (C) 1989 by Kenneth Almquist. All rights reserved. * This file is part of ash, which is distributed under the terms specified * by the Ash General Public License. See the file named LICENSE. */ #include "shell.h" #include "options.h" #include "nodes.h" /* for other header files */ #include "eval.h" #include "jobs.h" #include "input.h" #include "output.h" #include "trap.h" #include "var.h" #include "memalloc.h" #include "error.h" #include "mystring.h" const char optchar[10] = "efIijnsxz"; /* shell flags */ char optval[10]; /* values of option flags */ char *arg0; /* value of $0 */ struct shparam shellparam; /* current positional parameters */ char **argptr; /* argument list for builtin commands */ char *optarg; /* set by nextopt (like getopt) */ char *optptr; /* used by nextopt */ char *minusc; /* argument to -c option */ #ifdef __STDC__ STATIC void options(int); STATIC void setoption(int, int); #else STATIC void options(); STATIC void setoption(); #endif /* * Process the shell command line arguments. */ void procargs(argc, argv) char **argv; { char *p; argptr = argv; if (argc > 0) argptr++; for (p = optval ; p < optval + sizeof optval - 1 ; p++) *p = 2; options(1); if (*argptr == NULL && minusc == NULL) sflag = 1; if (iflag == 2 && sflag == 1 && isatty(0) && isatty(1)) iflag = 1; if (jflag == 2) jflag = iflag; for (p = optval ; p < optval + sizeof optval - 1 ; p++) if (*p == 2) *p = 0; arg0 = argv[0]; if (sflag == 0 && minusc == NULL) { commandname = arg0 = *argptr++; setinputfile(commandname, 0); } shellparam.p = argptr; /* assert(shellparam.malloc == 0 && shellparam.nparam == 0); */ while (*argptr) { shellparam.nparam++; argptr++; } setinteractive(iflag); setjobctl(jflag); } /* * Process shell options. The global variable argptr contains a pointer * to the argument list; we advance it past the options. */ STATIC void options(cmdline) { register char *p; int val; int c; minusc = NULL; while ((p = *argptr) != NULL) { argptr++; if ((c = *p++) == '-') { val = 1; if (p[0] == '-' && p[1] == '\0') break; /* "--" terminates options */ } else if (c == '+') { val = 0; } else { argptr--; break; } while ((c = *p++) != '\0') { if (c == 'c' && cmdline) { if (*p == '\0') p = *argptr++; if (p == NULL || minusc != NULL) error("Bad -c option"); minusc = p; break; } else { setoption(c, val); } } if (! cmdline) break; } } STATIC void setoption(flag, val) char flag; int val; { register char *p; if ((p = strchr(optchar, flag)) == NULL) error("Illegal option -%c", flag); optval[p - optchar] = val; } #ifdef mkinit INCLUDE "options.h" SHELLPROC { char *p; for (p = optval ; p < optval + sizeof optval ; p++) *p = 0; } #endif /* * Set the shell parameters. */ void setparam(argv) char **argv; { char **newparam; char **ap; int nparam; for (nparam = 0 ; argv[nparam] ; nparam++); ap = newparam = ckmalloc((nparam + 1) * sizeof *ap); while (*argv) { *ap++ = savestr(*argv++); } *ap = NULL; freeparam(&shellparam); shellparam.malloc = 1; shellparam.nparam = nparam; shellparam.p = newparam; shellparam.optnext = NULL; } /* * Free the list of positional parameters. */ void freeparam(param) struct shparam *param; { char **ap; if (param->malloc) { for (ap = param->p ; *ap ; ap++) ckfree(*ap); ckfree(param->p); } } /* * The shift builtin command. */ shiftcmd(argc, argv) char **argv; { int n; char **ap1, **ap2; n = 1; if (argc > 1) n = number(argv[1]); if (n > shellparam.nparam) n = shellparam.nparam; INTOFF; shellparam.nparam -= n; for (ap1 = shellparam.p ; --n >= 0 ; ap1++) { if (shellparam.malloc) ckfree(*ap1); } ap2 = shellparam.p; while ((*ap2++ = *ap1++) != NULL); shellparam.optnext = NULL; INTON; return 0; } /* * The set command builtin. */ setcmd(argc, argv) char **argv; { if (argc == 1) return showvarscmd(argc, argv); INTOFF; options(0); setinteractive(iflag); setjobctl(jflag); if (*argptr != NULL) { setparam(argptr); } INTON; return 0; } /* * The getopts builtin. Shellparam.optnext points to the next argument * to be processed. Shellparam.optptr points to the next character to * be processed in the current argument. If shellparam.optnext is NULL, * then it's the first time getopts has been called. */ getoptscmd(argc, argv) char **argv; { register char *p, *q; char c; char s[10]; if (argc != 3) error("Usage: getopts optstring var"); if (shellparam.optnext == NULL) { shellparam.optnext = shellparam.p; shellparam.optptr = NULL; } if ((p = shellparam.optptr) == NULL || *p == '\0') { p = *shellparam.optnext; if (p == NULL || *p != '-' || *++p == '\0') { atend: fmtstr(s, 10, "%d", shellparam.optnext - shellparam.p + 1); setvar("OPTIND", s, 0); shellparam.optnext = NULL; return 1; } shellparam.optnext++; if (p[0] == '-' && p[1] == '\0') /* check for "--" */ goto atend; } c = *p++; for (q = argv[1] ; *q != c ; ) { if (*q == '\0') { out1fmt("Illegal option -%c\n", c); c = '?'; goto out; } if (*++q == ':') q++; } if (*++q == ':') { if (*p == '\0' && (p = *shellparam.optnext) == NULL) { out1fmt("No arg for -%c option\n", c); c = '?'; goto out; } shellparam.optnext++; setvar("OPTARG", p, 0); p = NULL; } out: shellparam.optptr = p; s[0] = c; s[1] = '\0'; setvar(argv[2], s, 0); return 0; } /* * Standard option processing (a la getopt) for builtin routines. The * only argument that is passed to nextopt is the option string; the * other arguments are unnecessary. It return the character, or '\0' on * end of input. */ int nextopt(optstring) char *optstring; { register char *p, *q; char c; if ((p = optptr) == NULL || *p == '\0') { p = *argptr; if (p == NULL || *p != '-' || *++p == '\0') return '\0'; argptr++; if (p[0] == '-' && p[1] == '\0') /* check for "--" */ return '\0'; } c = *p++; for (q = optstring ; *q != c ; ) { if (*q == '\0') error("Illegal option -%c", c); if (*++q == ':') q++; } if (*++q == ':') { if (*p == '\0' && (p = *argptr++) == NULL) error("No arg for -%c option", c); optarg = p; p = NULL; } optptr = p; return c; } EOF if test `wc -c < options.c` -ne 7075 then echo 'options.c is the wrong size' fi echo extracting output.h cat > output.h <<\EOF /* * Copyright (C) 1989 by Kenneth Almquist. All rights reserved. * This file is part of ash, which is distributed under the terms specified * by the Ash General Public License. See the file named LICENSE. */ #ifndef OUTPUT_INCL struct output { char *nextc; int nleft; char *buf; int bufsize; short fd; short flags; }; extern struct output output; extern struct output errout; extern struct output memout; extern struct output *out1; extern struct output *out2; #ifdef __STDC__ void outstr(char *, struct output *); void out1str(char *); void out2str(char *); void outfmt(struct output *, char *, ...); void out1fmt(char *, ...); void fmtstr(char *, int, char *, ...); /* void doformat(struct output *, char *, va_list); */ void doformat(); void emptyoutbuf(struct output *); void flushall(void); void flushout(struct output *); void freestdout(void); int xwrite(int, char *, int); int xioctl(int, int, int); #else void outstr(); void out1str(); void out2str(); void outfmt(); void out1fmt(); void fmtstr(); /* void doformat(); */ void doformat(); void emptyoutbuf(); void flushall(); void flushout(); void freestdout(); int xwrite(); int xioctl(); #endif #define outc(c, file) (--(file)->nleft < 0? (emptyoutbuf(file), *(file)->nextc++ = (c)) : (*(file)->nextc++ = (c))) #define out1c(c) outc(c, out1); #define out2c(c) outc(c, out2); #define OUTPUT_INCL #endif EOF if test `wc -c < output.h` -ne 1412 then echo 'output.h is the wrong size' fi echo extracting output.c cat > output.c <<\EOF /* * Shell output routines. We use our own output routines because: * When a builtin command is interrupted we have to discard * any pending output. * When a builtin command appears in back quotes, we want to * save the output of the command in a region obtained * via malloc, rather than doing a fork and reading the * output of the command via a pipe. * Our output routines may be smaller than the stdio routines. * * Copyright (C) 1989 by Kenneth Almquist. All rights reserved. * This file is part of ash, which is distributed under the terms specified * by the Ash General Public License. See the file named LICENSE. */ #include <stdio.h> /* defines BUFSIZ */ #include "shell.h" #include "syntax.h" #include "output.h" #include "memalloc.h" #include "error.h" #ifdef __STDC__ #include "stdarg.h" #else #include <varargs.h> #endif #include "myerrno.h" #define OUTBUFSIZ BUFSIZ #define BLOCK_OUT -2 /* output to a fixed block of memory */ #define MEM_OUT -3 /* output to dynamically allocated memory */ #define OUTPUT_ERR 01 /* error occurred on output */ struct output output = {NULL, 0, NULL, OUTBUFSIZ, 1, 0}; struct output errout = {NULL, 0, NULL, 100, 2, 0};; struct output memout = {NULL, 0, NULL, 0, MEM_OUT, 0}; struct output *out1 = &output; struct output *out2 = &errout; #ifdef mkinit INCLUDE "output.h" INCLUDE "memalloc.h" RESET { out1 = &output; out2 = &errout; if (memout.buf != NULL) { ckfree(memout.buf); memout.buf = NULL; } } #endif #ifdef notdef /* no longer used */ /* * Set up an output file to write to memory rather than a file. */ void open_mem(block, length, file) char *block; int length; struct output *file; { file->nextc = block; file->nleft = --length; file->fd = BLOCK_OUT; file->flags = 0; } #endif void out1str(p) char *p; { outstr(p, out1); } void out2str(p) char *p; { outstr(p, out2); } void outstr(p, file) register char *p; register struct output *file; { while (*p) outc(*p++, file); } char out_junk[16]; void emptyoutbuf(dest) struct output *dest; { int offset; if (dest->fd == BLOCK_OUT) { dest->nextc = out_junk; dest->nleft = sizeof out_junk; dest->flags |= OUTPUT_ERR; } else if (dest->buf == NULL) { INTOFF; dest->buf = ckmalloc(dest->bufsize); dest->nextc = dest->buf; dest->nleft = dest->bufsize; INTON; } else if (dest->fd == MEM_OUT) { offset = dest->bufsize; INTOFF; dest->bufsize <<= 1; dest->buf = ckrealloc(dest->buf, dest->bufsize); dest->nleft = dest->bufsize - offset; dest->nextc = dest->buf + offset; INTON; } else { flushout(dest); } dest->nleft--; } void flushall() { flushout(&output); flushout(&errout); } void flushout(dest) struct output *dest; { if (dest->buf == NULL || dest->nextc == dest->buf || dest->fd < 0) return; if (xwrite(dest->fd, dest->buf, dest->nextc - dest->buf) < 0) dest->flags |= OUTPUT_ERR; dest->nextc = dest->buf; dest->nleft = dest->bufsize; } void freestdout() { INTOFF; if (output.buf) { ckfree(output.buf); output.buf = NULL; output.nleft = 0; } INTON; } #ifdef __STDC__ void outfmt(struct output *file, char *fmt, ...) { va_list ap; va_start(ap, fmt); doformat(file, fmt, ap); va_end(ap); } void out1fmt(char *fmt, ...) { va_list ap; va_start(ap, fmt); doformat(out1, fmt, ap); va_end(ap); } void fmtstr(char *outbuf, int length, char *fmt, ...) { va_list ap; struct output strout; va_start(ap, fmt); strout.nextc = outbuf; strout.nleft = length; strout.fd = BLOCK_OUT; strout.flags = 0; doformat(&strout, fmt, ap); outc('\0', &strout); if (strout.flags & OUTPUT_ERR) outbuf[length - 1] = '\0'; } #else /* not __STDC__ */ void outfmt(va_alist) va_dcl { va_list ap; struct output *file; char *fmt; va_start(ap); file = va_arg(ap, struct output *); fmt = va_arg(ap, char *); doformat(file, fmt, ap); va_end(ap); } void out1fmt(va_alist) va_dcl { va_list ap; char *fmt; va_start(ap); fmt = va_arg(ap, char *); doformat(out1, fmt, ap); va_end(ap); } void fmtstr(va_alist) va_dcl { va_list ap; struct output strout; char *outbuf; int length; char *fmt; va_start(ap); outbuf = va_arg(ap, char *); length = va_arg(ap, int); fmt = va_arg(ap, char *); strout.nextc = outbuf; strout.nleft = length; strout.fd = BLOCK_OUT; strout.flags = 0; doformat(&strout, fmt, ap); outc('\0', &strout); if (strout.flags & OUTPUT_ERR) outbuf[length - 1] = '\0'; } #endif /* __STDC__ */ /* * Formatted output. This routine handles a subset of the printf formats: * - Formats supported: d, u, o, X, s, and c. * - The x format is also accepted but is treated like X. * - The l modifier is accepted. * - The - and # flags are accepted; # only works with the o format. * - Width and precision may be specified with any format except c. * - An * may be given for the width or precision. * - The obsolete practice of preceding the width with a zero to get * zero padding is not supported; use the precision field. * - A % may be printed by writing %% in the format string. */ #define TEMPSIZE 24 #ifdef __STDC__ static const char digit[16] = "0123456789ABCDEF"; #else static const char digit[17] = "0123456789ABCDEF"; #endif void doformat(dest, f, ap) register struct output *dest; register char *f; /* format string */ va_list ap; { register char c; char temp[TEMPSIZE]; int flushleft; int sharp; int width; int prec; int islong; char *p; int sign; long l; unsigned long num; unsigned base; int len; int size; int pad; while ((c = *f++) != '\0') { if (c != '%') { outc(c, dest); continue; } flushleft = 0; sharp = 0; width = 0; prec = -1; islong = 0; for (;;) { if (*f == '-') flushleft++; else if (*f == '#') sharp++; else break; f++; } if (*f == '*') { width = va_arg(ap, int); f++; } else { while (is_digit(*f)) { width = 10 * width + digit_val(*f++); } } if (*f == '.') { if (*++f == '*') { prec = va_arg(ap, int); f++; } else { prec = 0; while (is_digit(*f)) { prec = 10 * prec + digit_val(*f++); } } } if (*f == 'l') { islong++; f++; } switch (*f) { case 'd': if (islong) l = va_arg(ap, long); else l = va_arg(ap, int); sign = 0; num = l; if (l < 0) { num = -l; sign = 1; } base = 10; goto number; case 'u': base = 10; goto uns_number; case 'o': base = 8; goto uns_number; case 'x': /* we don't implement 'x'; treat like 'X' */ case 'X': base = 16; uns_number: /* an unsigned number */ sign = 0; if (islong) num = va_arg(ap, unsigned long); else num = va_arg(ap, unsigned int); number: /* process a number */ p = temp + TEMPSIZE - 1; *p = '\0'; while (num) { *--p = digit[num % base]; num /= base; } len = (temp + TEMPSIZE - 1) - p; if (prec < 0) prec = 1; if (sharp && *f == 'o' && prec <= len) prec = len + 1; pad = 0; if (width) { size = len; if (size < prec) size = prec; size += sign; pad = width - size; if (flushleft == 0) { while (--pad >= 0) outc(' ', dest); } } if (sign) outc('-', dest); prec -= len; while (--prec >= 0) outc('0', dest); while (*p) outc(*p++, dest); while (--pad >= 0) outc(' ', dest); break; case 's': p = va_arg(ap, char *); pad = 0; if (width) { len = strlen(p); if (prec >= 0 && len > prec) len = prec; pad = width - len; if (flushleft == 0) { while (--pad >= 0) outc(' ', dest); } } prec++; while (--prec != 0 && *p) outc(*p++, dest); while (--pad >= 0) outc(' ', dest); break; case 'c': c = va_arg(ap, int); outc(c, dest); break; default: outc(*f, dest); break; } f++; } } /* * Version of write which resumes after a signal is caught. */ int xwrite(fd, buf, nbytes) int fd; char *buf; int nbytes; { int ntry; int i; int n; n = nbytes; ntry = 0; for (;;) { i = write(fd, buf, n); if (i > 0) { if ((n -= i) <= 0) return nbytes; buf += i; ntry = 0; } else if (i == 0) { if (++ntry > 10) return nbytes - n; } else if (errno != EINTR) { return -1; } } } /* * Version of ioctl that retries after a signal is caught. */ int xioctl(fd, request, arg) { int i; while ((i = ioctl(fd, request, arg)) == -1 && errno == EINTR); return i; } EOF if test `wc -c < output.c` -ne 9365 then echo 'output.c is the wrong size' fi echo extracting parser.h cat > parser.h <<\EOF /* * Copyright (C) 1989 by Kenneth Almquist. All rights reserved. * This file is part of ash, which is distributed under the terms specified * by the Ash General Public License. See the file named LICENSE. */ /* control characters in argument strings */ #define CTLESC '\201' #define CTLVAR '\202' #define CTLENDVAR '\203' #define CTLBACKQ '\204' #define CTLQUOTE 01 /* ored with CTLBACKQ code if in quotes */ /* variable substitution byte (follows CTLVAR) */ #define VSTYPE 07 /* type of variable substitution */ #define VSNUL 040 /* colon--treat the empty string as unset */ #define VSQUOTE 0100 /* inside double quotes--suppress splitting */ /* values of VSTYPE field */ #define VSNORMAL 1 /* normal variable: $var or ${var} */ #define VSMINUS 2 /* ${var-text} */ #define VSPLUS 3 /* ${var+text} */ #define VSQUESTION 4 /* ${var?message} */ #define VSASSIGN 5 /* ${var=text} */ /* * NEOF is returned by parsecmd when it encounters an end of file. It * must be distinct from NULL, so we use the address of a variable that * happens to be handy. */ extern int tokpushback; #define NEOF ((union node *)&tokpushback) #ifdef __STDC__ union node *parsecmd(int); int goodname(char *); #else union node *parsecmd(); int goodname(); #endif EOF if test `wc -c < parser.h` -ne 1262 then echo 'parser.h is the wrong size' fi echo extracting parser.c cat > parser.c <<\EOF /* * Copyright (C) 1989 by Kenneth Almquist. All rights reserved. * This file is part of ash, which is distributed under the terms specified * by the Ash General Public License. See the file named LICENSE. */ #include "shell.h" #include "parser.h" #include "nodes.h" #include "expand.h" /* defines rmescapes() */ #include "redir.h" /* defines copyfd() */ #include "syntax.h" #include "options.h" #include "input.h" #include "output.h" #include "var.h" #include "error.h" #include "memalloc.h" #include "mystring.h" /* * Shell command parser. */ #define EOFMARKLEN 79 /* values returned by readtoken */ #include "token.def" struct heredoc { struct heredoc *next; /* next here document in list */ union node *here; /* redirection node */ char *eofmark; /* string indicating end of input */ int striptabs; /* if set, strip leading tabs */ }; struct heredoc *heredoclist; /* list of here documents to read */ int parsebackquote; /* nonzero if we are inside backquotes */ int doprompt; /* if set, prompt the user */ int needprompt; /* true if interactive and at start of line */ int lasttoken; /* last token read */ MKINIT int tokpushback; /* last token pushed back */ char *wordtext; /* text of last word returned by readtoken */ struct nodelist *backquotelist; union node *redirnode; struct heredoc *heredoc; int quoteflag; /* set if (part of) last token was quoted */ int startlinno; /* line # where last token started */ #define GDB_HACK 1 /* avoid local declarations which gdb can't handle */ #ifdef GDB_HACK static const char argvars[5] = {CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0'}; static const char types[] = "}-+?="; #endif #ifdef __STDC__ STATIC union node *list(int); STATIC union node *andor(void); STATIC union node *pipeline(void); STATIC union node *command(void); STATIC union node *simplecmd(void); STATIC void parsefname(void); STATIC void parseheredoc(void); STATIC void checkkwd(void); STATIC int readtoken(void); STATIC int readtoken1(int, char const *, char *, int); STATIC void attyline(void); STATIC int noexpand(char *); STATIC void synexpect(int); STATIC void synerror(char *); #else STATIC union node *list(); STATIC union node *andor(); STATIC union node *pipeline(); STATIC union node *command(); STATIC union node *simplecmd(); STATIC void parsefname(); STATIC void parseheredoc(); STATIC void checkkwd(); STATIC int readtoken(); STATIC int readtoken1(); STATIC void attyline(); STATIC int noexpand(); STATIC void synexpect(); STATIC void synerror(); #endif #if ATTY #ifdef __STDC__ STATIC void putprompt(char *); #else STATIC void putprompt(); #endif #else /* not ATTY */ #define putprompt(s) out2str(s) #endif /* * Read and parse a command. Returns NEOF on end of file. (NULL is a * valid parse tree indicating a blank line.) */ union node * parsecmd(interact) { int t; doprompt = interact; if (doprompt) putprompt(ps1val()); needprompt = 0; if ((t = readtoken()) == TEOF) return NEOF; if (t == TNL) return NULL; tokpushback++; return list(1); } STATIC union node * list(nlflag) { union node *n1, *n2, *n3; checkkwd(); if (nlflag == 0 && tokendlist[lasttoken]) return NULL; n1 = andor(); for (;;) { switch (readtoken()) { case TBACKGND: if (n1->type == NCMD || n1->type == NPIPE) { n1->ncmd.backgnd = 1; } else if (n1->type == NREDIR) { n1->type = NBACKGND; } else { n3 = (union node *)stalloc(sizeof (struct nredir)); n3->type = NBACKGND; n3->nredir.n = n1; n3->nredir.redirect = NULL; n1 = n3; } goto tsemi; case TNL: tokpushback++; /* fall through */ tsemi: case TSEMI: if (readtoken() == TNL) { parseheredoc(); if (nlflag) return n1; } else { tokpushback++; } checkkwd(); if (tokendlist[lasttoken]) return n1; n2 = andor(); n3 = (union node *)stalloc(sizeof (struct nbinary)); n3->type = NSEMI; n3->nbinary.ch1 = n1; n3->nbinary.ch2 = n2; n1 = n3; break; case TEOF: if (heredoclist) parseheredoc(); else pungetc(); /* push back EOF on input */ return n1; default: if (nlflag) synexpect(-1); tokpushback++; return n1; } } } STATIC union node * andor() { union node *n1, *n2, *n3; int t; n1 = pipeline(); for (;;) { if ((t = readtoken()) == TAND) { t = NAND; } else if (t == TOR) { t = NOR; } else { tokpushback++; return n1; } n2 = pipeline(); n3 = (union node *)stalloc(sizeof (struct nbinary)); n3->type = t; n3->nbinary.ch1 = n1; n3->nbinary.ch2 = n2; n1 = n3; } } STATIC union node * pipeline() { union node *n1, *pipenode; struct nodelist *lp, *prev; n1 = command(); if (readtoken() == TPIPE) { pipenode = (union node *)stalloc(sizeof (struct npipe)); pipenode->type = NPIPE; pipenode->npipe.backgnd = 0; lp = (struct nodelist *)stalloc(sizeof (struct nodelist)); pipenode->npipe.cmdlist = lp; lp->n = n1; do { prev = lp; lp = (struct nodelist *)stalloc(sizeof (struct nodelist)); lp->n = command(); prev->next = lp; } while (readtoken() == TPIPE); lp->next = NULL; n1 = pipenode; } tokpushback++; return n1; } STATIC union node * command() { union node *n1, *n2; union node *ap, **app; union node *cp, **cpp; union node *redir, **rpp; int t; checkkwd(); switch (readtoken()) { case TIF: n1 = (union node *)stalloc(sizeof (struct nif)); n1->type = NIF; n1->nif.test = list(0); if (readtoken() != TTHEN) synexpect(TTHEN); n1->nif.ifpart = list(0); n2 = n1; while (readtoken() == TELIF) { n2->nif.elsepart = (union node *)stalloc(sizeof (struct nif)); n2 = n2->nif.elsepart; n2->type = NIF; n2->nif.test = list(0); if (readtoken() != TTHEN) synexpect(TTHEN); n2->nif.ifpart = list(0); } if (lasttoken == TELSE) n2->nif.elsepart = list(0); else { n2->nif.elsepart = NULL; tokpushback++; } if (readtoken() != TFI) synexpect(TFI); break; case TWHILE: case TUNTIL: n1 = (union node *)stalloc(sizeof (struct nbinary)); n1->type = (lasttoken == TWHILE)? NWHILE : NUNTIL; n1->nbinary.ch1 = list(0); if (readtoken() != TDO) synexpect(TDO); n1->nbinary.ch2 = list(0); if (readtoken() != TDONE) synexpect(TDONE); break; case TFOR: if (readtoken() != TWORD || quoteflag || ! goodname(wordtext)) synerror("Bad for loop variable"); n1 = (union node *)stalloc(sizeof (struct nfor)); n1->type = NFOR; n1->nfor.var = wordtext; if (readtoken() == TWORD && ! quoteflag && equal(wordtext, "in")) { app = ≈ while (readtoken() == TWORD) { n2 = (union node *)stalloc(sizeof (struct narg)); n2->type = NARG; n2->narg.text = wordtext; n2->narg.backquote = backquotelist; *app = n2; app = &n2->narg.next; } *app = NULL; n1->nfor.args = ap; } else { #ifndef GDB_HACK static const char argvars[5] = {CTLVAR, VSNORMAL|VSQUOTE, '@', '=', '\0'}; #endif n2 = (union node *)stalloc(sizeof (struct narg)); n2->type = NARG; n2->narg.text = (char *)argvars; n2->narg.backquote = NULL; n2->narg.next = NULL; n1->nfor.args = n2; } if (lasttoken != TNL && lasttoken != TSEMI) synexpect(-1); checkkwd(); if ((t = readtoken()) == TDO) t = TDONE; else if (t == TBEGIN) t = TEND; else synexpect(-1); n1->nfor.body = list(0); if (readtoken() != t) synexpect(t); break; case TCASE: n1 = (union node *)stalloc(sizeof (struct ncase)); n1->type = NCASE; if (readtoken() != TWORD) synexpect(TWORD); n1->ncase.expr = n2 = (union node *)stalloc(sizeof (struct narg)); n2->type = NARG; n2->narg.text = wordtext; n2->narg.backquote = backquotelist; n2->narg.next = NULL; while (readtoken() == TNL); if (lasttoken != TWORD || ! equal(wordtext, "in")) synerror("expecting \"in\""); cpp = &n1->ncase.cases; while (checkkwd(), readtoken() == TWORD) { *cpp = cp = (union node *)stalloc(sizeof (struct nclist)); cp->type = NCLIST; app = &cp->nclist.pattern; for (;;) { *app = ap = (union node *)stalloc(sizeof (struct narg)); ap->type = NARG; ap->narg.text = wordtext; ap->narg.backquote = backquotelist; if (readtoken() != TPIPE) break; app = &ap->narg.next; if (readtoken() != TWORD) synexpect(TWORD); } ap->narg.next = NULL; if (lasttoken != TRP) synexpect(TRP); cp->nclist.body = list(0); if ((t = readtoken()) == TESAC) tokpushback++; else if (t != TENDCASE) synexpect(TENDCASE); cpp = &cp->nclist.next; } *cpp = NULL; if (lasttoken != TESAC) synexpect(TESAC); break; case TLP: n1 = (union node *)stalloc(sizeof (struct nredir)); n1->type = NSUBSHELL; n1->nredir.n = list(0); n1->nredir.redirect = NULL; if (readtoken() != TRP) synexpect(TRP); break; case TBEGIN: n1 = list(0); if (readtoken() != TEND) synexpect(TEND); break; case TWORD: case TREDIR: tokpushback++; return simplecmd(); default: synexpect(-1); } /* Now check for redirection which may follow command */ rpp = &redir; while (readtoken() == TREDIR) { *rpp = n2 = redirnode; rpp = &n2->nfile.next; parsefname(); } tokpushback++; *rpp = NULL; if (redir) { if (n1->type != NSUBSHELL) { n2 = (union node *)stalloc(sizeof (struct nredir)); n2->type = NREDIR; n2->nredir.n = n1; n1 = n2; } n1->nredir.redirect = redir; } return n1; } STATIC union node * simplecmd() { union node *args, **app; union node *redir, **rpp; union node *n; args = NULL; app = &args; rpp = &redir; for (;;) { if (readtoken() == TWORD) { n = (union node *)stalloc(sizeof (struct narg)); n->type = NARG; n->narg.text = wordtext; n->narg.backquote = backquotelist; *app = n; app = &n->narg.next; } else if (lasttoken == TREDIR) { *rpp = n = redirnode; rpp = &n->nfile.next; parsefname(); /* read name of redirection file */ } else if (lasttoken == TLP && app == &args->narg.next && rpp == &redir) { /* We have a function */ if (readtoken() != TRP) synexpect(TRP); if (! goodname(n->narg.text)) synerror("Bad function name"); n->type = NDEFUN; n->narg.next = command(); return n; } else { tokpushback++; break; } } *app = NULL; *rpp = NULL; n = (union node *)stalloc(sizeof (struct ncmd)); n->type = NCMD; n->ncmd.backgnd = 0; n->ncmd.args = args; n->ncmd.redirect = redir; return n; } STATIC void parsefname() { union node *n = redirnode; if (readtoken() != TWORD) synexpect(-1); if (n->type == NHERE) { struct heredoc *here = heredoc; struct heredoc *p; int i; if (quoteflag == 0) n->type = NXHERE; TRACE(("Here document %d\n", n->type)); if (here->striptabs) { while (*wordtext == '\t') wordtext++; } if (! noexpand(wordtext) || (i = strlen(wordtext)) == 0 || i > EOFMARKLEN) synerror("Illegal eof marker for << redirection"); rmescapes(wordtext); here->eofmark = wordtext; here->next = NULL; if (heredoclist == NULL) heredoclist = here; else { for (p = heredoclist ; p->next ; p = p->next); p->next = here; } } else if (n->type == NTOFD || n->type == NFROMFD) { if (is_digit(wordtext[0])) n->ndup.dupfd = digit_val(wordtext[0]); else if (wordtext[0] == '-') n->ndup.dupfd = -1; else goto bad; if (wordtext[1] != '\0') { bad: synerror("Bad fd number"); } } else { n->nfile.fname = (union node *)stalloc(sizeof (struct narg)); n = n->nfile.fname; n->type = NARG; n->narg.next = NULL; n->narg.text = wordtext; n->narg.backquote = backquotelist; } } /* * Input any here documents. */ STATIC void parseheredoc() { struct heredoc *here; union node *n; while (heredoclist) { here = heredoclist; heredoclist = here->next; if (needprompt) { putprompt(ps2val()); needprompt = 0; } readtoken1(pgetc(), here->here->type == NHERE? SQSYNTAX : DQSYNTAX, here->eofmark, here->striptabs); n = (union node *)stalloc(sizeof (struct narg)); n->narg.type = NARG; n->narg.next = NULL; n->narg.text = wordtext; n->narg.backquote = backquotelist; here->here->nhere.doc = n; } } /* * This routine is called to tell readtoken that we are at the beginning * of a command, so newlines should be ignored and keywords should be * checked for. We munge things here rather than setting a flag for * readtoken. */ STATIC void checkkwd() { register char *const *pp; int t; while ((t = readtoken()) == TNL) parseheredoc(); if (t == TWORD && quoteflag == 0) { for (pp = parsekwd ; *pp ; pp++) { if (**pp == *wordtext && equal(*pp, wordtext)) { lasttoken = pp - parsekwd + KWDOFFSET; break; } } } tokpushback++; } STATIC int xxreadtoken(); STATIC int readtoken() { int t; if (tokpushback) { return xxreadtoken(); } else { t = xxreadtoken(); /* TRACE(("token %s\n", tokname[t])); */ return t; } } /* * Read the next input token. * If the token is a word, we set backquotelist to the list of cmds in * backquotes. We set quoteflag to true if any part of the word was * quoted. * If the token is TREDIR, then we set redirnode to a structure containing * the redirection. * In all cases, the variable startlinno is set to the number of the line * on which the token starts. * * [Change comment: here documents and internal procedures] * [Readtoken shouldn't have any arguments. Perhaps we should make the * word parsing code into a separate routine. In this case, readtoken * doesn't need to have any internal procedures, but parseword does. * We could also make parseoperator in essence the main routine, and * have parseword (readtoken1?) handle both words and redirection.] */ #define RETURN(token) return lasttoken = token STATIC int xxreadtoken() { register c; if (tokpushback) { tokpushback = 0; return lasttoken; } if (needprompt) { putprompt(ps2val()); needprompt = 0; } startlinno = plinno; for (;;) { /* until token or start of word found */ c = pgetc_macro(); if (c == ' ' || c == '\t') continue; /* quick check for white space first */ switch (c) { case ' ': case '\t': continue; case '#': while ((c = pgetc()) != '\n' && c != PEOF); pungetc(); continue; case '\\': if (pgetc() == '\n') { startlinno = ++plinno; if (doprompt) putprompt(ps2val()); continue; } pungetc(); goto breakloop; case '\n': plinno++; needprompt = doprompt; RETURN(TNL); case PEOF: RETURN(TEOF); case '&': if (pgetc() == '&') RETURN(TAND); pungetc(); RETURN(TBACKGND); case '|': if (pgetc() == '|') RETURN(TOR); pungetc(); RETURN(TPIPE); case ';': if (pgetc() == ';') RETURN(TENDCASE); pungetc(); RETURN(TSEMI); case '(': RETURN(TLP); case ')': RETURN(TRP); default: goto breakloop; } } breakloop: return readtoken1(c, BASESYNTAX, (char *)NULL, 0); #undef RETURN } /* * If eofmark is NULL, read a word or a redirection symbol. If eofmark * is not NULL, read a here document. In the latter case, eofmark is the * word which marks the end of the document and striptabs is true if * leading tabs should be stripped from the document. The argument firstc * is the first character of the input token or document. * * Because C does not have internal subroutines, I have simulated them * using goto's to implement the subroutine linkage. The following macros * will run code that appears at the end of readtoken1. */ #define CHECKEND() {goto checkend; checkend_return:;} #define PARSEREDIR() {goto parseredir; parseredir_return:;} #define PARSESUB() {goto parsesub; parsesub_return:;} #define PARSEBACKQOLD() {oldstyle = 1; goto parsebackq; parsebackq_oldreturn:;} #define PARSEBACKQNEW() {oldstyle = 0; goto parsebackq; parsebackq_newreturn:;} STATIC int readtoken1(firstc, syntax, eofmark, striptabs) int firstc; char const *syntax; char *eofmark; int striptabs; { register c = firstc; register char *out; int len; char line[EOFMARKLEN + 1]; struct nodelist *bqlist; int quotef; int dblquote; int varnest; int oldstyle; startlinno = plinno; dblquote = 0; if (syntax == DQSYNTAX) dblquote = 1; quotef = 0; bqlist = NULL; varnest = 0; STARTSTACKSTR(out); loop: { /* for each line, until end of word */ #if ATTY if (c == '\034' && doprompt && attyset() && ! equal(termval(), "emacs")) { attyline(); if (syntax == BASESYNTAX) return readtoken(); c = pgetc(); goto loop; } #endif CHECKEND(); /* set c to PEOF if at end of here document */ for (;;) { /* until end of line or end of word */ CHECKSTRSPACE(3, out); /* permit 3 calls to USTPUTC */ switch(syntax[c]) { case CNL: /* '\n' */ if (syntax == BASESYNTAX) goto endword; /* exit outer loop */ USTPUTC(c, out); plinno++; if (doprompt) { putprompt(ps2val()); } c = pgetc(); goto loop; /* continue outer loop */ case CWORD: USTPUTC(c, out); break; case CCTL: if (eofmark == NULL || dblquote) USTPUTC(CTLESC, out); USTPUTC(c, out); break; case CBACK: /* backslash */ c = pgetc(); if (c == PEOF) { USTPUTC('\\', out); pungetc(); } else if (c == '\n') { if (doprompt) putprompt(ps2val()); } else { if (dblquote && c != '\\' && c != '`' && c != '$' && (c != '"' || eofmark != NULL)) USTPUTC('\\', out); if (SQSYNTAX[c] == CCTL) USTPUTC(CTLESC, out); USTPUTC(c, out); quotef++; } break; case CSQUOTE: syntax = SQSYNTAX; break; case CDQUOTE: syntax = DQSYNTAX; dblquote = 1; break; case CENDQUOTE: if (eofmark) { USTPUTC(c, out); } else { syntax = BASESYNTAX; quotef++; dblquote = 0; } break; case CVAR: /* '$' */ PARSESUB(); /* parse substitution */ break; case CENDVAR: /* '}' */ if (varnest > 0) { varnest--; USTPUTC(CTLENDVAR, out); } else { USTPUTC(c, out); } break; case CBQUOTE: /* '`' */ if (parsebackquote && syntax == BASESYNTAX) { if (out == stackblock()) return lasttoken = TENDBQUOTE; else goto endword; /* exit outer loop */ } PARSEBACKQOLD(); break; case CEOF: goto endword; /* exit outer loop */ default: if (varnest == 0) goto endword; /* exit outer loop */ USTPUTC(c, out); } c = pgetc_macro(); } } endword: if (syntax != BASESYNTAX && eofmark == NULL) synerror("Unterminated quoted string"); if (varnest != 0) { startlinno = plinno; synerror("Missing '}'"); } USTPUTC('\0', out); len = out - stackblock(); out = stackblock(); if (eofmark == NULL) { if ((c == '>' || c == '<') && quotef == 0 && len <= 2 && (*out == '\0' || is_digit(*out))) { PARSEREDIR(); return lasttoken = TREDIR; } else { pungetc(); } } quoteflag = quotef; backquotelist = bqlist; grabstackblock(len); wordtext = out; return lasttoken = TWORD; /* end of readtoken routine */ /* * Check to see whether we are at the end of the here document. When this * is called, c is set to the first character of the next input line. If * we are at the end of the here document, this routine sets the c to PEOF. */ checkend: { if (eofmark) { if (striptabs) { while (c == '\t') c = pgetc(); } if (c == *eofmark) { if (pfgets(line, sizeof line) != NULL) { register char *p, *q; p = line; for (q = eofmark + 1 ; *q && *p == *q ; p++, q++); if (*p == '\n' && *q == '\0') { c = PEOF; plinno++; needprompt = doprompt; } else { ppushback(line, strlen(line)); } } } } goto checkend_return; } /* * Parse a redirection operator. The variable "out" points to a string * specifying the fd to be redirected. The variable "c" contains the * first character of the redirection operator. */ parseredir: { char fd = *out; union node *np; np = (union node *)stalloc(sizeof (struct nfile)); if (c == '>') { np->nfile.fd = 1; c = pgetc(); if (c == '>') np->type = NAPPEND; else if (c == '&') np->type = NTOFD; else { np->type = NTO; pungetc(); } } else { /* c == '<' */ np->nfile.fd = 0; c = pgetc(); if (c == '<') { if (sizeof (struct nfile) != sizeof (struct nhere)) { np = (union node *)stalloc(sizeof (struct nhere)); np->nfile.fd = 0; } np->type = NHERE; heredoc = (struct heredoc *)stalloc(sizeof (struct heredoc)); heredoc->here = np; if ((c = pgetc()) == '-') { heredoc->striptabs = 1; } else { heredoc->striptabs = 0; pungetc(); } } else if (c == '&') np->type = NFROMFD; else { np->type = NFROM; pungetc(); } } if (fd != '\0') np->nfile.fd = digit_val(fd); redirnode = np; goto parseredir_return; } /* * Parse a substitution. At this point, we have read the dollar sign * and nothing else. */ parsesub: { int subtype; int typeloc; int flags; char *p; #ifndef GDB_HACK static const char types[] = "}-+?="; #endif c = pgetc(); if (c == ' ' || c == '\t' || c == '\n' || c == '"' || c == PEOF) { USTPUTC('$', out); pungetc(); } else if (c == '(') { /* $(command) */ PARSEBACKQNEW(); } else { USTPUTC(CTLVAR, out); typeloc = out - stackblock(); USTPUTC(VSNORMAL, out); subtype = VSNORMAL; if (c == '{') { c = pgetc(); subtype = 0; } if (is_name(c)) { do { STPUTC(c, out); c = pgetc(); } while (is_in_name(c)); } else { if (! is_special(c)) badsub: synerror("Bad substitution"); USTPUTC(c, out); c = pgetc(); } STPUTC('=', out); flags = 0; if (subtype == 0) { if (c == ':') { flags = VSNUL; c = pgetc(); } p = strchr(types, c); if (p == NULL) goto badsub; subtype = p - types + VSNORMAL; } else { pungetc(); } if (dblquote) flags |= VSQUOTE; *(stackblock() + typeloc) = subtype | flags; if (subtype != VSNORMAL) varnest++; } goto parsesub_return; } /* * Called to parse command substitutions. Newstyle is set if the command * is enclosed inside $(...); nlpp is a pointer to the head of the linked * list of commands (passed by reference), and savelen is the number of * characters on the top of the stack which must be preserved. */ parsebackq: { struct nodelist **nlpp; int savepbq; union node *n; char *volatile str; struct jmploc jmploc; struct jmploc *volatile savehandler; int savelen; int t; savepbq = parsebackquote; if (setjmp(jmploc.loc)) { if (str) ckfree(str); parsebackquote = 0; handler = savehandler; longjmp(handler, 1); } INTOFF; str = NULL; savelen = out - stackblock(); if (savelen > 0) { str = ckmalloc(savelen); bcopy(stackblock(), str, savelen); } savehandler = handler; handler = &jmploc; INTON; nlpp = &bqlist; while (*nlpp) nlpp = &(*nlpp)->next; *nlpp = (struct nodelist *)stalloc(sizeof (struct nodelist)); (*nlpp)->next = NULL; parsebackquote = oldstyle; n = list(0); t = oldstyle? TENDBQUOTE : TRP; if (readtoken() != t) synexpect(t); (*nlpp)->n = n; while (stackblocksize() <= savelen) growstackblock(); STARTSTACKSTR(out); if (str) { bcopy(str, out, savelen); STADJUST(savelen, out); INTOFF; ckfree(str); str = NULL; INTON; } parsebackquote = savepbq; handler = savehandler; USTPUTC(CTLBACKQ + dblquote, out); if (oldstyle) goto parsebackq_oldreturn; else goto parsebackq_newreturn; } } /* end of readtoken */ #ifdef mkinit RESET { tokpushback = 0; } #endif #if ATTY /* * Called to process a command generated by atty. We execute the line, * and catch any errors that occur so they don't propagate outside of * this routine. */ STATIC void attyline() { char line[256]; struct stackmark smark; struct jmploc jmploc; struct jmploc *volatile savehandler; if (pfgets(line, sizeof line) == NULL) return; /* "can't happen" */ if (setjmp(jmploc.loc)) { if (exception == EXERROR) out2str("\033]D\n"); handler = savehandler; longjmp(handler, 1); } savehandler = handler; handler = &jmploc; setstackmark(&smark); evalstring(line); popstackmark(&smark); handler = savehandler; doprompt = 1; } /* * Output a prompt for atty. We output the prompt as part of the * appropriate escape sequence. */ STATIC void putprompt(s) char *s; { register char *p; if (attyset() && ! equal(termval(), "emacs")) { if (strchr(s, '\7')) out2c('\7'); out2str("\033]P1;"); for (p = s ; *p ; p++) { if ((unsigned)(*p - ' ') <= '~' - ' ') out2c(*p); } out2c('\n'); } else { out2str(s); } } #endif /* * Returns true if the text contains nothing to expand (no dollar signs * or backquotes). */ STATIC int noexpand(text) char *text; { register char *p; register char c; p = text; while ((c = *p++) != '\0') { if (c == CTLESC) p++; else if (BASESYNTAX[c] == CCTL) return 0; } return 1; } /* * Return true if the argument is a legal variable name (a letter or * underscore followed by zero or more letters, underscores, and digits). */ int goodname(name) char *name; { register char *p; p = name; if (! is_name(*p)) return 0; while (*++p) { if (! is_in_name(*p)) return 0; } return 1; } /* * Called when an unexpected token is read during the parse. The argument * is the token that is expected, or -1 if more than one type of token can * occur at this point. */ STATIC void synexpect(token) { char msg[64]; if (token >= 0) { fmtstr(msg, 64, "%s unexpected (expecting %s)", tokname[lasttoken], tokname[token]); } else { fmtstr(msg, 64, "%s unexpected", tokname[lasttoken]); } synerror(msg); } STATIC void synerror(msg) char *msg; { if (commandname) outfmt(&errout, "%s: %d: ", commandname, startlinno); outfmt(&errout, "Syntax error: %s\n", msg); error((char *)NULL); } EOF if test `wc -c < parser.c` -ne 28043 then echo 'parser.c is the wrong size' fi echo Archive 6 unpacked exit -- Please send comp.sources.unix-related mail to rsalz@uunet.uu.net. Use a domain-based address or give alternate paths, or you may lose out.