lang/fortran/comp/gram.expr

   1 funarglist:
   2                 { $$ = 0; }
   3         | funargs
   4                 { $$ = revchain($1); }
   5         ;
   6
   7 funargs:  expr
   8                 { $$ = mkchain((char *)$1, CHNULL); }
   9         | funargs SCOMMA expr
  10                 { $$ = mkchain((char *)$3, $1); }
  11         ;
  12
  13
  14 expr:     uexpr
  15         | SLPAR expr SRPAR      { $$ = $2; }
  16         | complex_const
  17         ;
  18
  19 uexpr:    lhs
  20         | simple_const
  21         | expr addop expr   %prec SPLUS
  22                 { $$ = mkexpr($2, $1, $3); }
  23         | expr SSTAR expr
  24                 { $$ = mkexpr(OPSTAR, $1, $3); }
  25         | expr SSLASH expr
  26                 { $$ = mkexpr(OPSLASH, $1, $3); }
  27         | expr SPOWER expr
  28                 { $$ = mkexpr(OPPOWER, $1, $3); }
  29         | addop expr  %prec SSTAR
  30                 { if($1 == OPMINUS)
  31                         $$ = mkexpr(OPNEG, $2, ENULL);
  32                   else  $$ = $2;
  33                 }
  34         | expr relop expr  %prec SEQ
  35                 { $$ = mkexpr($2, $1, $3); }
  36         | expr SEQV expr
  37                 { NO66(".EQV. operator");
  38                   $$ = mkexpr(OPEQV, $1,$3); }
  39         | expr SNEQV expr
  40                 { NO66(".NEQV. operator");
  41                   $$ = mkexpr(OPNEQV, $1, $3); }
  42         | expr SOR expr
  43                 { $$ = mkexpr(OPOR, $1, $3); }
  44         | expr SAND expr
  45                 { $$ = mkexpr(OPAND, $1, $3); }
  46         | SNOT expr
  47                 { $$ = mkexpr(OPNOT, $2, ENULL); }
  48         | expr SCONCAT expr
  49                 { NO66("concatenation operator //");
  50                   $$ = mkexpr(OPCONCAT, $1, $3); }
  51         ;
  52
  53 addop:    SPLUS         { $$ = OPPLUS; }
  54         | SMINUS        { $$ = OPMINUS; }
  55         ;
  56
  57 relop:    SEQ   { $$ = OPEQ; }
  58         | SGT   { $$ = OPGT; }
  59         | SLT   { $$ = OPLT; }
  60         | SGE   { $$ = OPGE; }
  61         | SLE   { $$ = OPLE; }
  62         | SNE   { $$ = OPNE; }
  63         ;
  64
  65 lhs:     name
  66                 { $$ = mkprim($1, LBNULL, CHNULL); }
  67         | name substring
  68                 { NO66("substring operator :");
  69                   $$ = mkprim($1, LBNULL, $2); }
  70         | name SLPAR funarglist SRPAR
  71                 { $$ = mkprim($1, mklist($3), CHNULL); }
  72         | name SLPAR funarglist SRPAR substring
  73                 { NO66("substring operator :");
  74                   $$ = mkprim($1, mklist($3), $5); }
  75         ;
  76
  77 substring:  SLPAR opt_expr SCOLON opt_expr SRPAR
  78                 { $$ = mkchain((char *)$2, mkchain((char *)$4,CHNULL)); }
  79         ;
  80
  81 opt_expr:
  82                 { $$ = 0; }
  83         | expr
  84         ;
  85
  86 simple:   name
  87                 { if($1->vclass == CLPARAM)
  88                         $$ = (expptr) cpexpr(
  89                                 ( (struct Paramblock *) ($1) ) -> paramval);
  90                 }
  91         | simple_const
  92         ;
  93
  94 simple_const:   STRUE   { $$ = mklogcon(1); }
  95         | SFALSE        { $$ = mklogcon(0); }
  96         | SHOLLERITH  { $$ = mkstrcon(toklen, token); }
  97         | SICON = { $$ = mkintcon( convci(toklen, token) ); }
  98         | SRCON = { $$ = mkrealcon(tyreal, token); }
  99         | SDCON = { $$ = mkrealcon(TYDREAL, token); }
 100         | bit_const
 101         ;
 102
 103 complex_const:  SLPAR uexpr SCOMMA uexpr SRPAR
 104                 { $$ = mkcxcon($2,$4); }
 105         ;
 106
 107 bit_const:  SHEXCON
 108                 { NOEXT("hex constant");
 109                   $$ = mkbitcon(4, toklen, token); }
 110         | SOCTCON
 111                 { NOEXT("octal constant");
 112                   $$ = mkbitcon(3, toklen, token); }
 113         | SBITCON
 114                 { NOEXT("binary constant");
 115                   $$ = mkbitcon(1, toklen, token); }
 116         ;
 117
 118 fexpr:    unpar_fexpr
 119         | SLPAR fexpr SRPAR
 120                 { $$ = $2; }
 121         ;
 122
 123 unpar_fexpr:      lhs
 124         | simple_const
 125         | fexpr addop fexpr   %prec SPLUS
 126                 { $$ = mkexpr($2, $1, $3); }
 127         | fexpr SSTAR fexpr
 128                 { $$ = mkexpr(OPSTAR, $1, $3); }
 129         | fexpr SSLASH fexpr
 130                 { $$ = mkexpr(OPSLASH, $1, $3); }
 131         | fexpr SPOWER fexpr
 132                 { $$ = mkexpr(OPPOWER, $1, $3); }
 133         | addop fexpr  %prec SSTAR
 134                 { if($1 == OPMINUS)
 135                         $$ = mkexpr(OPNEG, $2, ENULL);
 136                   else  $$ = $2;
 137                 }
 138         | fexpr SCONCAT fexpr
 139                 { NO66("concatenation operator //");
 140                   $$ = mkexpr(OPCONCAT, $1, $3); }
 141         ;