trc: add recursive descent parser - plan9port - [fork] Plan 9 from user space
(HTM) git clone git://src.adamsgaard.dk/plan9port
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
(DIR) commit 47d4646eebac34c0b94951cfcf1b81ed2ca513e1
(DIR) parent c1c1b5267fd5e14be531a4b22ed0124b35d427cb
(HTM) Author: Russ Cox <rsc@swtch.com>
Date: Mon, 4 May 2020 18:34:19 -0400
rc: add recursive descent parser
The old yacc-based parser is available with the -Y flag,
which will probably be removed at some point.
The new -D flag dumps a parse tree of the input,
without executing it. This allows comparing the output
of rc -D and rc -DY on different scripts to see that the
ttwo parsers behave the same.
The rc paper ends by saying:
It is remarkable that in the four most recent editions of the UNIX
system programmer’s manual the Bourne shell grammar described in the
manual page does not admit the command who|wc. This is surely an
oversight, but it suggests something darker: nobody really knows what
the Bourne shell’s grammar is. Even examination of the source code is
little help. The parser is implemented by recursive descent, but the
routines corresponding to the syntactic categories all have a flag
argument that subtly changes their operation depending on the context.
Rc’s parser is implemented using yacc, so I can say precisely what the
grammar is.
The new recursive descent parser here has no such flags.
It is a straightforward translation of the yacc.
The new parser will make it easier to handle free carats
in more generality as well as potentially allow the use of
unquoted = as a word character.
Going through this exercise has highlighted a few
dark corners here as well. For example, I was surprised to
find that
x >f | y
>f x | y
are different commands (the latter redirects y's output).
It is similarly surprising that
a=b x | y
sets a during the execution of y.
It is also a bit counter-intuitive
x | y | z
x | if(c) y | z
are not both 3-phase pipelines.
These are certainly not things we should change, but they
are not entirely obvious from the man page description,
undercutting the quoted claim a bit.
On the other hand, who | wc is clearly accepted by the grammar
in the manual page, and the new parser still handles that test case.
Diffstat:
A src/cmd/rc/checkparse | 14 ++++++++++++++
M src/cmd/rc/code.c | 10 ++++++++++
M src/cmd/rc/exec.c | 4 ++--
M src/cmd/rc/fns.h | 1 +
M src/cmd/rc/io.c | 5 ++++-
M src/cmd/rc/io.h | 1 +
M src/cmd/rc/lex.c | 7 ++++++-
M src/cmd/rc/mkfile | 1 +
A src/cmd/rc/parse.c | 532 +++++++++++++++++++++++++++++++
M src/cmd/rc/pcmd.c | 115 +++++++++++++++++++++++++++++++
M src/cmd/rc/simple.c | 1 +
M src/cmd/rc/syn.y | 10 +++++-----
A src/cmd/rc/test.rc | 38 +++++++++++++++++++++++++++++++
13 files changed, 730 insertions(+), 9 deletions(-)
---
(DIR) diff --git a/src/cmd/rc/checkparse b/src/cmd/rc/checkparse
t@@ -0,0 +1,14 @@
+#!/bin/bash
+
+files="$@"
+if [ $# = 0 ]; then
+ files=$(echo ./test.rc;
+ grep -l '^#!/usr/local/plan9/bin/rc' /usr/local/plan9/bin/{*,*/*} 2>/dev/null;
+ grep -l '^#!/bin/rc' $HOME/pub/plan9/rc/bin/{*,*/*} 2>/dev/null)
+fi
+
+for i in $files
+do
+ echo '#' $i
+ diff <(./o.rc -DY $i 2>&1) <(./o.rc -D $i 2>&1)
+done
(DIR) diff --git a/src/cmd/rc/code.c b/src/cmd/rc/code.c
t@@ -41,6 +41,16 @@ stuffdot(int a)
int
compile(tree *t)
{
+ if(flag['D']) {
+ struct io *s;
+ s = openstr();
+ pfmt(s, "compile: %u\n", t);
+ write(2, s->strp, strlen(s->strp));
+ closeio(s);
+ if(eflagok) // made it out of rcmain - stop executing commands, just print them
+ t = nil;
+ }
+
ncode = 100;
codebuf = (code *)emalloc(ncode*sizeof codebuf[0]);
codep = 0;
(DIR) diff --git a/src/cmd/rc/exec.c b/src/cmd/rc/exec.c
t@@ -139,7 +139,7 @@ main(int argc, char *argv[])
/* needed for rcmain later */
putenv("PLAN9", unsharp("#9"));
- argc = getflags(argc, argv, "SsrdiIlxepvVc:1m:1[command]", 1);
+ argc = getflags(argc, argv, "DSYsrdiIlxepvVc:1m:1[command]", 1);
if(argc==-1)
usage("[file [arg ...]]");
if(argv[0][0]=='-')
t@@ -901,7 +901,7 @@ Xrdcmds(void)
promptstr="% ";
}
Noerror();
- if(yyparse()){
+ if((flag['Y'] ? yyparse : parse)()){
if(!p->iflag || p->eof && !Eintr()){
if(p->cmdfile)
efree(p->cmdfile);
(DIR) diff --git a/src/cmd/rc/fns.h b/src/cmd/rc/fns.h
t@@ -65,3 +65,4 @@ int wordchr(int);
void yyerror(char*);
int yylex(void);
int yyparse(void);
+int parse(void);
(DIR) diff --git a/src/cmd/rc/io.c b/src/cmd/rc/io.c
t@@ -44,7 +44,10 @@ pfmt(io *f, char *fmt, ...)
pstr(f, va_arg(ap, char *));
break;
case 't':
- pcmd(f, va_arg(ap, struct tree *));
+ pcmd(f, va_arg(ap, tree *));
+ break;
+ case 'u':
+ pcmdu(f, va_arg(ap, tree *));
break;
case 'v':
pval(f, va_arg(ap, struct word *));
(DIR) diff --git a/src/cmd/rc/io.h b/src/cmd/rc/io.h
t@@ -25,6 +25,7 @@ void pquo(io*, char*);
void pwrd(io*, char*);
void pstr(io*, char*);
void pcmd(io*, tree*);
+void pcmdu(io*, tree*);
void pval(io*, word*);
void pfnc(io*, thread*);
void pfmt(io*, char*, ...);
(DIR) diff --git a/src/cmd/rc/lex.c b/src/cmd/rc/lex.c
t@@ -188,7 +188,7 @@ yylex(void)
{
int c, d = nextc();
char *w = tok;
- struct tree *t;
+ tree *t;
yylval.tree = 0;
/*
* Embarassing sneakiness: if the last token read was a quoted or unquoted
t@@ -331,6 +331,11 @@ yylex(void)
yylval.tree = t;
if(t->type==PIPE)
skipnl();
+ if(t->type==REDIR) {
+ skipwhite();
+ if(nextc() == '{')
+ t->type = REDIRW;
+ }
return t->type;
case '\'':
lastdol = 0;
(DIR) diff --git a/src/cmd/rc/mkfile b/src/cmd/rc/mkfile
t@@ -10,6 +10,7 @@ OFILES=\
here.$O\
io.$O\
lex.$O\
+ parse.$O\
pcmd.$O\
pfnc.$O\
simple.$O\
(DIR) diff --git a/src/cmd/rc/parse.c b/src/cmd/rc/parse.c
t@@ -0,0 +1,532 @@
+#include "rc.h"
+#include "io.h"
+#include "fns.h"
+
+static tree* body(int tok, int *ptok);
+static tree* brace(int tok);
+static tree* cmd(int tok, int *ptok);
+static tree* cmd2(int tok, int *ptok);
+static tree* cmd3(int tok, int *ptok);
+static tree* cmd4(int tok, int *ptok);
+static tree* cmds(int tok, int *ptok, int nlok);
+static tree* epilog(int tok, int *ptok);
+static int iswordtok(int tok);
+static tree* line(int tok, int *ptok);
+static tree* paren(int tok);
+static tree* yyredir(int tok, int *ptok);
+static tree* yyword(int tok, int *ptok);
+static tree* word1(int tok, int *ptok);
+static tree* words(int tok, int *ptok);
+
+static jmp_buf yyjmp;
+
+static void
+syntax(int tok)
+{
+ char buf[100];
+ snprint(buf, sizeof buf, "syntax error %d", tok);
+ yyerror(buf);
+ longjmp(yyjmp, 1);
+}
+
+int
+parse(void)
+{
+ tree *t;
+ int tok;
+
+ if(setjmp(yyjmp))
+ return 1;
+
+ // rc: { return 1;}
+ // | line '\n' {return !compile($1);}
+
+ tok = yylex();
+ if(tok == EOF)
+ return 1;
+ t = line(tok, &tok);
+ if(tok != '\n')
+ yyerror("missing newline at end of line");
+ yylval.tree = t;
+ return !compile(t);
+}
+
+static tree*
+line(int tok, int *ptok)
+{
+ return cmds(tok, ptok, 0);
+}
+
+static tree*
+body(int tok, int *ptok)
+{
+ return cmds(tok, ptok, 1);
+}
+
+static tree*
+cmds(int tok, int *ptok, int nlok)
+{
+ tree *t, **last, *t2;
+
+ // line: cmd
+ // | cmdsa line {$$=tree2(';', $1, $2);}
+ // cmdsa: cmd ';'
+ // | cmd '&' {$$=tree1('&', $1);}
+
+ // body: cmd
+ // | cmdsan body {$$=tree2(';', $1, $2);}
+ // cmdsan: cmdsa
+ // | cmd '\n'
+
+ t = nil;
+ last = nil;
+ for(;;) {
+ t2 = cmd(tok, &tok);
+ if(tok == '&')
+ t2 = tree1('&', t2);
+ if(t2 != nil) {
+ // slot into list t
+ if(last == nil) {
+ t = t2;
+ last = &t;
+ } else {
+ *last = tree2(';', *last, t2);
+ last = &(*last)->child[1];
+ }
+ }
+ if(tok != ';' && tok != '&' && (!nlok || tok != '\n'))
+ break;
+ tok = yylex();
+ }
+ *ptok = tok;
+ return t;
+}
+
+static tree*
+brace(int tok)
+{
+ tree *t;
+
+ // brace: '{' body '}' {$$=tree1(BRACE, $2);}
+
+ if(tok != '{')
+ syntax(tok);
+ t = body(yylex(), &tok);
+ if(tok != '}')
+ syntax(tok);
+ return tree1(BRACE, t);
+}
+
+static tree*
+paren(int tok)
+{
+ tree *t;
+
+ // paren: '(' body ')' {$$=tree1(PCMD, $2);}
+
+ if(tok != '(')
+ syntax(tok);
+ t = body(yylex(), &tok);
+ if(tok != ')')
+ syntax(tok);
+ return tree1(PCMD, t);
+}
+
+static tree*
+epilog(int tok, int *ptok)
+{
+ tree *t, *r;
+
+ // epilog: {$$=0;}
+ // | redir epilog {$$=mung2($1, $1->child[0], $2);}
+
+ if(tok != REDIR && tok != DUP) {
+ *ptok = tok;
+ return nil;
+ }
+
+ r = yyredir(tok, &tok);
+ t = epilog(tok, &tok);
+ *ptok = tok;
+ return mung2(r, r->child[0], t);
+}
+
+static tree*
+yyredir(int tok, int *ptok)
+{
+ tree *r, *w;
+
+ // redir: REDIR word {$$=mung1($1, $1->rtype==HERE?heredoc($2):$2);}
+ // | DUP
+
+ switch(tok) {
+ default:
+ syntax(tok);
+ case DUP:
+ r = yylval.tree;
+ *ptok = yylex();
+ break;
+ case REDIR:
+ r = yylval.tree;
+ w = yyword(yylex(), ptok);
+ r = mung1(r, r->rtype==HERE?heredoc(w):w);
+ break;
+ }
+ return r;
+}
+
+static tree*
+cmd(int tok, int *ptok)
+{
+ tree *t1, *t2, *t3, *t4;
+
+ switch(tok) {
+ default:
+ return cmd2(tok, ptok);
+
+ case IF:
+ // | IF paren {skipnl();} cmd {$$=mung2($1, $2, $4);}
+ // | IF NOT {skipnl();} cmd {$$=mung1($2, $4);}
+ t1 = yylval.tree;
+ tok = yylex();
+ if(tok == NOT) {
+ t1 = yylval.tree;
+ skipnl();
+ t2 = cmd(yylex(), ptok);
+ return mung1(t1, t2);
+ }
+ t2 = paren(tok);
+ skipnl();
+ t3 = cmd(yylex(), ptok);
+ return mung2(t1, t2, t3);
+
+ case FOR:
+ // | FOR '(' word IN words ')' {skipnl();} cmd
+ // {$$=mung3($1, $3, $5 ? $5 : tree1(PAREN, $5), $8);}
+ // | FOR '(' word ')' {skipnl();} cmd
+ // {$$=mung3($1, $3, (tree *)0, $6);}
+ t1 = yylval.tree;
+ tok = yylex();
+ if(tok != '(')
+ syntax(tok);
+ t2 = yyword(yylex(), &tok);
+ switch(tok) {
+ default:
+ syntax(tok);
+ case ')':
+ t3 = nil;
+ break;
+ case IN:
+ t3 = words(yylex(), &tok);
+ if(t3 == nil)
+ t3 = tree1(PAREN, nil);
+ if(tok != ')')
+ syntax(tok);
+ break;
+ }
+ skipnl();
+ t4 = cmd(yylex(), ptok);
+ return mung3(t1, t2, t3, t4);
+
+ case WHILE:
+ // | WHILE paren {skipnl();} cmd
+ // {$$=mung2($1, $2, $4);}
+ t1 = yylval.tree;
+ t2 = paren(yylex());
+ skipnl();
+ t3 = cmd(yylex(), ptok);
+ return mung2(t1, t2, t3);
+
+ case SWITCH:
+ // | SWITCH word {skipnl();} brace
+ // {$$=tree2(SWITCH, $2, $4);}
+ t1 = yyword(yylex(), &tok);
+ while(tok == '\n')
+ tok = yylex();
+ t2 = brace(tok);
+ *ptok = yylex();
+ return tree2(SWITCH, t1, t2);
+ }
+}
+
+static tree*
+cmd2(int tok, int *ptok)
+{
+ int op;
+ tree *t1, *t2;
+
+ // | cmd ANDAND cmd {$$=tree2(ANDAND, $1, $3);}
+ // | cmd OROR cmd {$$=tree2(OROR, $1, $3);}
+
+ t1 = cmd3(tok, &tok);
+ while(tok == ANDAND || tok == OROR) {
+ op = tok;
+ t2 = cmd3(yylex(), &tok);
+ t1 = tree2(op, t1, t2);
+ }
+ *ptok = tok;
+ return t1;
+}
+
+static tree*
+cmd3(int tok, int *ptok)
+{
+ tree *t1, *t2, *t3;
+
+ // | cmd PIPE cmd {$$=mung2($2, $1, $3);}
+ t1 = cmd4(tok, &tok);
+ while(tok == PIPE) {
+ t2 = yylval.tree;
+ t3 = cmd4(yylex(), &tok);
+ t1 = mung2(t2, t1, t3);
+ }
+ *ptok = tok;
+ return t1;
+}
+
+static tree*
+cmd4(int tok, int *ptok)
+{
+ tree *t1, *t2, *t3;
+
+ switch(tok) {
+ case ';':
+ case '&':
+ case '\n':
+ *ptok = tok;
+ return nil;
+
+ case IF:
+ case FOR:
+ case SWITCH:
+ case WHILE:
+ // Note: cmd: a && for(x) y && b is a && {for (x) {y && b}}.
+ return cmd(tok, ptok);
+
+ case FN:
+ // | FN words brace {$$=tree2(FN, $2, $3);}
+ // | FN words {$$=tree1(FN, $2);}
+ t1 = words(yylex(), &tok);
+ if(tok != '{') {
+ *ptok = tok;
+ return tree1(FN, t1);
+ }
+ t2 = brace(tok);
+ *ptok = yylex();
+ return tree2(FN, t1, t2);
+
+ case TWIDDLE:
+ // | TWIDDLE word words {$$=mung2($1, $2, $3);}
+ t1 = yylval.tree;
+ t2 = yyword(yylex(), &tok);
+ t3 = words(tok, ptok);
+ return mung2(t1, t2, t3);
+
+ case BANG:
+ case SUBSHELL:
+ // | BANG cmd {$$=mung1($1, $2);}
+ // | SUBSHELL cmd {$$=mung1($1, $2);}
+ // Note: cmd3: ! x | y is !{x | y} not {!x} | y.
+ t1 = yylval.tree;
+ return mung1(t1, cmd3(yylex(), ptok));
+
+ case REDIR:
+ case DUP:
+ // | redir cmd %prec BANG {$$=mung2($1, $1->child[0], $2);}
+ // Note: cmd3: {>x echo a | tr a-z A-Z} writes A to x.
+ t1 = yyredir(tok, &tok);
+ t2 = cmd3(tok, ptok);
+ return mung2(t1, t1->child[0], t2);
+
+ case '{':
+ // | brace epilog {$$=epimung($1, $2);}
+ t1 = brace(tok);
+ tok = yylex();
+ t2 = epilog(tok, ptok);
+ return epimung(t1, t2);
+ }
+
+ if(!iswordtok(tok)) {
+ *ptok = tok;
+ return nil;
+ }
+
+ // cmd: ...
+ // | simple {$$=simplemung($1);}
+ // | assign cmd %prec BANG {$$=mung3($1, $1->child[0], $1->child[1], $2);}
+ // assign: first '=' word {$$=tree2('=', $1, $3);}
+ // Note: first is same as word except for disallowing all the leading keywords,
+ // but all those keywords have been picked off in the switch above.
+ // Except NOT, but disallowing that in yacc was likely a mistake anyway:
+ // there's no ambiguity in not=1 or not x y z.
+ t1 = yyword(tok, &tok);
+ if(tok == '=') {
+ // assignment
+ // Note: cmd3: {x=1 true | echo $x} echoes 1.
+ t1 = tree2('=', t1, yyword(yylex(), &tok));
+ t2 = cmd3(tok, ptok);
+ return mung3(t1, t1->child[0], t1->child[1], t2);
+ }
+
+ // simple: first
+ // | simple word {$$=tree2(ARGLIST, $1, $2);}
+ // | simple redir {$$=tree2(ARGLIST, $1, $2);}
+ for(;;) {
+ if(tok == REDIR || tok == DUP) {
+ t1 = tree2(ARGLIST, t1, yyredir(tok, &tok));
+ } else if(iswordtok(tok)) {
+ t1 = tree2(ARGLIST, t1, yyword(tok, &tok));
+ } else {
+ break;
+ }
+ }
+ *ptok = tok;
+ return simplemung(t1);
+}
+
+static tree*
+words(int tok, int *ptok)
+{
+ tree *t;
+
+ // words: {$$=(tree*)0;}
+ // | words word {$$=tree2(WORDS, $1, $2);}
+
+ t = nil;
+ while(iswordtok(tok))
+ t = tree2(WORDS, t, yyword(tok, &tok));
+ *ptok = tok;
+ return t;
+}
+
+static tree*
+yyword(int tok, int *ptok)
+{
+ tree *t;
+
+ // word: keyword {lastword=1; $1->type=WORD;}
+ // | comword
+ // | word '^' word {$$=tree2('^', $1, $3);}
+ // comword: '$' word {$$=tree1('$', $2);}
+ // | '$' word SUB words ')' {$$=tree2(SUB, $2, $4);}
+ // | '"' word {$$=tree1('"', $2);}
+ // | COUNT word {$$=tree1(COUNT, $2);}
+ // | WORD
+ // | '`' brace {$$=tree1('`', $2);}
+ // | '(' words ')' {$$=tree1(PAREN, $2);}
+ // | REDIR brace {$$=mung1($1, $2); $$->type=PIPEFD;}
+ // keyword: FOR|IN|WHILE|IF|NOT|TWIDDLE|BANG|SUBSHELL|SWITCH|FN
+ //
+ // factored into:
+ //
+ // word: word1
+ // | word '^' word1
+ //
+ // word1: keyword | comword
+
+ t = word1(tok, &tok);
+ while(tok == '^')
+ t = tree2('^', t, word1(yylex(), &tok));
+ *ptok = tok;
+ return t;
+}
+
+static tree*
+word1(int tok, int *ptok)
+{
+ tree *w, *sub, *t;
+
+ switch(tok) {
+ default:
+ syntax(tok);
+
+ case WORD:
+ case FOR:
+ case IN:
+ case WHILE:
+ case IF:
+ case NOT:
+ case TWIDDLE:
+ case BANG:
+ case SUBSHELL:
+ case SWITCH:
+ case FN:
+ // | WORD
+ // keyword: FOR|IN|WHILE|IF|NOT|TWIDDLE|BANG|SUBSHELL|SWITCH|FN
+ t = yylval.tree;
+ t->type = WORD;
+ lastword = 1;
+ *ptok = yylex();
+ return t;
+
+ case '$':
+ // comword: '$' word1 {$$=tree1('$', $2);}
+ // | '$' word1 SUB words ')' {$$=tree2(SUB, $2, $4);}
+ w = word1(yylex(), &tok);
+ if(tok == SUB) {
+ sub = words(yylex(), &tok);
+ if(tok != ')')
+ syntax(tok);
+ *ptok = yylex();
+ return tree2(SUB, w, sub);
+ }
+ *ptok = tok;
+ return tree1('$', w);
+
+ case '"':
+ // | '"' word1 {$$=tree1('"', $2);}
+ return tree1('"', word1(yylex(), ptok));
+
+ case COUNT:
+ // | COUNT word1 {$$=tree1(COUNT, $2);}
+ return tree1(COUNT, word1(yylex(), ptok));
+
+ case '`':
+ // | '`' brace {$$=tree1('`', $2);}
+ t = tree1('`', brace(yylex()));
+ *ptok = yylex();
+ return t;
+
+ case '(':
+ // | '(' words ')' {$$=tree1(PAREN, $2);}
+ t = tree1(PAREN, words(yylex(), &tok));
+ if(tok != ')')
+ syntax(tok);
+ *ptok = yylex();
+ return t;
+
+ case REDIRW:
+ // | REDIRW brace {$$=mung1($1, $2); $$->type=PIPEFD;}
+ t = yylval.tree;
+ t = mung1(t, brace(yylex()));
+ t->type = PIPEFD;
+ *ptok = yylex();
+ return t;
+ }
+}
+
+static int
+iswordtok(int tok)
+{
+ switch(tok) {
+ case FOR:
+ case IN:
+ case WHILE:
+ case IF:
+ case NOT:
+ case TWIDDLE:
+ case BANG:
+ case SUBSHELL:
+ case SWITCH:
+ case FN:
+ case '$':
+ case '"':
+ case COUNT:
+ case WORD:
+ case '`':
+ case '(':
+ case REDIRW:
+ return 1;
+ }
+ return 0;
+}
(DIR) diff --git a/src/cmd/rc/pcmd.c b/src/cmd/rc/pcmd.c
t@@ -145,3 +145,118 @@ pcmd(io *f, tree *t)
break;
}
}
+
+void
+pcmdu(io *f, tree *t) /* unambiguous */
+{
+ if(t==0) {
+ pfmt(f, "<nil>");
+ return;
+ }
+
+ switch(t->type){
+ default: pfmt(f, "(bad %d %p %p %p)", t->type, c0, c1, c2);
+ break;
+ case '$': pfmt(f, "($ %u)", c0);
+ break;
+ case '"': pfmt(f, "($\" %u)", c0);
+ break;
+ case '&': pfmt(f, "(& %u)", c0);
+ break;
+ case '^': pfmt(f, "(^ %u %u)", c0, c1);
+ break;
+ case '`': pfmt(f, "(` %u)", c0);
+ break;
+ case ANDAND: pfmt(f, "(&& %u %u)", c0, c1);
+ break;
+ case BANG: pfmt(f, "(! %u)", c0);
+ break;
+ case BRACE: pfmt(f, "(brace %u)", c0);
+ break;
+ case COUNT: pfmt(f, "($# %u)", c0);
+ break;
+ case FN: pfmt(f, "(fn %u %u)", c0, c1);
+ break;
+ case IF: pfmt(f, "(if %u %u)", c0, c1);
+ break;
+ case NOT: pfmt(f, "(if not %u)", c0);
+ break;
+ case OROR: pfmt(f, "(|| %u %u)", c0, c1);
+ break;
+ case PCMD:
+ case PAREN: pfmt(f, "(paren %u)", c0);
+ break;
+ case SUB: pfmt(f, "($sub %u %u)", c0, c1);
+ break;
+ case SIMPLE: pfmt(f, "(simple %u)", c0);
+ break;
+ case SUBSHELL: pfmt(f, "(@ %u)", c0);
+ break;
+ case SWITCH: pfmt(f, "(switch %u %u)", c0, c1);
+ break;
+ case TWIDDLE: pfmt(f, "(~ %u %u)", c0, c1);
+ break;
+ case WHILE: pfmt(f, "(while %u %u)", c0, c1);
+ break;
+ case ARGLIST:
+ pfmt(f, "(arglist %u %u)", c0, c1);
+ break;
+ case ';':
+ pfmt(f, "(; %u %u)", c0, c1);
+ break;
+ case WORDS:
+ pfmt(f, "(words %u %u)", c0, c1);
+ break;
+ case FOR:
+ pfmt(f, "(for %u %u %u)", c0, c1, c2);
+ break;
+ case WORD:
+ if(t->quoted)
+ pfmt(f, "%Q", t->str);
+ else pdeglob(f, t->str);
+ break;
+ case DUP:
+ if(t->rtype==DUPFD)
+ pfmt(f, "(>[%d=%d]", t->fd1, t->fd0); /* yes, fd1, then fd0; read lex.c */
+ else
+ pfmt(f, "(>[%d=]", t->fd0); /*)*/
+ pfmt(f, " %u)", c1);
+ break;
+ case PIPEFD:
+ case REDIR:
+ pfmt(f, "(");
+ switch(t->rtype){
+ case HERE:
+ pchr(f, '<');
+ case READ:
+ case RDWR:
+ pchr(f, '<');
+ if(t->rtype==RDWR)
+ pchr(f, '>');
+ if(t->fd0!=0)
+ pfmt(f, "[%d]", t->fd0);
+ break;
+ case APPEND:
+ pchr(f, '>');
+ case WRITE:
+ pchr(f, '>');
+ if(t->fd0!=1)
+ pfmt(f, "[%d]", t->fd0);
+ break;
+ }
+ pfmt(f, "%u %u)", c0, c1);
+ break;
+ case '=':
+ pfmt(f, "(%u=%u %u)", c0, c1, c2);
+ break;
+ case PIPE:
+ pfmt(f, "(|");
+ if(t->fd1==0){
+ if(t->fd0!=1)
+ pfmt(f, "[%d]", t->fd0);
+ }
+ else pfmt(f, "[%d=%d]", t->fd0, t->fd1);
+ pfmt(f, " %u %u", c0, c1);
+ break;
+ }
+}
(DIR) diff --git a/src/cmd/rc/simple.c b/src/cmd/rc/simple.c
t@@ -322,6 +322,7 @@ execdot(void)
static int first = 1;
char file[512];
word *path;
+
if(first){
dotcmds[0].i = 1;
dotcmds[1].f = Xmark;
(DIR) diff --git a/src/cmd/rc/syn.y b/src/cmd/rc/syn.y
t@@ -1,5 +1,5 @@
%term FOR IN WHILE IF NOT TWIDDLE BANG SUBSHELL SWITCH FN
-%term WORD REDIR DUP PIPE SUB
+%term WORD REDIR REDIRW DUP PIPE SUB
%term SIMPLE ARGLIST WORDS BRACE PAREN PCMD PIPEFD /* not used in syntax */
/* operator priorities -- lowest first */
%left IF WHILE FOR SWITCH ')' NOT
t@@ -19,7 +19,7 @@
%type<tree> line paren brace body cmdsa cmdsan assign epilog redir
%type<tree> cmd simple first word comword keyword words
%type<tree> NOT FOR IN WHILE IF TWIDDLE BANG SUBSHELL SWITCH FN
-%type<tree> WORD REDIR DUP PIPE
+%type<tree> WORD REDIR REDIRW DUP PIPE
%%
rc: { return 1;}
| line '\n' {return !compile($1);}
t@@ -45,7 +45,7 @@ cmd: {$$=0;}
| IF NOT {skipnl();} cmd {$$=mung1($2, $4);}
| FOR '(' word IN words ')' {skipnl();} cmd
/*
- * if ``words'' is nil, we need a tree element to distinguish between
+ * if ``words'' is nil, we need a tree element to distinguish between
* for(i in ) and for(i), the former being a loop over the empty set
* and the latter being the implicit argument loop. so if $5 is nil
* (the empty set), we represent it as "()". don't parenthesize non-nil
t@@ -73,7 +73,7 @@ cmd: {$$=0;}
simple: first
| simple word {$$=tree2(ARGLIST, $1, $2);}
| simple redir {$$=tree2(ARGLIST, $1, $2);}
-first: comword
+first: comword
| first '^' word {$$=tree2('^', $1, $3);}
word: keyword {lastword=1; $1->type=WORD;}
| comword
t@@ -85,7 +85,7 @@ comword: '$' word {$$=tree1('$', $2);}
| WORD
| '`' brace {$$=tree1('`', $2);}
| '(' words ')' {$$=tree1(PAREN, $2);}
-| REDIR brace {$$=mung1($1, $2); $$->type=PIPEFD;}
+| REDIRW brace {$$=mung1($1, $2); $$->type=PIPEFD;}
keyword: FOR|IN|WHILE|IF|NOT|TWIDDLE|BANG|SUBSHELL|SWITCH|FN
words: {$$=(struct tree*)0;}
| words word {$$=tree2(WORDS, $1, $2);}
(DIR) diff --git a/src/cmd/rc/test.rc b/src/cmd/rc/test.rc
t@@ -0,0 +1,38 @@
+# test for parser
+
+{a; b; c}
+x=y a && b || c
+x=y a | b | c
+x=y for(i) a | b
+>x for(i) a | b
+>x a || b && c
+a >x || b && c
+a | for(i) b | c
+fn x {y; z} | b && c
+if (x) y
+if not z
+`{} >x >[1=2]y >[3=] z <w
+~ x y && z
+x | y && z
+x | y || z
+! x | y | z
+@ x | y | z
+x | ! y | z
+x | @y | z
+! x | if(y) z
+@ x | if(y) z
+x=1 y | if(z) w
+a'b' c
+a^'b'^ c
+a^'b' c
+$$x
+$x($y)
+$"x
+$#x
+$#$x
+-$x-
+`{a;b;c}
+<{a;b}
+x for in while if not ~ ! @ switch fn
+x not$y
+a;b;c