cond.y

   1 %{
   2
   3 #include <stdio.h>
   4 #include <string.h>
   5
   6 #include "umpf.h"
   7
   8 static struct tree* tree_malloc(int type);
   9
  10 %}
  11 %error-verbose
  12
  13 %union {
  14         int n;
  15         char* str;
  16         struct tree* tr;
  17 }
  18
  19 %token <str> CONST
  20 %token <n> NUM
  21 %token <str> VAR
  22 %token <str> KW_DISCARD
  23 %token <str> KW_PIPE KW_MAIL KW_COPY
  24 %token '(' ')' '{' '}' ';'
  25 %nonassoc KW_IF
  26 %nonassoc KW_ELSE
  27 %left ARROW
  28 %left <n> EQ NEQ GE LE '<' '>' RE NRE
  29 %left '='
  30 %left '.'
  31 %left '+' '-'
  32 %left '*' '/'
  33 %left <n> '|'
  34 %left <n> '^'
  35 %left <n> '&'
  36 %left <n> '!'
  37 %type <tr> input
  38 %type <tr> command
  39 %type <tr> next
  40 %type <tr> ass
  41 %type <tr> ass_right
  42 %type <tr> cif
  43 %type <tr> arrow
  44 %type <tr> cond
  45 %type <n> rop
  46 %type <str> left
  47 %type <str> right
  48 %type <tr> leaves
  49
  50 %%
  51 input:  /* empty */     { $$ = input_tree = tree_malloc(ST_EMPTY); }
  52         | command input {       $$ = tree_malloc(ST_BLOCK);
  53                                 $$->pt.block.head = $1;
  54                                 $$->pt.block.tail = $2;
  55
  56                                 input_tree = $$;
  57                         }
  58 ;
  59
  60 command:         ';' { $$ = tree_malloc(ST_EMPTY); }
  61                 | '{' command next '}'  {
  62                                                 $$ = tree_malloc(ST_BLOCK);
  63                                                 $$->pt.block.head = $2;
  64                                                 $$->pt.block.tail = $3;
  65                                         }
  66                 | '{' '}' { $$ = tree_malloc(ST_EMPTY); }
  67                 | cif
  68                 | ass ';' { $$ = $1; }
  69                 | arrow ';' { $$ = $1; }
  70
  71
  72 ;
  73
  74 next:   /* empty */ {$$ = tree_malloc(ST_EMPTY); }
  75         | command
  76
  77
  78 ;
  79
  80 cif:    KW_IF cond command KW_ELSE command      {
  81                                         $$ = tree_malloc(ST_IF);
  82                                         $$->pt.tif.c = $2;
  83                                         $$->pt.tif.i = $3;
  84                                         $$->pt.tif.e = $5;
  85                                 }
  86         | KW_IF cond command    {
  87                                         $$ = tree_malloc(ST_IF);
  88                                         $$->pt.tif.c = $2;
  89                                         $$->pt.tif.i = $3;
  90                                         $$->pt.tif.e = tree_malloc(ST_EMPTY);
  91                                 }
  92 ;
  93
  94 cond:   '!' cond {
  95                                 $$ = tree_malloc(ST_COND);
  96                                 $$->pt.cond.left = $2;
  97                                 $$->pt.cond.right = NULL;
  98                                 $$->pt.cond.op = $1;
  99                                 $$->pt.cond.type = OP_BOOL;
 100                 }
 101         | cond '|' cond {
 102                                 $$ = tree_malloc(ST_COND);
 103                                 $$->pt.cond.left = $1;
 104                                 $$->pt.cond.right = $3;
 105                                 $$->pt.cond.op = $2;
 106                                 $$->pt.cond.type = OP_BOOL;
 107                         }
 108         | cond '&' cond {
 109                                 $$ = tree_malloc(ST_COND);
 110                                 $$->pt.cond.left = $1;
 111                                 $$->pt.cond.right = $3;
 112                                 $$->pt.cond.op = $2;
 113                                 $$->pt.cond.type = OP_BOOL;
 114                         }
 115         | cond '^' cond {
 116                                 $$ = tree_malloc(ST_COND);
 117                                 $$->pt.cond.left = $1;
 118                                 $$->pt.cond.right = $3;
 119                                 $$->pt.cond.op = $2;
 120                                 $$->pt.cond.type = OP_BOOL;
 121
 122                         }
 123         | '(' cond ')' { $$ = $2; }
 124         | ass_right rop ass_right       {
 125                                                 $$ = tree_malloc(ST_COND);
 126                                                 $$->pt.cond.left = $1;
 127                                                 $$->pt.cond.right = $3;
 128                                                 $$->pt.cond.op = $2;
 129                                                 $$->pt.cond.type = OP_REL;
 130                                         }
 131 ;
 132
 133 rop:    '>'
 134         | '<'
 135         | EQ
 136         | NEQ
 137         | LE
 138         | GE
 139         | RE
 140         | NRE
 141 ;
 142
 143 ass:
 144         VAR '=' ass_right       {
 145                                         $$ = tree_malloc(ST_ASS);
 146
 147                                         $$->pt.ass.left = tree_malloc(ST_LEAF);
 148                                         $$->pt.ass.left->pt.leaf.type = L_VAR;
 149                                         $$->pt.ass.left->pt.leaf.value = $1;
 150                                         $$->pt.ass.left->pt.leaf.n = find_var($1, var_hash);
 151                                         $$->pt.ass.right = $3;
 152                                 }
 153 ;
 154
 155 leaves:         VAR     {
 156                                 $$ = tree_malloc(ST_LEAF);
 157                                 $$->pt.leaf.type = L_VAR;
 158                                 $$->pt.leaf.value = $1;
 159                                 $$->pt.leaf.n = find_var($1, var_hash);
 160                         }
 161                 | CONST {
 162                                 $$ = tree_malloc(ST_LEAF);
 163                                 $$->pt.leaf.type = L_CONST;
 164                                 $$->pt.leaf.value = $1;
 165                                 $$->pt.leaf.n = store_const($1);
 166                         }
 167 ;
 168
 169 arrow:  left ARROW right ass_right  {
 170                                         $$ = tree_malloc(ST_ARROW);
 171                                         $$->pt.arrow.s = $4;
 172                                         $$->pt.arrow.kw_left = $1;
 173                                         $$->pt.arrow.kw_right = $3;
 174                                 }
 175         | left ARROW KW_DISCARD         { //FIXME: actually left does not make sense here
 176                                         $$ = tree_malloc(ST_ARROW);
 177                                         $$->pt.arrow.s = NULL;
 178                                         $$->pt.arrow.kw_left = NULL;
 179                                         $$->pt.arrow.kw_right = "discard";
 180                                 }
 181 ;
 182
 183 left:   /* empty */ { $$ = NULL;}
 184         | KW_COPY { $$ = "copy"; }
 185
 186 ;
 187
 188 right:  /* empty */ { $$ = NULL; }
 189         | KW_PIPE { $$ = "pipe"; }
 190         | KW_MAIL { $$ = "mail"; }
 191 ;
 192
 193 ass_right:      leaves
 194                 | ass_right '.' ass_right       {
 195                                         $$ = tree_malloc(ST_OP);
 196                                         $$->pt.op.op = '.';
 197                                         $$->pt.op.left = $1;
 198                                         $$->pt.op.right = $3;
 199                                 }
 200 ;
 201
 202 %%
 203
 204 struct tree*
 205 tree_malloc(int type)
 206 {
 207         struct tree* temp;
 208         temp = xmalloc(sizeof (struct tree));
 209         temp->st=type;
 210
 211         return temp;
 212 }
 213
 214 void
 215 yyerror (char const *s)
 216 {
 217         fprintf (stderr, "Line %d: %s\n", line, s);
 218 }