Return to gram.expr CVS log

Up to [CSRG BSD Unix] / 41BSD / cmd / efl

Annotation of 41BSD/cmd/efl/gram.expr, revision 1.1

1.1     ! root        1: expr:    lhs
        !             2:                { if($1->tag == TCALL)
        !             3:                        $1 = funcinv($1);
        !             4:                  if($1->vtype==TYUNDEFINED && $1->vext==0)
        !             5:                        impldecl($1);
        !             6:                  else if($1->tag==TNAME && $1->vdcldone==0
        !             7:                          && $1->vext==0 && !inbound)
        !             8:                                dclit($1);
        !             9:                  if($1->vtype==TYFIELD)
        !            10:                        $$ = extrfield($1);
        !            11:                }
        !            12:        | CONST
        !            13:        | logcon
        !            14:                { $$ = mkconst(TYLOG, ($1 == TRUE ? ".true." : ".false.") ); }
        !            15:        | specs parexprs
        !            16:                { $$ = typexpr($1,$2); }
        !            17:        | sizeof
        !            18:        | lengthof
        !            19:        | parexprs
        !            20:                { if( !ininit && $1->tag== TLIST)
        !            21:                        $$ = compconst($1); 
        !            22:                  else $1->needpar = 1; }
        !            23:        | expr ADDOP expr
        !            24:                { $$ = mknode(TAROP,$2,$1,$3); }
        !            25:        | expr MULTOP expr
        !            26:                { $$ = mknode(TAROP,$2,$1,$3); }
        !            27:        | expr POWER expr
        !            28:                { $$ = mknode(TAROP,$2,$1,$3); }
        !            29:        | ADDOP expr  %prec MULTOP
        !            30:                { if($1==OPMINUS)
        !            31:                        $$ = mknode(TNEGOP,OPMINUS, $2, PNULL);
        !            32:                  else  $$ = $2;  }
        !            33:        | DOUBLEADDOP lhs  %prec MULTOP
        !            34:                { $$ =  mknode(TASGNOP,$1,$2,mkint(1)); }
        !            35:        | expr RELOP expr
        !            36:                { $$ = mknode(TRELOP,$2,$1,$3); }
        !            37:        | expr OR expr
        !            38:                { $$ = mknode(TLOGOP,$2,$1,$3); }
        !            39:        | expr AND expr
        !            40:                { $$ = mknode(TLOGOP,$2,$1,$3); }
        !            41:        | NOT expr
        !            42:                { $$ = mknode(TNOTOP,$1,$2,PNULL); }
        !            43:        | lhs ASGNOP expr
        !            44:                { if($1->tag == TCALL)
        !            45:                        {
        !            46:                        exprerr("may not assign to a function", CNULL);
        !            47:                        $$ = errnode();
        !            48:                        }
        !            49:                  else
        !            50:                        $$ = mknode(TASGNOP,$2,$1,$3);
        !            51:                }
        !            52:        | expr REPOP expr
        !            53:                { $$ = mknode(TREPOP,0,$1,$3); }
        !            54:        | iostat
        !            55:        | error
        !            56:                { $$ = errnode(); }
        !            57:        ;
        !            58: 
        !            59: lhs:   lhs1
        !            60:                { if($1->tag==TNAME && $1->vdcldone==0 &&
        !            61:                        $1->vsubs==0 && $1->vext==0 && !inbound)
        !            62:                                dclit($1);
        !            63:                }
        !            64:        ;
        !            65: 
        !            66: lhs1:    lhsname
        !            67:        | lhsname parexprs
        !            68:                {
        !            69:                if($2->tag!=TLIST)
        !            70:                        $2 = mknode(TLIST,0, mkchain($2,CHNULL), PNULL);
        !            71:                if($1->vdim)
        !            72:                        {
        !            73:                        if($1->vdcldone==0 && $1->vext==0)
        !            74:                                dclit($1);
        !            75:                        $$ = subscript($1,$2);
        !            76:                        }
        !            77:                else    $$ = mkcall($1,$2);
        !            78:                }
        !            79:        | lhs QUALOP NAME
        !            80:                { $$ = strucelt($1,$3); }
        !            81:        | lhs QUALOP NAME parexprs
        !            82:                { if($4->tag != TLIST)
        !            83:                        $4 = mknode(TLIST,0, mkchain($4,CHNULL), PNULL);
        !            84:                  $$ = subscript(strucelt($1,$3), $4);
        !            85:                }
        !            86:        | lhs ARROW STRUCTNAME
        !            87:                { $$ = mkarrow($1,$3); }
        !            88:        ;
        !            89: 
        !            90: lhsname:  NAME
        !            91:                { if($1->varp == 0) mkvar($1);
        !            92:                  if(inbound)
        !            93:                          $1->varp->vadjdim = 1;
        !            94:                  $$ = cpexpr($1->varp); }
        !            95:        ;
        !            96: 
        !            97: parexprs: LPAR RPAR
        !            98:                { $$ = mknode(TLIST, 0, PNULL, PNULL); }
        !            99:        | LPAR expr RPAR
        !           100:                { $$ = $2; }
        !           101:        | LPAR exprlist RPAR
        !           102:                { $$ = mknode(TLIST,0,$2,PNULL); }
        !           103:        ;
        !           104: 
        !           105: exprlist: expr COMMA expr
        !           106:                { $$ = mkchain($1, mkchain($3, CHNULL) ); }
        !           107:        | exprlist COMMA expr
        !           108:                { hookup($1, mkchain($3,CHNULL) ); }
        !           109:        ;
        !           110: 
        !           111: sizeof:          SIZEOF LPAR expr RPAR
        !           112:                { $$ = esizeof($3->vtype, $3->vtypep, $3->vdim);
        !           113:                  frexpr($3); }
        !           114:        | SIZEOF LPAR specs RPAR
        !           115:                { if($3->attype==TYREAL && $3->atprec)
        !           116:                        $3->attype = TYLREAL;
        !           117:                  $$ = esizeof($3->attype, $3->attypep, $3->atdim);
        !           118:                  cfree($3);
        !           119:                }
        !           120:        | SIZEOF LPAR CHARACTER RPAR
        !           121:                { $$ = mkint(tailor.ftnsize[FTNINT]/tailor.ftnchwd); }
        !           122:        ;
        !           123: 
        !           124: lengthof:        LENGTHOF LPAR expr RPAR
        !           125:                { $$ = elenof($3->vtype, $3->vtypep, $3->vdim);
        !           126:                  frexpr($3); }
        !           127:        | LENGTHOF LPAR specs RPAR
        !           128:                { $$ = elenof($3->attype, $3->attypep, $3->atdim);
        !           129:                  cfree($3);
        !           130:                }
        !           131:        | LENGTHOF LPAR CHARACTER RPAR
        !           132:                { $$ = mkint(1); }
        !           133:        ;
        !           134: 
        !           135: logcon:   logval
        !           136:        | QUALOP logval QUALOP
        !           137:                { $$ = $2; }
        !           138:        ;
        !           139: 
        !           140: logval:   TRUE
        !           141:        | FALSE
        !           142:        ;

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