Return to gram.expr CVS log

Up to [CSRG BSD Unix] / 43BSDReno / old / efl

Annotation of 43BSDReno/old/efl/gram.expr, revision 1.1.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.