git.gag.com Git - fw/sdcc/blob - src/SDCC.y

   1 /*-----------------------------------------------------------------------
   2
   3   SDCC.y - parser definition file for sdcc :
   4           Written By : Sandeep Dutta . sandeep.dutta@usa.net (1997)
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 2, or (at your option) any
   9    later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19
  20    In other words, you are welcome to use, share and improve this program.
  21    You are forbidden to forbid anyone else to use, share and improve
  22    what you give them.   Help stamp out software-hoarding!
  23 -------------------------------------------------------------------------*/
  24 %{
  25 #include <stdio.h>
  26 #include <stdarg.h>
  27 #include <string.h>
  28 #include "SDCCglobl.h"
  29 #include "SDCCsymt.h"
  30 #include "SDCChasht.h"
  31 #include "SDCCval.h"
  32 #include "SDCCmem.h"
  33 #include "SDCCast.h"
  34 #include "port.h"
  35 #include "newalloc.h"
  36 #include "SDCCerr.h"
  37 #include "SDCCutil.h"
  38
  39 extern int yyerror (char *);
  40 extern FILE     *yyin;
  41 int NestLevel = 0 ;     /* current NestLevel       */
  42 int stackPtr  = 1 ;     /* stack pointer           */
  43 int xstackPtr = 0 ;     /* xstack pointer          */
  44 int reentrant = 0 ;
  45 int blockNo   = 0 ;     /* sequential block number  */
  46 int currBlockno=0 ;
  47 int inCritical= 0 ;
  48 extern int yylex();
  49 int yyparse(void);
  50 extern int noLineno ;
  51 char lbuff[1024];      /* local buffer */
  52
  53 /* break & continue stacks */
  54 STACK_DCL(continueStack  ,symbol *,MAX_NEST_LEVEL)
  55 STACK_DCL(breakStack  ,symbol *,MAX_NEST_LEVEL)
  56 STACK_DCL(forStack  ,symbol *,MAX_NEST_LEVEL)
  57 STACK_DCL(swStk   ,ast   *,MAX_NEST_LEVEL)
  58 STACK_DCL(blockNum,int,MAX_NEST_LEVEL*3)
  59
  60 value *cenum = NULL  ;  /* current enumeration  type chain*/
  61 bool uselessDecl = TRUE;
  62
  63 %}
  64 %expect 6
  65
  66 %union {
  67     symbol     *sym ;      /* symbol table pointer       */
  68     structdef  *sdef;      /* structure definition       */
  69     char       yychar[SDCC_NAME_MAX+1];
  70     sym_link   *lnk ;      /* declarator  or specifier   */
  71     int        yyint;      /* integer value returned     */
  72     value      *val ;      /* for integer constant       */
  73     initList   *ilist;     /* initial list               */
  74     const char *yyinline;  /* inlined assembler code     */
  75     ast        *asts;      /* expression tree            */
  76 }
  77
  78 %token <yychar> IDENTIFIER TYPE_NAME
  79 %token <val>   CONSTANT   STRING_LITERAL
  80 %token SIZEOF TYPEOF
  81 %token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP
  82 %token AND_OP OR_OP
  83 %token <yyint> MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
  84 %token <yyint> SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
  85 %token <yyint> XOR_ASSIGN OR_ASSIGN
  86 %token TYPEDEF EXTERN STATIC AUTO REGISTER CODE EEPROM INTERRUPT SFR AT SBIT
  87 %token REENTRANT USING  XDATA DATA IDATA PDATA VAR_ARGS CRITICAL NONBANKED BANKED
  88 %token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID BIT
  89 %token STRUCT UNION ENUM ELIPSIS RANGE FAR
  90 %token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN
  91 %token NAKED JAVANATIVE OVERLAY
  92 %token <yyinline> INLINEASM
  93 %token IFX ADDRESS_OF GET_VALUE_AT_ADDRESS SPIL UNSPIL GETHBIT
  94 %token BITWISEAND UNARYMINUS IPUSH IPOP PCALL  ENDFUNCTION JUMPTABLE
  95 %token RRC RLC
  96 %token CAST CALL PARAM NULLOP BLOCK LABEL RECEIVE SEND ARRAYINIT
  97 %token DUMMY_READ_VOLATILE ENDCRITICAL SWAP
  98
  99 %type <yyint>  Interrupt_storage
 100 %type <sym> identifier  declarator  declarator2 enumerator_list enumerator
 101 %type <sym> struct_declarator
 102 %type <sym> struct_declarator_list  struct_declaration   struct_declaration_list
 103 %type <sym> declaration init_declarator_list init_declarator
 104 %type <sym> declaration_list identifier_list parameter_identifier_list
 105 %type <sym> declarator2_function_attributes while do for critical
 106 %type <lnk> pointer type_specifier_list type_specifier type_name
 107 %type <lnk> storage_class_specifier struct_or_union_specifier
 108 %type <lnk> declaration_specifiers  sfr_reg_bit type_specifier2
 109 %type <lnk> function_attribute function_attributes enum_specifier
 110 %type <lnk> abstract_declarator abstract_declarator2 unqualified_pointer
 111 %type <val> parameter_type_list parameter_list parameter_declaration opt_assign_expr
 112 %type <sdef> stag opt_stag
 113 %type <asts> primary_expr
 114 %type <asts> postfix_expr unary_expr cast_expr multiplicative_expr
 115 %type <asts> additive_expr shift_expr relational_expr equality_expr
 116 %type <asts> and_expr exclusive_or_expr inclusive_or_expr logical_or_expr
 117 %type <asts> logical_and_expr conditional_expr assignment_expr constant_expr
 118 %type <asts> expr argument_expr_list function_definition expr_opt
 119 %type <asts> statement_list statement labeled_statement compound_statement
 120 %type <asts> expression_statement selection_statement iteration_statement
 121 %type <asts> jump_statement function_body else_statement string_literal
 122 %type <asts> critical_statement
 123 %type <ilist> initializer initializer_list
 124 %type <yyint> unary_operator  assignment_operator struct_or_union
 125
 126 %start file
 127
 128 %%
 129
 130 file
 131    : external_definition
 132    | file external_definition
 133    ;
 134
 135 external_definition
 136    : function_definition     {
 137                                blockNo=0;
 138                              }
 139    | declaration             {
 140                                if ($1 && $1->type
 141                                 && IS_FUNC($1->type))
 142                                {
 143                                    /* The only legal storage classes for
 144                                     * a function prototype (declaration)
 145                                     * are extern and static. extern is the
 146                                     * default. Thus, if this function isn't
 147                                     * explicitly marked static, mark it
 148                                     * extern.
 149                                     */
 150                                    if ($1->etype
 151                                     && IS_SPEC($1->etype)
 152                                     && !SPEC_STAT($1->etype))
 153                                    {
 154                                         SPEC_EXTR($1->etype) = 1;
 155                                    }
 156                                }
 157                                addSymChain ($1);
 158                                allocVariables ($1) ;
 159                                cleanUpLevel (SymbolTab,1);
 160                              }
 161    ;
 162
 163 function_definition
 164    : declarator function_body  {   /* function type not specified */
 165                                    /* assume it to be 'int'       */
 166                                    addDecl($1,0,newIntLink());
 167                                    $$ = createFunction($1,$2);
 168                                }
 169    | declaration_specifiers declarator function_body
 170                                 {
 171                                     pointerTypes($2->type,copyLinkChain($1));
 172                                     addDecl($2,0,$1);
 173                                     $$ = createFunction($2,$3);
 174                                 }
 175    ;
 176
 177 function_attribute
 178    : function_attributes
 179    | function_attributes function_attribute { $$ = mergeSpec($1,$2,"function_attribute"); }
 180    ;
 181
 182 function_attributes
 183    :  USING CONSTANT {
 184                         $$ = newLink(SPECIFIER) ;
 185                         FUNC_REGBANK($$) = (int) floatFromVal($2);
 186                      }
 187    |  REENTRANT      {  $$ = newLink (SPECIFIER);
 188                         FUNC_ISREENT($$)=1;
 189                      }
 190    |  CRITICAL       {  $$ = newLink (SPECIFIER);
 191                         FUNC_ISCRITICAL($$) = 1;
 192                      }
 193    |  NAKED          {  $$ = newLink (SPECIFIER);
 194                         FUNC_ISNAKED($$)=1;
 195                      }
 196    |  JAVANATIVE     {  $$ = newLink (SPECIFIER);
 197                         FUNC_ISJAVANATIVE($$)=1;
 198                      }
 199    |  OVERLAY        {  $$ = newLink (SPECIFIER);
 200                         FUNC_ISOVERLAY($$)=1;
 201                      }
 202    |  NONBANKED      {$$ = newLink (SPECIFIER);
 203                         FUNC_NONBANKED($$) = 1;
 204                         if (FUNC_BANKED($$)) {
 205                             werror(W_BANKED_WITH_NONBANKED);
 206                         }
 207                      }
 208    |  BANKED         {$$ = newLink (SPECIFIER);
 209                         FUNC_BANKED($$) = 1;
 210                         if (FUNC_NONBANKED($$)) {
 211                             werror(W_BANKED_WITH_NONBANKED);
 212                         }
 213                         if (SPEC_STAT($$)) {
 214                             werror(W_BANKED_WITH_STATIC);
 215                         }
 216                      }
 217    |  Interrupt_storage
 218                      {
 219                         $$ = newLink (SPECIFIER) ;
 220                         FUNC_INTNO($$) = $1 ;
 221                         FUNC_ISISR($$) = 1;
 222                      }
 223    ;
 224
 225 function_body
 226    : compound_statement
 227    | declaration_list compound_statement
 228          {
 229             werror(E_OLD_STYLE,($1 ? $1->name: "")) ;
 230             exit(1);
 231          }
 232    ;
 233
 234 primary_expr
 235    : identifier      {  $$ = newAst_VALUE(symbolVal($1));  }
 236    | CONSTANT        {  $$ = newAst_VALUE($1);  }
 237    | string_literal
 238    | '(' expr ')'    {  $$ = $2 ;                   }
 239    ;
 240
 241 string_literal
 242     : STRING_LITERAL                    { $$ = newAst_VALUE($1); }
 243     ;
 244
 245 postfix_expr
 246    : primary_expr
 247    | postfix_expr '[' expr ']'          { $$ = newNode  ('[', $1, $3) ; }
 248    | postfix_expr '(' ')'               { $$ = newNode  (CALL,$1,NULL);
 249                                           $$->left->funcName = 1;}
 250    | postfix_expr '(' argument_expr_list ')'
 251           {
 252             $$ = newNode  (CALL,$1,$3) ; $$->left->funcName = 1;
 253           }
 254    | postfix_expr '.' identifier
 255                       {
 256                         $3 = newSymbol($3->name,NestLevel);
 257                         $3->implicit = 1;
 258                         $$ = newNode(PTR_OP,newNode('&',$1,NULL),newAst_VALUE(symbolVal($3)));
 259 /*                      $$ = newNode('.',$1,newAst(EX_VALUE,symbolVal($3))) ;                   */
 260                       }
 261    | postfix_expr PTR_OP identifier
 262                       {
 263                         $3 = newSymbol($3->name,NestLevel);
 264                         $3->implicit = 1;
 265                         $$ = newNode(PTR_OP,$1,newAst_VALUE(symbolVal($3)));
 266                       }
 267    | postfix_expr INC_OP
 268                       { $$ = newNode(INC_OP,$1,NULL);}
 269    | postfix_expr DEC_OP
 270                       { $$ = newNode(DEC_OP,$1,NULL); }
 271    ;
 272
 273 argument_expr_list
 274    : assignment_expr
 275    | assignment_expr ',' argument_expr_list { $$ = newNode(PARAM,$1,$3); }
 276    ;
 277
 278 unary_expr
 279    : postfix_expr
 280    | INC_OP unary_expr        { $$ = newNode(INC_OP,NULL,$2);  }
 281    | DEC_OP unary_expr        { $$ = newNode(DEC_OP,NULL,$2);  }
 282    | unary_operator cast_expr { $$ = newNode($1,$2,NULL)    ;  }
 283    | SIZEOF unary_expr        { $$ = newNode(SIZEOF,NULL,$2);  }
 284    | SIZEOF '(' type_name ')' { $$ = newAst_VALUE(sizeofOp($3)); }
 285    | TYPEOF unary_expr        { $$ = newNode(TYPEOF,NULL,$2);  }
 286    ;
 287
 288 unary_operator
 289    : '&'    { $$ = '&' ;}
 290    | '*'    { $$ = '*' ;}
 291    | '+'    { $$ = '+' ;}
 292    | '-'    { $$ = '-' ;}
 293    | '~'    { $$ = '~' ;}
 294    | '!'    { $$ = '!' ;}
 295    ;
 296
 297 cast_expr
 298    : unary_expr
 299    | '(' type_name ')' cast_expr { $$ = newNode(CAST,newAst_LINK($2),$4); }
 300    ;
 301
 302 multiplicative_expr
 303    : cast_expr
 304    | multiplicative_expr '*' cast_expr { $$ = newNode('*',$1,$3);}
 305    | multiplicative_expr '/' cast_expr { $$ = newNode('/',$1,$3);}
 306    | multiplicative_expr '%' cast_expr { $$ = newNode('%',$1,$3);}
 307    ;
 308
 309 additive_expr
 310    : multiplicative_expr
 311    | additive_expr '+' multiplicative_expr { $$=newNode('+',$1,$3);}
 312    | additive_expr '-' multiplicative_expr { $$=newNode('-',$1,$3);}
 313    ;
 314
 315 shift_expr
 316    : additive_expr
 317    | shift_expr LEFT_OP additive_expr  { $$ = newNode(LEFT_OP,$1,$3); }
 318    | shift_expr RIGHT_OP additive_expr { $$ = newNode(RIGHT_OP,$1,$3); }
 319    ;
 320
 321 relational_expr
 322    : shift_expr
 323    | relational_expr '<' shift_expr    {
 324         $$ = (port->lt_nge ?
 325               newNode('!',newNode(GE_OP,$1,$3),NULL) :
 326               newNode('<', $1,$3));
 327    }
 328    | relational_expr '>' shift_expr    {
 329            $$ = (port->gt_nle ?
 330                  newNode('!',newNode(LE_OP,$1,$3),NULL) :
 331                  newNode('>',$1,$3));
 332    }
 333    | relational_expr LE_OP shift_expr  {
 334            $$ = (port->le_ngt ?
 335                  newNode('!', newNode('>', $1 , $3 ), NULL) :
 336                  newNode(LE_OP,$1,$3));
 337    }
 338    | relational_expr GE_OP shift_expr  {
 339            $$ = (port->ge_nlt ?
 340                  newNode('!', newNode('<', $1 , $3 ), NULL) :
 341                  newNode(GE_OP,$1,$3));
 342    }
 343    ;
 344
 345 equality_expr
 346    : relational_expr
 347    | equality_expr EQ_OP relational_expr  {
 348     $$ = (port->eq_nne ?
 349           newNode('!',newNode(NE_OP,$1,$3),NULL) :
 350           newNode(EQ_OP,$1,$3));
 351    }
 352    | equality_expr NE_OP relational_expr {
 353        $$ = (port->ne_neq ?
 354              newNode('!', newNode(EQ_OP,$1,$3), NULL) :
 355              newNode(NE_OP,$1,$3));
 356    }
 357    ;
 358
 359 and_expr
 360    : equality_expr
 361    | and_expr '&' equality_expr  { $$ = newNode('&',$1,$3);}
 362    ;
 363
 364 exclusive_or_expr
 365    : and_expr
 366    | exclusive_or_expr '^' and_expr { $$ = newNode('^',$1,$3);}
 367    ;
 368
 369 inclusive_or_expr
 370    : exclusive_or_expr
 371    | inclusive_or_expr '|' exclusive_or_expr { $$ = newNode('|',$1,$3);}
 372    ;
 373
 374 logical_and_expr
 375    : inclusive_or_expr
 376    | logical_and_expr AND_OP inclusive_or_expr
 377                                  { $$ = newNode(AND_OP,$1,$3);}
 378    ;
 379
 380 logical_or_expr
 381    : logical_and_expr
 382    | logical_or_expr OR_OP logical_and_expr
 383                                  { $$ = newNode(OR_OP,$1,$3); }
 384    ;
 385
 386 conditional_expr
 387    : logical_or_expr
 388    | logical_or_expr '?' logical_or_expr ':' conditional_expr
 389                      {
 390                         $$ = newNode(':',$3,$5) ;
 391                         $$ = newNode('?',$1,$$) ;
 392                      }
 393    ;
 394
 395 assignment_expr
 396    : conditional_expr
 397    | unary_expr assignment_operator assignment_expr
 398                      {
 399
 400                              switch ($2) {
 401                              case '=':
 402                                      $$ = newNode($2,$1,$3);
 403                                      break;
 404                              case MUL_ASSIGN:
 405                                      $$ = newNode('=',removePostIncDecOps(copyAst($1)),
 406                                                       newNode('*',removePreIncDecOps(copyAst($1)),$3));
 407                                      break;
 408                              case DIV_ASSIGN:
 409                                      $$ = newNode('=',removePostIncDecOps(copyAst($1)),
 410                                                       newNode('/',removePreIncDecOps(copyAst($1)),$3));
 411                                      break;
 412                              case MOD_ASSIGN:
 413                                      $$ = newNode('=',removePostIncDecOps(copyAst($1)),
 414                                                       newNode('%',removePreIncDecOps(copyAst($1)),$3));
 415                                      break;
 416                              case ADD_ASSIGN:
 417                                      $$ = newNode('=',removePostIncDecOps(copyAst($1)),
 418                                                       newNode('+',removePreIncDecOps(copyAst($1)),$3));
 419                                      break;
 420                              case SUB_ASSIGN:
 421                                      $$ = newNode('=',removePostIncDecOps(copyAst($1)),
 422                                                       newNode('-',removePreIncDecOps(copyAst($1)),$3));
 423                                      break;
 424                              case LEFT_ASSIGN:
 425                                      $$ = newNode('=',removePostIncDecOps(copyAst($1)),
 426                                                       newNode(LEFT_OP,removePreIncDecOps(copyAst($1)),$3));
 427                                      break;
 428                              case RIGHT_ASSIGN:
 429                                      $$ = newNode('=',removePostIncDecOps(copyAst($1)),
 430                                                       newNode(RIGHT_OP,removePreIncDecOps(copyAst($1)),$3));
 431                                      break;
 432                              case AND_ASSIGN:
 433                                      $$ = newNode('=',removePostIncDecOps(copyAst($1)),
 434                                                       newNode('&',removePreIncDecOps(copyAst($1)),$3));
 435                                      break;
 436                              case XOR_ASSIGN:
 437                                      $$ = newNode('=',removePostIncDecOps(copyAst($1)),
 438                                                       newNode('^',removePreIncDecOps(copyAst($1)),$3));
 439                                      break;
 440                              case OR_ASSIGN:
 441                                      /* $$ = newNode('=',$1,newNode('|',removeIncDecOps(copyAst($1)),$3)); */
 442                                      $$ = newNode('=',removePostIncDecOps(copyAst($1)),
 443                                                       newNode('|',removePreIncDecOps(copyAst($1)),$3));
 444                                      break;
 445                              default :
 446                                      $$ = NULL;
 447                              }
 448
 449                      }
 450 ;
 451
 452 assignment_operator
 453    : '='             { $$ = '=' ;}
 454    | MUL_ASSIGN
 455    | DIV_ASSIGN
 456    | MOD_ASSIGN
 457    | ADD_ASSIGN
 458    | SUB_ASSIGN
 459    | LEFT_ASSIGN
 460    | RIGHT_ASSIGN
 461    | AND_ASSIGN
 462    | XOR_ASSIGN
 463    | OR_ASSIGN
 464    ;
 465
 466 expr
 467    : assignment_expr
 468    | expr ',' assignment_expr { $$ = newNode(',',$1,$3);}
 469    ;
 470
 471 constant_expr
 472    : conditional_expr
 473    ;
 474
 475 declaration
 476    : declaration_specifiers ';'
 477       {
 478          if (uselessDecl)
 479            werror(W_USELESS_DECL);
 480          uselessDecl = TRUE;
 481          $$ = NULL ;
 482       }
 483    | declaration_specifiers init_declarator_list ';'
 484       {
 485          /* add the specifier list to the id */
 486          symbol *sym , *sym1;
 487
 488          for (sym1 = sym = reverseSyms($2);sym != NULL;sym = sym->next) {
 489              sym_link *lnk = copyLinkChain($1);
 490              /* do the pointer stuff */
 491              pointerTypes(sym->type,lnk);
 492              addDecl (sym,0,lnk) ;
 493          }
 494
 495          uselessDecl = TRUE;
 496          $$ = sym1 ;
 497       }
 498    ;
 499
 500 declaration_specifiers
 501    : storage_class_specifier                                            { $$ = $1; }
 502    | storage_class_specifier declaration_specifiers {
 503      /* if the decl $2 is not a specifier */
 504      /* find the spec and replace it      */
 505      if ( !IS_SPEC($2)) {
 506        sym_link *lnk = $2 ;
 507        while (lnk && !IS_SPEC(lnk->next))
 508          lnk = lnk->next;
 509        lnk->next = mergeSpec($1,lnk->next, "storage_class_specifier declaration_specifiers - skipped");
 510        $$ = $2 ;
 511      }
 512      else
 513        $$ = mergeSpec($1,$2, "storage_class_specifier declaration_specifiers");
 514    }
 515    | type_specifier                                 { $$ = $1; }
 516    | type_specifier declaration_specifiers          {
 517      /* if the decl $2 is not a specifier */
 518      /* find the spec and replace it      */
 519      if ( !IS_SPEC($2)) {
 520        sym_link *lnk = $2 ;
 521        while (lnk && !IS_SPEC(lnk->next))
 522          lnk = lnk->next;
 523        lnk->next = mergeSpec($1,lnk->next, "type_specifier declaration_specifiers - skipped");
 524        $$ = $2 ;
 525      }
 526      else
 527        $$ = mergeSpec($1,$2, "type_specifier declaration_specifiers");
 528    }
 529    ;
 530
 531 init_declarator_list
 532    : init_declarator
 533    | init_declarator_list ',' init_declarator      { $3->next = $1 ; $$ = $3;}
 534    ;
 535
 536 init_declarator
 537    : declarator                  { $1->ival = NULL ; }
 538    | declarator '=' initializer  { $1->ival = $3   ; }
 539    ;
 540
 541
 542 storage_class_specifier
 543    : TYPEDEF   {
 544                   $$ = newLink (SPECIFIER) ;
 545                   SPEC_TYPEDEF($$) = 1 ;
 546                }
 547    | EXTERN    {
 548                   $$ = newLink(SPECIFIER);
 549                   SPEC_EXTR($$) = 1 ;
 550                }
 551    | STATIC    {
 552                   $$ = newLink (SPECIFIER);
 553                   SPEC_STAT($$) = 1 ;
 554                }
 555    | AUTO      {
 556                   $$ = newLink (SPECIFIER) ;
 557                   SPEC_SCLS($$) = S_AUTO  ;
 558                }
 559    | REGISTER  {
 560                   $$ = newLink (SPECIFIER);
 561                   SPEC_SCLS($$) = S_REGISTER ;
 562                }
 563    ;
 564
 565 Interrupt_storage
 566    : INTERRUPT { $$ = INTNO_UNSPEC ; }
 567    | INTERRUPT CONSTANT
 568         { int intno = (int) floatFromVal($2);
 569           if ((intno >= 0) && (intno <= INTNO_MAX))
 570             $$ = intno;
 571           else
 572             {
 573               werror(E_INT_BAD_INTNO, intno);
 574               $$ = INTNO_UNSPEC;
 575             }
 576         }
 577    ;
 578
 579 type_specifier
 580    : type_specifier2
 581    | type_specifier2 AT constant_expr
 582         {
 583            /* add this to the storage class specifier  */
 584            SPEC_ABSA($1) = 1;   /* set the absolute addr flag */
 585            /* now get the abs addr from value */
 586            SPEC_ADDR($1) = (int) floatFromVal(constExprValue($3,TRUE)) ;
 587         }
 588    ;
 589
 590 type_specifier2
 591    : CHAR   {
 592                $$=newLink(SPECIFIER);
 593                SPEC_NOUN($$) = V_CHAR  ;
 594             }
 595    | SHORT  {
 596                $$=newLink(SPECIFIER);
 597                $$->select.s._short = 1 ;
 598             }
 599    | INT    {
 600                $$=newLink(SPECIFIER);
 601                SPEC_NOUN($$) = V_INT   ;
 602             }
 603    | LONG   {
 604                $$=newLink(SPECIFIER);
 605                SPEC_LONG($$) = 1       ;
 606             }
 607    | SIGNED {
 608                $$=newLink(SPECIFIER);
 609                $$->select.s._signed = 1;
 610             }
 611    | UNSIGNED  {
 612                $$=newLink(SPECIFIER);
 613                SPEC_USIGN($$) = 1      ;
 614             }
 615    | VOID   {
 616                $$=newLink(SPECIFIER);
 617                SPEC_NOUN($$) = V_VOID  ;
 618             }
 619    | CONST  {
 620                $$=newLink(SPECIFIER);
 621                SPEC_CONST($$) = 1;
 622             }
 623    | VOLATILE  {
 624                $$=newLink(SPECIFIER);
 625                SPEC_VOLATILE($$) = 1 ;
 626             }
 627    | FLOAT  {
 628                $$=newLink(SPECIFIER);
 629                SPEC_NOUN($$) = V_FLOAT;
 630             }
 631    | XDATA     {
 632                   $$ = newLink (SPECIFIER);
 633                   SPEC_SCLS($$) = S_XDATA  ;
 634                }
 635    | CODE      {
 636                   $$ = newLink (SPECIFIER) ;
 637                   SPEC_SCLS($$) = S_CODE ;
 638                }
 639    | EEPROM      {
 640                   $$ = newLink (SPECIFIER) ;
 641                   SPEC_SCLS($$) = S_EEPROM ;
 642                }
 643    | DATA      {
 644                   $$ = newLink (SPECIFIER);
 645                   SPEC_SCLS($$) = S_DATA   ;
 646                }
 647    | IDATA     {
 648                   $$ = newLink (SPECIFIER);
 649                   SPEC_SCLS($$) = S_IDATA  ;
 650                }
 651    | PDATA     {
 652                   $$ = newLink (SPECIFIER);
 653                   SPEC_SCLS($$) = S_PDATA  ;
 654                }
 655    | BIT    {
 656                $$=newLink(SPECIFIER);
 657                SPEC_NOUN($$) = V_BIT   ;
 658                SPEC_SCLS($$) = S_BIT   ;
 659                SPEC_BLEN($$) = 1;
 660                SPEC_BSTR($$) = 0;
 661             }
 662
 663    | struct_or_union_specifier  {
 664                                    uselessDecl = FALSE;
 665                                    $$ = $1 ;
 666                                 }
 667    | enum_specifier     {
 668                            cenum = NULL ;
 669                            uselessDecl = FALSE;
 670                            $$ = $1 ;
 671                         }
 672    | TYPE_NAME
 673          {
 674             symbol *sym;
 675             sym_link   *p  ;
 676             sym = findSym(TypedefTab,NULL,$1) ;
 677             $$ = p = copyLinkChain(sym->type);
 678             SPEC_TYPEDEF(getSpec(p)) = 0;
 679          }
 680    | sfr_reg_bit
 681    ;
 682
 683 sfr_reg_bit
 684    :  SBIT  {
 685                $$ = newLink(SPECIFIER) ;
 686                SPEC_NOUN($$) = V_SBIT;
 687                SPEC_SCLS($$) = S_SBIT;
 688             }
 689    |  SFR   {
 690                $$ = newLink(SPECIFIER) ;
 691                SPEC_NOUN($$) = V_CHAR;
 692                SPEC_SCLS($$) = S_SFR ;
 693                SPEC_USIGN($$) = 1 ;
 694             }
 695    ;
 696
 697 struct_or_union_specifier
 698    : struct_or_union opt_stag '{' struct_declaration_list '}'
 699         {
 700            structdef *sdef ;
 701            symbol *sym, *dsym;
 702
 703            // check for duplicate structure members
 704            for (sym=$4; sym; sym=sym->next) {
 705              for (dsym=sym->next; dsym; dsym=dsym->next) {
 706                if (strcmp(sym->name, dsym->name)==0) {
 707                  werror(E_DUPLICATE_MEMBER,
 708                         $1==STRUCT ? "struct" : "union", sym->name);
 709                }
 710              }
 711            }
 712
 713            /* Create a structdef   */
 714            sdef = $2 ;
 715            sdef->fields   = reverseSyms($4) ;   /* link the fields */
 716            sdef->size  = compStructSize($1,sdef);   /* update size of  */
 717
 718            /* Create the specifier */
 719            $$ = newLink (SPECIFIER) ;
 720            SPEC_NOUN($$) = V_STRUCT;
 721            SPEC_STRUCT($$)= sdef ;
 722         }
 723    | struct_or_union stag
 724          {
 725             $$ = newLink(SPECIFIER) ;
 726             SPEC_NOUN($$) = V_STRUCT;
 727             SPEC_STRUCT($$) = $2 ;
 728          }
 729    ;
 730
 731 struct_or_union
 732    : STRUCT          { $$ = STRUCT ; }
 733    | UNION           { $$ = UNION  ; }
 734    ;
 735
 736 opt_stag
 737 : stag
 738 |  {  /* synthesize a name add to structtable */
 739      $$ = newStruct(genSymName(NestLevel)) ;
 740      $$->level = NestLevel ;
 741      addSym (StructTab, $$, $$->tag,$$->level,currBlockno, 0);
 742 };
 743
 744 stag
 745 :  identifier  {  /* add name to structure table */
 746      $$ = findSymWithBlock (StructTab,$1,currBlockno);
 747      if (! $$ ) {
 748        $$ = newStruct($1->name) ;
 749        $$->level = NestLevel ;
 750        addSym (StructTab, $$, $$->tag,$$->level,currBlockno,0);
 751      }
 752 };
 753
 754
 755 struct_declaration_list
 756    : struct_declaration
 757    | struct_declaration_list struct_declaration
 758        {
 759            symbol *sym=$2;
 760
 761            /* go to the end of the chain */
 762            while (sym->next) sym=sym->next;
 763            sym->next = $1 ;
 764
 765            $$ = $2;
 766        }
 767    ;
 768
 769 struct_declaration
 770    : type_specifier_list struct_declarator_list ';'
 771        {
 772            /* add this type to all the symbols */
 773            symbol *sym ;
 774            for ( sym = $2 ; sym != NULL ; sym = sym->next ) {
 775
 776                /* make the symbol one level up */
 777                sym->level-- ;
 778
 779                pointerTypes(sym->type,copyLinkChain($1));
 780                if (!sym->type) {
 781                    sym->type = copyLinkChain($1);
 782                    sym->etype = getSpec(sym->type);
 783                }
 784                else
 785                  addDecl (sym,0,copyLinkChain($1));
 786                /* make sure the type is complete and sane */
 787                checkTypeSanity(sym->etype, sym->name);
 788            }
 789            $$ = $2;
 790        }
 791    ;
 792
 793 struct_declarator_list
 794    : struct_declarator
 795    | struct_declarator_list ',' struct_declarator
 796        {
 797            $3->next  = $1 ;
 798            $$ = $3 ;
 799        }
 800    ;
 801
 802 struct_declarator
 803    : declarator
 804    | ':' constant_expr  {
 805                            int bitsize;
 806                            $$ = newSymbol (genSymName(NestLevel),NestLevel) ;
 807                            bitsize= (int) floatFromVal(constExprValue($2,TRUE));
 808                            if (bitsize > (port->s.int_size * 8)) {
 809                              bitsize = port->s.int_size * 8;
 810                              werror(E_BITFLD_SIZE, bitsize);
 811                            }
 812                            if (!bitsize)
 813                              bitsize = BITVAR_PAD;
 814                            $$->bitVar = bitsize;
 815                         }
 816    | declarator ':' constant_expr
 817                         {
 818                           int bitsize;
 819                           bitsize= (int) floatFromVal(constExprValue($3,TRUE));
 820                           if (bitsize > (port->s.int_size * 8)) {
 821                             bitsize = port->s.int_size * 8;
 822                             werror(E_BITFLD_SIZE, bitsize);
 823                           }
 824                           if (!bitsize) {
 825                             $$ = newSymbol (genSymName(NestLevel),NestLevel) ;
 826                             $$->bitVar = BITVAR_PAD;
 827                             werror(W_BITFLD_NAMED);
 828                           }
 829                           else
 830                             $1->bitVar = bitsize;
 831                         }
 832    ;
 833
 834 enum_specifier
 835    : ENUM            '{' enumerator_list '}' {
 836            symbol *sym, *dsym;
 837            char _error=0;
 838
 839            // check for duplicate enums
 840            for (sym=$3; sym; sym=sym->next) {
 841              for (dsym=sym->next; dsym; dsym=dsym->next) {
 842                if (strcmp(sym->name, dsym->name)==0) {
 843                  werror(E_DUPLICATE_MEMBER, "enum", sym->name);
 844                  _error++;
 845                }
 846              }
 847            }
 848            if (_error==0) {
 849              $$ = copyLinkChain(cenum->type);
 850            } else {
 851              $$ = newIntLink();
 852              SPEC_NOUN($$)=0;
 853            }
 854          }
 855
 856    | ENUM identifier '{' enumerator_list '}' {
 857      symbol *csym ;
 858
 859      $2->type = copyLinkChain(cenum->type);
 860      $2->etype = getSpec($2->type);
 861      /* add this to the enumerator table */
 862      if (!(csym=findSym(enumTab,$2,$2->name)) &&
 863          (csym && csym->level == $2->level))
 864        werror(E_DUPLICATE_TYPEDEF,csym->name);
 865
 866      addSym ( enumTab,$2,$2->name,$2->level,$2->block, 0);
 867      //addSymChain ($4);
 868      //allocVariables (reverseSyms($4));
 869      $$ = copyLinkChain(cenum->type);
 870      SPEC_SCLS(getSpec($$)) = 0 ;
 871    }
 872    | ENUM identifier                         {
 873      symbol *csym ;
 874
 875      /* check the enumerator table */
 876      if ((csym = findSym(enumTab,$2,$2->name)))
 877        $$ = copyLinkChain(csym->type);
 878      else  {
 879        $$ = newLink(SPECIFIER) ;
 880        SPEC_NOUN($$) = V_INT   ;
 881      }
 882
 883      SPEC_SCLS(getSpec($$)) = 0 ;
 884    }
 885    ;
 886
 887 enumerator_list
 888    : enumerator
 889    | enumerator_list ',' {
 890                          }
 891    | enumerator_list ',' enumerator {
 892                                        $3->next = $1 ;
 893                                        $$ = $3  ;
 894                                     }
 895    ;
 896
 897 enumerator
 898    : identifier opt_assign_expr
 899      {
 900        /* make the symbol one level up */
 901        $1->level-- ;
 902        $1->type = copyLinkChain($2->type);
 903        $1->etype= getSpec($1->type);
 904        SPEC_ENUM($1->etype) = 1;
 905        $$ = $1 ;
 906        // do this now, so we can use it for the next enums in the list
 907        addSymChain($1);
 908      }
 909    ;
 910
 911 opt_assign_expr
 912    :  '='   constant_expr  {
 913                               value *val ;
 914
 915                               val = constExprValue($2,TRUE);
 916                               $$ = cenum = val ;
 917                            }
 918    |                       {
 919                               if (cenum)  {
 920                                  SNPRINTF(lbuff, sizeof(lbuff),
 921                                           "%d",(int) floatFromVal(cenum)+1);
 922                                  $$ = cenum = constVal(lbuff);
 923                               }
 924                               else {
 925                                  SNPRINTF(lbuff, sizeof(lbuff),
 926                                           "%d",0);
 927                                  $$ = cenum = constVal(lbuff);
 928                               }
 929                            }
 930    ;
 931
 932 declarator
 933    : declarator2_function_attributes    { $$ = $1; }
 934    | pointer declarator2_function_attributes
 935          {
 936              addDecl ($2,0,reverseLink($1));
 937              $$ = $2 ;
 938          }
 939    ;
 940
 941 declarator2_function_attributes
 942    : declarator2                  { $$ = $1 ; }
 943    | declarator2 function_attribute  {
 944        if ((! $1) || (! IS_FUNC($1->etype)))
 945          {
 946            // function_attribute is only allowed if declarator2 was
 947            // an actual function
 948            werror(E_FUNC_ATTR);
 949            $$=$1;
 950          }
 951        else
 952          {
 953            // copy the functionAttributes (not the args and hasVargs !!)
 954            sym_link *funcType=$1->etype;
 955            struct value *args=FUNC_ARGS(funcType);
 956            unsigned hasVargs=FUNC_HASVARARGS(funcType);
 957
 958            memcpy (&funcType->funcAttrs, &$2->funcAttrs,
 959                sizeof($2->funcAttrs));
 960
 961            FUNC_ARGS(funcType)=args;
 962            FUNC_HASVARARGS(funcType)=hasVargs;
 963
 964            // just to be sure
 965            memset (&$2->funcAttrs, 0,
 966                sizeof($2->funcAttrs));
 967
 968            addDecl ($1,0,$2);
 969          }
 970    }
 971    ;
 972
 973 declarator2
 974    : identifier
 975    | '(' declarator ')'     { $$ = $2; }
 976    | declarator2 '[' ']'
 977          {
 978             sym_link   *p;
 979
 980             p = newLink (DECLARATOR);
 981             DCL_TYPE(p) = ARRAY ;
 982             DCL_ELEM(p) = 0     ;
 983             addDecl($1,0,p);
 984          }
 985    | declarator2 '[' constant_expr ']'
 986          {
 987             sym_link   *p ;
 988                         value *tval;
 989
 990             tval = constExprValue($3,TRUE);
 991             /* if it is not a constant then Error  */
 992             p = newLink (DECLARATOR);
 993             DCL_TYPE(p) = ARRAY ;
 994             if ( !tval || (SPEC_SCLS(tval->etype) != S_LITERAL)) {
 995                werror(E_CONST_EXPECTED) ;
 996                /* Assume a single item array to limit the cascade */
 997                /* of additional errors. */
 998                DCL_ELEM(p) = 1;
 999             }
1000             else {
1001                DCL_ELEM(p) = (int) floatFromVal(tval) ;
1002             }
1003             addDecl($1,0,p);
1004          }
1005    | declarator2 '('  ')'       {  addDecl ($1,FUNCTION,NULL) ;   }
1006    | declarator2 '(' { NestLevel++ ; currBlockno++; } parameter_type_list ')'
1007          {
1008
1009              addDecl ($1,FUNCTION,NULL) ;
1010
1011              FUNC_HASVARARGS($1->type) = IS_VARG($4);
1012              FUNC_ARGS($1->type) = reverseVal($4);
1013
1014              /* nest level was incremented to take care of the parms  */
1015              NestLevel-- ;
1016              currBlockno--;
1017
1018              // if this was a pointer (to a function)
1019              if (IS_PTR($1->type)) {
1020                // move the args and hasVargs to the function
1021                FUNC_ARGS($1->etype)=FUNC_ARGS($1->type);
1022                FUNC_HASVARARGS($1->etype)=FUNC_HASVARARGS($1->type);
1023                memset (&$1->type->funcAttrs, 0,
1024                        sizeof($1->type->funcAttrs));
1025                // remove the symbol args (if any)
1026                cleanUpLevel(SymbolTab,NestLevel+1);
1027              }
1028
1029              $$ = $1;
1030          }
1031    | declarator2 '(' parameter_identifier_list ')'
1032          {
1033            werror(E_OLD_STYLE,$1->name) ;
1034
1035            /* assume it returns an int */
1036            $1->type = $1->etype = newIntLink();
1037            $$ = $1 ;
1038          }
1039    ;
1040
1041 pointer
1042    : unqualified_pointer { $$ = $1 ;}
1043    | unqualified_pointer type_specifier_list
1044          {
1045              $$ = $1  ;
1046              DCL_TSPEC($1) = $2;
1047              DCL_PTR_CONST($1) = SPEC_CONST($2);
1048              DCL_PTR_VOLATILE($1) = SPEC_VOLATILE($2);
1049          }
1050    | unqualified_pointer pointer
1051          {
1052              $$ = $1 ;
1053              $$->next = $2 ;
1054              DCL_TYPE($2)=port->unqualified_pointer;
1055          }
1056    | unqualified_pointer type_specifier_list pointer
1057          {
1058              $$ = $1 ;
1059              if (IS_SPEC($2) && DCL_TYPE($3) == UPOINTER) {
1060                  DCL_PTR_CONST($1) = SPEC_CONST($2);
1061                  DCL_PTR_VOLATILE($1) = SPEC_VOLATILE($2);
1062                  switch (SPEC_SCLS($2)) {
1063                  case S_XDATA:
1064                      DCL_TYPE($3) = FPOINTER;
1065                      break;
1066                  case S_IDATA:
1067                      DCL_TYPE($3) = IPOINTER ;
1068                      break;
1069                  case S_PDATA:
1070                      DCL_TYPE($3) = PPOINTER ;
1071                      break;
1072                  case S_DATA:
1073                      DCL_TYPE($3) = POINTER ;
1074                      break;
1075                  case S_CODE:
1076                      DCL_TYPE($3) = CPOINTER ;
1077                      break;
1078                  case S_EEPROM:
1079                      DCL_TYPE($3) = EEPPOINTER;
1080                      break;
1081                  default:
1082                    // this could be just "constant"
1083                    // werror(W_PTR_TYPE_INVALID);
1084                      ;
1085                  }
1086              }
1087              else
1088                  werror (W_PTR_TYPE_INVALID);
1089              $$->next = $3 ;
1090          }
1091    ;
1092
1093 unqualified_pointer
1094    :  '*'
1095       {
1096         $$ = newLink(DECLARATOR);
1097         DCL_TYPE($$)=UPOINTER;
1098       }
1099    ;
1100
1101 type_specifier_list
1102    : type_specifier
1103    //| type_specifier_list type_specifier         {  $$ = mergeSpec ($1,$2, "type_specifier_list"); }
1104    | type_specifier_list type_specifier {
1105      /* if the decl $2 is not a specifier */
1106      /* find the spec and replace it      */
1107      if ( !IS_SPEC($2)) {
1108        sym_link *lnk = $2 ;
1109        while (lnk && !IS_SPEC(lnk->next))
1110          lnk = lnk->next;
1111        lnk->next = mergeSpec($1,lnk->next, "type_specifier_list type_specifier skipped");
1112        $$ = $2 ;
1113      }
1114      else
1115        $$ = mergeSpec($1,$2, "type_specifier_list type_specifier");
1116    }
1117    ;
1118
1119 parameter_identifier_list
1120    : identifier_list
1121    | identifier_list ',' ELIPSIS
1122    ;
1123
1124 identifier_list
1125    : identifier
1126    | identifier_list ',' identifier
1127          {
1128            $3->next = $1;
1129            $$ = $3 ;
1130          }
1131    ;
1132
1133 parameter_type_list
1134         : parameter_list
1135         | parameter_list ',' VAR_ARGS { $1->vArgs = 1;}
1136         ;
1137
1138 parameter_list
1139    : parameter_declaration
1140    | parameter_list ',' parameter_declaration
1141          {
1142             $3->next = $1 ;
1143             $$ = $3 ;
1144          }
1145    ;
1146
1147 parameter_declaration
1148    : type_specifier_list declarator
1149                {
1150                   symbol *loop ;
1151                   pointerTypes($2->type,$1);
1152                   addDecl ($2,0,$1);
1153                   for (loop=$2;loop;loop->_isparm=1,loop=loop->next);
1154                   addSymChain ($2);
1155                   $$ = symbolVal($2);
1156                }
1157    | type_name {
1158                   $$ = newValue() ;
1159                   $$->type = $1;
1160                   $$->etype = getSpec($$->type);
1161                }
1162    ;
1163
1164 type_name
1165    : type_specifier_list  { $$ = $1 ;}
1166    | type_specifier_list abstract_declarator
1167                {
1168                  /* go to the end of the list */
1169                  sym_link *p;
1170                  pointerTypes($2,$1);
1171                  for ( p = $2 ; p && p->next ; p=p->next);
1172                  if (!p) {
1173                    werror(E_SYNTAX_ERROR, yytext);
1174                  } else {
1175                    p->next = $1 ;
1176                  }
1177                  $$ = $2 ;
1178                }
1179    ;
1180
1181 abstract_declarator
1182    : pointer { $$ = reverseLink($1); }
1183    | abstract_declarator2
1184    | pointer abstract_declarator2   { $1 = reverseLink($1); $1->next = $2 ; $$ = $1;
1185           if (IS_PTR($1) && IS_FUNC($2))
1186             DCL_TYPE($1) = CPOINTER;
1187         }
1188    ;
1189
1190 abstract_declarator2
1191    : '(' abstract_declarator ')'    { $$ = $2 ; }
1192    | '[' ']'                        {
1193                                        $$ = newLink (DECLARATOR);
1194                                        DCL_TYPE($$) = ARRAY ;
1195                                        DCL_ELEM($$) = 0     ;
1196                                     }
1197    | '[' constant_expr ']'          {
1198                                        value *val ;
1199                                        $$ = newLink (DECLARATOR);
1200                                        DCL_TYPE($$) = ARRAY ;
1201                                        DCL_ELEM($$) = (int) floatFromVal(val = constExprValue($2,TRUE));
1202                                     }
1203    | abstract_declarator2 '[' ']'   {
1204                                        $$ = newLink (DECLARATOR);
1205                                        DCL_TYPE($$) = ARRAY ;
1206                                        DCL_ELEM($$) = 0     ;
1207                                        $$->next = $1 ;
1208                                     }
1209    | abstract_declarator2 '[' constant_expr ']'
1210                                     {
1211                                        value *val ;
1212                                        $$ = newLink (DECLARATOR);
1213                                        DCL_TYPE($$) = ARRAY ;
1214                                        DCL_ELEM($$) = (int) floatFromVal(val = constExprValue($3,TRUE));
1215                                        $$->next = $1 ;
1216                                     }
1217    | '(' ')'                        { $$ = NULL;}
1218    | '(' parameter_type_list ')'    { $$ = NULL;}
1219    | abstract_declarator2 '(' ')' {
1220      // $1 must be a pointer to a function
1221      sym_link *p=newLink(DECLARATOR);
1222      DCL_TYPE(p) = FUNCTION;
1223      if (!$1) {
1224        // ((void (code *) ()) 0) ()
1225        $1=newLink(DECLARATOR);
1226        DCL_TYPE($1)=CPOINTER;
1227        $$ = $1;
1228      }
1229      $1->next=p;
1230    }
1231    | abstract_declarator2 '(' { NestLevel++ ; currBlockno++; } parameter_type_list ')' {
1232        sym_link *p=newLink(DECLARATOR);
1233        DCL_TYPE(p) = FUNCTION;
1234
1235        FUNC_HASVARARGS(p) = IS_VARG($4);
1236        FUNC_ARGS(p) = reverseVal($4);
1237
1238        /* nest level was incremented to take care of the parms  */
1239        NestLevel-- ;
1240        currBlockno--;
1241        p->next = $1;
1242        $$ = p;
1243
1244        // remove the symbol args (if any)
1245        cleanUpLevel(SymbolTab,NestLevel+1);
1246    }
1247    ;
1248
1249 initializer
1250    : assignment_expr                { $$ = newiList(INIT_NODE,$1); }
1251    | '{'  initializer_list '}'      { $$ = newiList(INIT_DEEP,revinit($2)); }
1252    | '{'  initializer_list ',' '}'  { $$ = newiList(INIT_DEEP,revinit($2)); }
1253    ;
1254
1255 initializer_list
1256    : initializer
1257    | initializer_list ',' initializer  {  $3->next = $1; $$ = $3; }
1258    ;
1259
1260 statement
1261    : labeled_statement
1262    | compound_statement
1263    | expression_statement
1264    | selection_statement
1265    | iteration_statement
1266    | jump_statement
1267    | critical_statement
1268    | INLINEASM  ';'      {
1269                             ast *ex = newNode(INLINEASM,NULL,NULL);
1270                             ex->values.inlineasm = strdup($1);
1271                             $$ = ex;
1272                          }
1273    ;
1274
1275 critical
1276    : CRITICAL   {
1277                    inCritical++;
1278                    STACK_PUSH(continueStack,NULL);
1279                    STACK_PUSH(breakStack,NULL);
1280                    $$ = NULL;
1281                 }
1282    ;
1283
1284 critical_statement
1285    : critical statement  {
1286                    STACK_POP(breakStack);
1287                    STACK_POP(continueStack);
1288                    inCritical--;
1289                    $$ = newNode(CRITICAL,$2,NULL);
1290                 }
1291    ;
1292
1293 labeled_statement
1294 //   : identifier ':' statement          {  $$ = createLabel($1,$3);  }
1295    : identifier ':'                    {  $$ = createLabel($1,NULL);  }
1296    | CASE constant_expr ':' statement  {  $$ = createCase(STACK_PEEK(swStk),$2,$4); }
1297    | DEFAULT ':' statement             {  $$ = createDefault(STACK_PEEK(swStk),$3); }
1298    ;
1299
1300 start_block : '{' { STACK_PUSH(blockNum,currBlockno); currBlockno = ++blockNo ;  }
1301             ;
1302
1303 end_block   : '}'     { currBlockno = STACK_POP(blockNum); }
1304             ;
1305
1306 compound_statement
1307    : start_block end_block                    { $$ = createBlock(NULL,NULL); }
1308    | start_block statement_list end_block     { $$ = createBlock(NULL,$2) ;  }
1309    | start_block
1310           declaration_list                    { addSymChain($2); }
1311      end_block                                { $$ = createBlock($2,NULL) ;  }
1312    | start_block
1313           declaration_list                    {  addSymChain ($2); }
1314           statement_list
1315      end_block                                {$$ = createBlock($2,$4)   ;  }
1316    | error ';'                                { $$ = NULL ; }
1317    ;
1318
1319 declaration_list
1320    : declaration
1321      {
1322        /* if this is typedef declare it immediately */
1323        if ( $1 && IS_TYPEDEF($1->etype)) {
1324          allocVariables ($1);
1325          $$ = NULL ;
1326        }
1327        else
1328          $$ = $1 ;
1329      }
1330
1331    | declaration_list declaration
1332      {
1333        symbol   *sym;
1334
1335        /* if this is a typedef */
1336        if ($2 && IS_TYPEDEF($2->etype)) {
1337          allocVariables ($2);
1338          $$ = $1 ;
1339        }
1340        else {
1341                                 /* get to the end of the previous decl */
1342          if ( $1 ) {
1343            $$ = sym = $1 ;
1344            while (sym->next)
1345              sym = sym->next ;
1346            sym->next = $2;
1347          }
1348          else
1349            $$ = $2 ;
1350        }
1351      }
1352    ;
1353
1354 statement_list
1355    : statement
1356    | statement_list statement          {  $$ = newNode(NULLOP,$1,$2) ;}
1357    ;
1358
1359 expression_statement
1360    : ';'                { $$ = NULL;}
1361    | expr ';'
1362    ;
1363
1364 else_statement
1365    :  ELSE  statement   { $$ = $2  ; }
1366    |                    { $$ = NULL;}
1367    ;
1368
1369
1370 selection_statement
1371    : IF '(' expr ')'  statement else_statement { noLineno++ ; $$ = createIf ($3, $5, $6 ); noLineno--;}
1372    | SWITCH '(' expr ')'   {
1373                               ast *ex ;
1374                               static   int swLabel = 0 ;
1375
1376                               /* create a node for expression  */
1377                               ex = newNode(SWITCH,$3,NULL);
1378                               STACK_PUSH(swStk,ex);   /* save it in the stack */
1379                               ex->values.switchVals.swNum = swLabel ;
1380
1381                               /* now create the label */
1382                               SNPRINTF(lbuff, sizeof(lbuff),
1383                                        "_swBrk_%d",swLabel++);
1384                               $<sym>$  =  newSymbol(lbuff,NestLevel);
1385                               /* put label in the break stack  */
1386                               STACK_PUSH(breakStack,$<sym>$);
1387                            }
1388      statement             {
1389                               /* get back the switch form the stack  */
1390                               $$ = STACK_POP(swStk)  ;
1391                               $$->right = newNode (NULLOP,$6,createLabel($<sym>5,NULL));
1392                               STACK_POP(breakStack);
1393                            }
1394         ;
1395
1396 while : WHILE  {  /* create and push the continue , break & body labels */
1397                   static int Lblnum = 0 ;
1398                   /* continue */
1399                   SNPRINTF (lbuff, sizeof(lbuff), "_whilecontinue_%d",Lblnum);
1400                   STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1401                   /* break */
1402                   SNPRINTF (lbuff, sizeof(lbuff), "_whilebreak_%d",Lblnum);
1403                   STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1404                   /* body */
1405                   SNPRINTF (lbuff, sizeof(lbuff), "_whilebody_%d",Lblnum++);
1406                   $$ = newSymbol(lbuff,NestLevel);
1407                }
1408    ;
1409
1410 do : DO {  /* create and push the continue , break & body Labels */
1411            static int Lblnum = 0 ;
1412
1413            /* continue */
1414            SNPRINTF(lbuff, sizeof(lbuff), "_docontinue_%d",Lblnum);
1415            STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1416            /* break */
1417            SNPRINTF(lbuff, sizeof(lbuff), "_dobreak_%d",Lblnum);
1418            STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1419            /* do body */
1420            SNPRINTF(lbuff, sizeof(lbuff), "_dobody_%d",Lblnum++);
1421            $$ = newSymbol (lbuff,NestLevel);
1422         }
1423    ;
1424
1425 for : FOR { /* create & push continue, break & body labels */
1426             static int Lblnum = 0 ;
1427
1428             /* continue */
1429             SNPRINTF(lbuff, sizeof(lbuff), "_forcontinue_%d",Lblnum);
1430             STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1431             /* break    */
1432             SNPRINTF(lbuff, sizeof(lbuff), "_forbreak_%d",Lblnum);
1433             STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1434             /* body */
1435             SNPRINTF(lbuff, sizeof(lbuff), "_forbody_%d",Lblnum);
1436             $$ = newSymbol(lbuff,NestLevel);
1437             /* condition */
1438             SNPRINTF(lbuff, sizeof(lbuff), "_forcond_%d",Lblnum++);
1439             STACK_PUSH(forStack,newSymbol(lbuff,NestLevel));
1440           }
1441    ;
1442
1443 iteration_statement
1444    : while '(' expr ')'  statement
1445                          {
1446                            noLineno++ ;
1447                            $$ = createWhile ( $1, STACK_POP(continueStack),
1448                                               STACK_POP(breakStack), $3, $5 );
1449                            $$->lineno = $1->lineDef ;
1450                            noLineno-- ;
1451                          }
1452    | do statement   WHILE '(' expr ')' ';'
1453                         {
1454                           noLineno++ ;
1455                           $$ = createDo ( $1 , STACK_POP(continueStack),
1456                                           STACK_POP(breakStack), $5, $2);
1457                           $$->lineno = $1->lineDef ;
1458                           noLineno-- ;
1459                         }
1460    | for '(' expr_opt   ';' expr_opt ';' expr_opt ')'  statement
1461                         {
1462                           noLineno++ ;
1463
1464                           /* if break or continue statement present
1465                              then create a general case loop */
1466                           if (STACK_PEEK(continueStack)->isref ||
1467                               STACK_PEEK(breakStack)->isref) {
1468                               $$ = createFor ($1, STACK_POP(continueStack),
1469                                               STACK_POP(breakStack) ,
1470                                               STACK_POP(forStack)   ,
1471                                               $3 , $5 , $7, $9 );
1472                           } else {
1473                               $$ = newNode(FOR,$9,NULL);
1474                               AST_FOR($$,trueLabel) = $1;
1475                               AST_FOR($$,continueLabel) =  STACK_POP(continueStack);
1476                               AST_FOR($$,falseLabel) = STACK_POP(breakStack);
1477                               AST_FOR($$,condLabel)  = STACK_POP(forStack)  ;
1478                               AST_FOR($$,initExpr)   = $3;
1479                               AST_FOR($$,condExpr)   = $5;
1480                               AST_FOR($$,loopExpr)   = $7;
1481                           }
1482
1483                           noLineno-- ;
1484                         }
1485 ;
1486
1487 expr_opt
1488         :                       { $$ = NULL ; }
1489         |       expr
1490         ;
1491
1492 jump_statement
1493    : GOTO identifier ';'   {
1494                               $2->islbl = 1;
1495                               $$ = newAst_VALUE(symbolVal($2));
1496                               $$ = newNode(GOTO,$$,NULL);
1497                            }
1498    | CONTINUE ';'          {
1499        /* make sure continue is in context */
1500        if (STACK_PEEK(continueStack) == NULL) {
1501            werror(E_BREAK_CONTEXT);
1502            $$ = NULL;
1503        }
1504        else {
1505            $$ = newAst_VALUE(symbolVal(STACK_PEEK(continueStack)));
1506            $$ = newNode(GOTO,$$,NULL);
1507            /* mark the continue label as referenced */
1508            STACK_PEEK(continueStack)->isref = 1;
1509        }
1510    }
1511    | BREAK ';'             {
1512        if (STACK_PEEK(breakStack) == NULL) {
1513            werror(E_BREAK_CONTEXT);
1514            $$ = NULL;
1515        } else {
1516            $$ = newAst_VALUE(symbolVal(STACK_PEEK(breakStack)));
1517            $$ = newNode(GOTO,$$,NULL);
1518            STACK_PEEK(breakStack)->isref = 1;
1519        }
1520    }
1521    | RETURN ';'            {
1522        if (inCritical) {
1523            werror(E_INVALID_CRITICAL);
1524            $$ = NULL;
1525        } else {
1526            $$ = newNode(RETURN,NULL,NULL);
1527        }
1528    }
1529    | RETURN expr ';'       {
1530        if (inCritical) {
1531            werror(E_INVALID_CRITICAL);
1532            $$ = NULL;
1533        } else {
1534            $$ = newNode(RETURN,NULL,$2);
1535        }
1536    }
1537    ;
1538
1539 identifier
1540    : IDENTIFIER   { $$ = newSymbol ($1,NestLevel) ; }
1541    ;
1542 %%
1543