Subversion Repositories planix.SVN

%term FOR IN WHILE IF NOT TWIDDLE BANG SUBSHELL SWITCH FN
%term WORD REDIR 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
%left ANDAND OROR
%left BANG SUBSHELL
%left PIPE
%left '^'
%right '$' COUNT '"'
%left SUB
%{
#include "rc.h"
#include "fns.h"
%}
%union{
        struct tree *tree;
};
%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
%%
rc:                             { return 1;}
|       line '\n'               {return !compile($1);}
line:   cmd
|       cmdsa line              {$$=tree2(';', $1, $2);}
body:   cmd
|       cmdsan body             {$$=tree2(';', $1, $2);}
cmdsa:  cmd ';'
|       cmd '&'                 {$$=tree1('&', $1);}
cmdsan: cmdsa
|       cmd '\n'
brace:  '{' body '}'            {$$=tree1(BRACE, $2);}
paren:  '(' body ')'            {$$=tree1(PCMD, $2);}
assign: first '=' word          {$$=tree2('=', $1, $3);}
epilog:                         {$$=0;}
|       redir epilog            {$$=mung2($1, $1->child[0], $2);}
redir:  REDIR word              {$$=mung1($1, $1->rtype==HERE?heredoc($2):$2);}
|       DUP
cmd:                            {$$=0;}
|       brace epilog            {$$=epimung($1, $2);}
|       IF paren {skipnl();} cmd
                                {$$=mung2($1, $2, $4);}
|       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 
         * 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
         * functions, to avoid growing parentheses every time we reread the
         * definition.
         */
                                {$$=mung3($1, $3, $5 ? $5 : tree1(PAREN, $5), $8);}
|       FOR '(' word ')' {skipnl();} cmd
                                {$$=mung3($1, $3, (struct tree *)0, $6);}
|       WHILE paren {skipnl();} cmd
                                {$$=mung2($1, $2, $4);}
|       SWITCH word {skipnl();} brace
                                {$$=tree2(SWITCH, $2, $4);}
|       simple                  {$$=simplemung($1);}
|       TWIDDLE word words      {$$=mung2($1, $2, $3);}
|       cmd ANDAND cmd          {$$=tree2(ANDAND, $1, $3);}
|       cmd OROR cmd            {$$=tree2(OROR, $1, $3);}
|       cmd PIPE cmd            {$$=mung2($2, $1, $3);}
|       redir cmd  %prec BANG   {$$=mung2($1, $1->child[0], $2);}
|       assign cmd %prec BANG   {$$=mung3($1, $1->child[0], $1->child[1], $2);}
|       BANG cmd                {$$=mung1($1, $2);}
|       SUBSHELL cmd            {$$=mung1($1, $2);}
|       FN words brace          {$$=tree2(FN, $2, $3);}
|       FN words                {$$=tree1(FN, $2);}
simple: first
|       simple word             {$$=tree2(ARGLIST, $1, $2);}
|       simple redir            {$$=tree2(ARGLIST, $1, $2);}
first:  comword 
|       first '^' word          {$$=tree2('^', $1, $3);}
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
words:                          {$$=(struct tree*)0;}
|       words word              {$$=tree2(WORDS, $1, $2);}