Return to syn.y CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / cmd / rc

Annotation of lucent/sys/src/cmd/rc/syn.y, revision 1.1

1.1     ! root        1: %term FOR IN WHILE IF NOT TWIDDLE BANG SUBSHELL SWITCH FN
        !             2: %term WORD REDIR DUP PIPE SUB
        !             3: %term SIMPLE ARGLIST WORDS BRACE PAREN PCMD PIPEFD /* not used in syntax */
        !             4: /* operator priorities -- lowest first */
        !             5: %left IF WHILE FOR SWITCH ')' NOT
        !             6: %left ANDAND OROR
        !             7: %left BANG SUBSHELL
        !             8: %left PIPE
        !             9: %left '^'
        !            10: %right '$' COUNT '"'
        !            11: %left SUB
        !            12: %{
        !            13: #include "rc.h"
        !            14: #include "fns.h"
        !            15: %}
        !            16: %union{
        !            17:        struct tree *tree;
        !            18: };
        !            19: %type<tree> line paren brace body cmdsa cmdsan assign epilog redir
        !            20: %type<tree> cmd simple first word comword keyword words
        !            21: %type<tree> NOT FOR IN WHILE IF TWIDDLE BANG SUBSHELL SWITCH FN
        !            22: %type<tree> WORD REDIR DUP PIPE
        !            23: %%
        !            24: rc:                            { return 1;}
        !            25: |      line '\n'               {return !compile($1);}
        !            26: line:  cmd
        !            27: |      cmdsa line              {$$=tree2(';', $1, $2);}
        !            28: body:  cmd
        !            29: |      cmdsan body             {$$=tree2(';', $1, $2);}
        !            30: cmdsa: cmd ';'
        !            31: |      cmd '&'                 {$$=tree1('&', $1);}
        !            32: cmdsan:        cmdsa
        !            33: |      cmd '\n'
        !            34: brace: '{' body '}'            {$$=tree1(BRACE, $2);}
        !            35: paren: '(' body ')'            {$$=tree1(PCMD, $2);}
        !            36: assign:        first '=' word          {$$=tree2('=', $1, $3);}
        !            37: epilog:                                {$$=0;}
        !            38: |      redir epilog            {$$=mung2($1, $1->child[0], $2);}
        !            39: redir: REDIR word              {$$=mung1($1, $1->rtype==HERE?heredoc($2):$2);}
        !            40: |      DUP
        !            41: cmd:                           {$$=0;}
        !            42: |      brace epilog            {$$=epimung($1, $2);}
        !            43: |      IF paren {skipnl();} cmd
        !            44:                                {$$=mung2($1, $2, $4);}
        !            45: |      IF NOT {skipnl();} cmd  {$$=mung1($2, $4);}
        !            46: |      FOR '(' word IN words ')' {skipnl();} cmd
        !            47:                                {$$=mung3($1, $3, tree1(PAREN, $5), $8);}
        !            48: |      FOR '(' word ')' {skipnl();} cmd
        !            49:                                {$$=mung3($1, $3, (struct tree *)0, $6);}
        !            50: |      WHILE paren {skipnl();} cmd
        !            51:                                {$$=mung2($1, $2, $4);}
        !            52: |      SWITCH word {skipnl();} brace
        !            53:                                {$$=tree2(SWITCH, $2, $4);}
        !            54: |      simple                  {$$=simplemung($1);}
        !            55: |      TWIDDLE word words      {$$=mung2($1, $2, $3);}
        !            56: |      cmd ANDAND cmd          {$$=tree2(ANDAND, $1, $3);}
        !            57: |      cmd OROR cmd            {$$=tree2(OROR, $1, $3);}
        !            58: |      cmd PIPE cmd            {$$=mung2($2, $1, $3);}
        !            59: |      redir cmd  %prec BANG   {$$=mung2($1, $1->child[0], $2);}
        !            60: |      assign cmd %prec BANG   {$$=mung3($1, $1->child[0], $1->child[1], $2);}
        !            61: |      BANG cmd                {$$=mung1($1, $2);}
        !            62: |      SUBSHELL cmd            {$$=mung1($1, $2);}
        !            63: |      FN words brace          {$$=tree2(FN, $2, $3);}
        !            64: |      FN words                {$$=tree1(FN, $2);}
        !            65: simple:        first
        !            66: |      simple word             {$$=tree2(ARGLIST, $1, $2);}
        !            67: |      simple redir            {$$=tree2(ARGLIST, $1, $2);}
        !            68: first: comword 
        !            69: |      first '^' word          {$$=tree2('^', $1, $3);}
        !            70: word:  keyword                 {$1->type=WORD;}
        !            71: |      comword
        !            72: |      word '^' word           {$$=tree2('^', $1, $3);}
        !            73: comword: '$' word              {$$=tree1('$', $2);}
        !            74: |      '$' word SUB words ')'  {$$=tree2(SUB, $2, $4);}
        !            75: |      '"' word                {$$=tree1('"', $2);}
        !            76: |      COUNT word              {$$=tree1(COUNT, $2);}
        !            77: |      WORD
        !            78: |      '`' brace               {$$=tree1('`', $2);}
        !            79: |      '(' words ')'           {$$=tree1(PAREN, $2);}
        !            80: |      REDIR brace             {$$=mung1($1, $2); $$->type=PIPEFD;}
        !            81: keyword: FOR|IN|WHILE|IF|NOT|TWIDDLE|BANG|SUBSHELL|SWITCH|FN
        !            82: words:                         {$$=0;}
        !            83: |      words word              {$$=tree2(WORDS, $1, $2);}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.