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              if (IS_SPEC($2)) {
1047                  DCL_TSPEC($1) = $2;
1048                  DCL_PTR_CONST($1) = SPEC_CONST($2);
1049                  DCL_PTR_VOLATILE($1) = SPEC_VOLATILE($2);
1050              }
1051              else
1052                  werror (W_PTR_TYPE_INVALID);
1053          }
1054    | unqualified_pointer pointer
1055          {
1056              $$ = $1 ;
1057              $$->next = $2 ;
1058              DCL_TYPE($2)=port->unqualified_pointer;
1059          }
1060    | unqualified_pointer type_specifier_list pointer
1061          {
1062              $$ = $1 ;
1063              if (IS_SPEC($2) && DCL_TYPE($3) == UPOINTER) {
1064                  DCL_PTR_CONST($1) = SPEC_CONST($2);
1065                  DCL_PTR_VOLATILE($1) = SPEC_VOLATILE($2);
1066                  switch (SPEC_SCLS($2)) {
1067                  case S_XDATA:
1068                      DCL_TYPE($3) = FPOINTER;
1069                      break;
1070                  case S_IDATA:
1071                      DCL_TYPE($3) = IPOINTER ;
1072                      break;
1073                  case S_PDATA:
1074                      DCL_TYPE($3) = PPOINTER ;
1075                      break;
1076                  case S_DATA:
1077                      DCL_TYPE($3) = POINTER ;
1078                      break;
1079                  case S_CODE:
1080                      DCL_TYPE($3) = CPOINTER ;
1081                      break;
1082                  case S_EEPROM:
1083                      DCL_TYPE($3) = EEPPOINTER;
1084                      break;
1085                  default:
1086                    // this could be just "constant"
1087                    // werror(W_PTR_TYPE_INVALID);
1088                      ;
1089                  }
1090              }
1091              else
1092                  werror (W_PTR_TYPE_INVALID);
1093              $$->next = $3 ;
1094          }
1095    ;
1096
1097 unqualified_pointer
1098    :  '*'
1099       {
1100         $$ = newLink(DECLARATOR);
1101         DCL_TYPE($$)=UPOINTER;
1102       }
1103    ;
1104
1105 type_specifier_list
1106    : type_specifier
1107    //| type_specifier_list type_specifier         {  $$ = mergeSpec ($1,$2, "type_specifier_list"); }
1108    | type_specifier_list type_specifier {
1109      /* if the decl $2 is not a specifier */
1110      /* find the spec and replace it      */
1111      if ( !IS_SPEC($2)) {
1112        sym_link *lnk = $2 ;
1113        while (lnk && !IS_SPEC(lnk->next))
1114          lnk = lnk->next;
1115        lnk->next = mergeSpec($1,lnk->next, "type_specifier_list type_specifier skipped");
1116        $$ = $2 ;
1117      }
1118      else
1119        $$ = mergeSpec($1,$2, "type_specifier_list type_specifier");
1120    }
1121    ;
1122
1123 parameter_identifier_list
1124    : identifier_list
1125    | identifier_list ',' ELIPSIS
1126    ;
1127
1128 identifier_list
1129    : identifier
1130    | identifier_list ',' identifier
1131          {
1132            $3->next = $1;
1133            $$ = $3 ;
1134          }
1135    ;
1136
1137 parameter_type_list
1138         : parameter_list
1139         | parameter_list ',' VAR_ARGS { $1->vArgs = 1;}
1140         ;
1141
1142 parameter_list
1143    : parameter_declaration
1144    | parameter_list ',' parameter_declaration
1145          {
1146             $3->next = $1 ;
1147             $$ = $3 ;
1148          }
1149    ;
1150
1151 parameter_declaration
1152    : type_specifier_list declarator
1153                {
1154                   symbol *loop ;
1155                   pointerTypes($2->type,$1);
1156                   addDecl ($2,0,$1);
1157                   for (loop=$2;loop;loop->_isparm=1,loop=loop->next);
1158                   addSymChain ($2);
1159                   $$ = symbolVal($2);
1160                }
1161    | type_name {
1162                   $$ = newValue() ;
1163                   $$->type = $1;
1164                   $$->etype = getSpec($$->type);
1165                }
1166    ;
1167
1168 type_name
1169    : type_specifier_list  { $$ = $1 ;}
1170    | type_specifier_list abstract_declarator
1171                {
1172                  /* go to the end of the list */
1173                  sym_link *p;
1174                  pointerTypes($2,$1);
1175                  for ( p = $2 ; p && p->next ; p=p->next);
1176                  if (!p) {
1177                    werror(E_SYNTAX_ERROR, yytext);
1178                  } else {
1179                    p->next = $1 ;
1180                  }
1181                  $$ = $2 ;
1182                }
1183    ;
1184
1185 abstract_declarator
1186    : pointer { $$ = reverseLink($1); }
1187    | abstract_declarator2
1188    | pointer abstract_declarator2   { $1 = reverseLink($1); $1->next = $2 ; $$ = $1;
1189           if (IS_PTR($1) && IS_FUNC($2))
1190             DCL_TYPE($1) = CPOINTER;
1191         }
1192    ;
1193
1194 abstract_declarator2
1195    : '(' abstract_declarator ')'    { $$ = $2 ; }
1196    | '[' ']'                        {
1197                                        $$ = newLink (DECLARATOR);
1198                                        DCL_TYPE($$) = ARRAY ;
1199                                        DCL_ELEM($$) = 0     ;
1200                                     }
1201    | '[' constant_expr ']'          {
1202                                        value *val ;
1203                                        $$ = newLink (DECLARATOR);
1204                                        DCL_TYPE($$) = ARRAY ;
1205                                        DCL_ELEM($$) = (int) floatFromVal(val = constExprValue($2,TRUE));
1206                                     }
1207    | abstract_declarator2 '[' ']'   {
1208                                        $$ = newLink (DECLARATOR);
1209                                        DCL_TYPE($$) = ARRAY ;
1210                                        DCL_ELEM($$) = 0     ;
1211                                        $$->next = $1 ;
1212                                     }
1213    | abstract_declarator2 '[' constant_expr ']'
1214                                     {
1215                                        value *val ;
1216                                        $$ = newLink (DECLARATOR);
1217                                        DCL_TYPE($$) = ARRAY ;
1218                                        DCL_ELEM($$) = (int) floatFromVal(val = constExprValue($3,TRUE));
1219                                        $$->next = $1 ;
1220                                     }
1221    | '(' ')'                        { $$ = NULL;}
1222    | '(' parameter_type_list ')'    { $$ = NULL;}
1223    | abstract_declarator2 '(' ')' {
1224      // $1 must be a pointer to a function
1225      sym_link *p=newLink(DECLARATOR);
1226      DCL_TYPE(p) = FUNCTION;
1227      if (!$1) {
1228        // ((void (code *) ()) 0) ()
1229        $1=newLink(DECLARATOR);
1230        DCL_TYPE($1)=CPOINTER;
1231        $$ = $1;
1232      }
1233      $1->next=p;
1234    }
1235    | abstract_declarator2 '(' { NestLevel++ ; currBlockno++; } parameter_type_list ')' {
1236        sym_link *p=newLink(DECLARATOR);
1237        DCL_TYPE(p) = FUNCTION;
1238
1239        FUNC_HASVARARGS(p) = IS_VARG($4);
1240        FUNC_ARGS(p) = reverseVal($4);
1241
1242        /* nest level was incremented to take care of the parms  */
1243        NestLevel-- ;
1244        currBlockno--;
1245        p->next = $1;
1246        $$ = p;
1247
1248        // remove the symbol args (if any)
1249        cleanUpLevel(SymbolTab,NestLevel+1);
1250    }
1251    ;
1252
1253 initializer
1254    : assignment_expr                { $$ = newiList(INIT_NODE,$1); }
1255    | '{'  initializer_list '}'      { $$ = newiList(INIT_DEEP,revinit($2)); }
1256    | '{'  initializer_list ',' '}'  { $$ = newiList(INIT_DEEP,revinit($2)); }
1257    ;
1258
1259 initializer_list
1260    : initializer
1261    | initializer_list ',' initializer  {  $3->next = $1; $$ = $3; }
1262    ;
1263
1264 statement
1265    : labeled_statement
1266    | compound_statement
1267    | expression_statement
1268    | selection_statement
1269    | iteration_statement
1270    | jump_statement
1271    | critical_statement
1272    | INLINEASM  ';'      {
1273                             ast *ex = newNode(INLINEASM,NULL,NULL);
1274                             ex->values.inlineasm = strdup($1);
1275                             $$ = ex;
1276                          }
1277    ;
1278
1279 critical
1280    : CRITICAL   {
1281                    inCritical++;
1282                    STACK_PUSH(continueStack,NULL);
1283                    STACK_PUSH(breakStack,NULL);
1284                    $$ = NULL;
1285                 }
1286    ;
1287
1288 critical_statement
1289    : critical statement  {
1290                    STACK_POP(breakStack);
1291                    STACK_POP(continueStack);
1292                    inCritical--;
1293                    $$ = newNode(CRITICAL,$2,NULL);
1294                 }
1295    ;
1296
1297 labeled_statement
1298 //   : identifier ':' statement          {  $$ = createLabel($1,$3);  }
1299    : identifier ':'                    {  $$ = createLabel($1,NULL);  }
1300    | CASE constant_expr ':' statement  {  $$ = createCase(STACK_PEEK(swStk),$2,$4); }
1301    | DEFAULT ':' statement             {  $$ = createDefault(STACK_PEEK(swStk),$3); }
1302    ;
1303
1304 start_block : '{' { STACK_PUSH(blockNum,currBlockno); currBlockno = ++blockNo ;  }
1305             ;
1306
1307 end_block   : '}'     { currBlockno = STACK_POP(blockNum); }
1308             ;
1309
1310 compound_statement
1311    : start_block end_block                    { $$ = createBlock(NULL,NULL); }
1312    | start_block statement_list end_block     { $$ = createBlock(NULL,$2) ;  }
1313    | start_block
1314           declaration_list                    { addSymChain($2); }
1315      end_block                                { $$ = createBlock($2,NULL) ;  }
1316    | start_block
1317           declaration_list                    {  addSymChain ($2); }
1318           statement_list
1319      end_block                                {$$ = createBlock($2,$4)   ;  }
1320    | error ';'                                { $$ = NULL ; }
1321    ;
1322
1323 declaration_list
1324    : declaration
1325      {
1326        /* if this is typedef declare it immediately */
1327        if ( $1 && IS_TYPEDEF($1->etype)) {
1328          allocVariables ($1);
1329          $$ = NULL ;
1330        }
1331        else
1332          $$ = $1 ;
1333      }
1334
1335    | declaration_list declaration
1336      {
1337        symbol   *sym;
1338
1339        /* if this is a typedef */
1340        if ($2 && IS_TYPEDEF($2->etype)) {
1341          allocVariables ($2);
1342          $$ = $1 ;
1343        }
1344        else {
1345                                 /* get to the end of the previous decl */
1346          if ( $1 ) {
1347            $$ = sym = $1 ;
1348            while (sym->next)
1349              sym = sym->next ;
1350            sym->next = $2;
1351          }
1352          else
1353            $$ = $2 ;
1354        }
1355      }
1356    ;
1357
1358 statement_list
1359    : statement
1360    | statement_list statement          {  $$ = newNode(NULLOP,$1,$2) ;}
1361    ;
1362
1363 expression_statement
1364    : ';'                { $$ = NULL;}
1365    | expr ';'
1366    ;
1367
1368 else_statement
1369    :  ELSE  statement   { $$ = $2  ; }
1370    |                    { $$ = NULL;}
1371    ;
1372
1373
1374 selection_statement
1375    : IF '(' expr ')'  statement else_statement { noLineno++ ; $$ = createIf ($3, $5, $6 ); noLineno--;}
1376    | SWITCH '(' expr ')'   {
1377                               ast *ex ;
1378                               static   int swLabel = 0 ;
1379
1380                               /* create a node for expression  */
1381                               ex = newNode(SWITCH,$3,NULL);
1382                               STACK_PUSH(swStk,ex);   /* save it in the stack */
1383                               ex->values.switchVals.swNum = swLabel ;
1384
1385                               /* now create the label */
1386                               SNPRINTF(lbuff, sizeof(lbuff),
1387                                        "_swBrk_%d",swLabel++);
1388                               $<sym>$  =  newSymbol(lbuff,NestLevel);
1389                               /* put label in the break stack  */
1390                               STACK_PUSH(breakStack,$<sym>$);
1391                            }
1392      statement             {
1393                               /* get back the switch form the stack  */
1394                               $$ = STACK_POP(swStk)  ;
1395                               $$->right = newNode (NULLOP,$6,createLabel($<sym>5,NULL));
1396                               STACK_POP(breakStack);
1397                            }
1398         ;
1399
1400 while : WHILE  {  /* create and push the continue , break & body labels */
1401                   static int Lblnum = 0 ;
1402                   /* continue */
1403                   SNPRINTF (lbuff, sizeof(lbuff), "_whilecontinue_%d",Lblnum);
1404                   STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1405                   /* break */
1406                   SNPRINTF (lbuff, sizeof(lbuff), "_whilebreak_%d",Lblnum);
1407                   STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1408                   /* body */
1409                   SNPRINTF (lbuff, sizeof(lbuff), "_whilebody_%d",Lblnum++);
1410                   $$ = newSymbol(lbuff,NestLevel);
1411                }
1412    ;
1413
1414 do : DO {  /* create and push the continue , break & body Labels */
1415            static int Lblnum = 0 ;
1416
1417            /* continue */
1418            SNPRINTF(lbuff, sizeof(lbuff), "_docontinue_%d",Lblnum);
1419            STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1420            /* break */
1421            SNPRINTF(lbuff, sizeof(lbuff), "_dobreak_%d",Lblnum);
1422            STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1423            /* do body */
1424            SNPRINTF(lbuff, sizeof(lbuff), "_dobody_%d",Lblnum++);
1425            $$ = newSymbol (lbuff,NestLevel);
1426         }
1427    ;
1428
1429 for : FOR { /* create & push continue, break & body labels */
1430             static int Lblnum = 0 ;
1431
1432             /* continue */
1433             SNPRINTF(lbuff, sizeof(lbuff), "_forcontinue_%d",Lblnum);
1434             STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1435             /* break    */
1436             SNPRINTF(lbuff, sizeof(lbuff), "_forbreak_%d",Lblnum);
1437             STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1438             /* body */
1439             SNPRINTF(lbuff, sizeof(lbuff), "_forbody_%d",Lblnum);
1440             $$ = newSymbol(lbuff,NestLevel);
1441             /* condition */
1442             SNPRINTF(lbuff, sizeof(lbuff), "_forcond_%d",Lblnum++);
1443             STACK_PUSH(forStack,newSymbol(lbuff,NestLevel));
1444           }
1445    ;
1446
1447 iteration_statement
1448    : while '(' expr ')'  statement
1449                          {
1450                            noLineno++ ;
1451                            $$ = createWhile ( $1, STACK_POP(continueStack),
1452                                               STACK_POP(breakStack), $3, $5 );
1453                            $$->lineno = $1->lineDef ;
1454                            noLineno-- ;
1455                          }
1456    | do statement   WHILE '(' expr ')' ';'
1457                         {
1458                           noLineno++ ;
1459                           $$ = createDo ( $1 , STACK_POP(continueStack),
1460                                           STACK_POP(breakStack), $5, $2);
1461                           $$->lineno = $1->lineDef ;
1462                           noLineno-- ;
1463                         }
1464    | for '(' expr_opt   ';' expr_opt ';' expr_opt ')'  statement
1465                         {
1466                           noLineno++ ;
1467
1468                           /* if break or continue statement present
1469                              then create a general case loop */
1470                           if (STACK_PEEK(continueStack)->isref ||
1471                               STACK_PEEK(breakStack)->isref) {
1472                               $$ = createFor ($1, STACK_POP(continueStack),
1473                                               STACK_POP(breakStack) ,
1474                                               STACK_POP(forStack)   ,
1475                                               $3 , $5 , $7, $9 );
1476                           } else {
1477                               $$ = newNode(FOR,$9,NULL);
1478                               AST_FOR($$,trueLabel) = $1;
1479                               AST_FOR($$,continueLabel) =  STACK_POP(continueStack);
1480                               AST_FOR($$,falseLabel) = STACK_POP(breakStack);
1481                               AST_FOR($$,condLabel)  = STACK_POP(forStack)  ;
1482                               AST_FOR($$,initExpr)   = $3;
1483                               AST_FOR($$,condExpr)   = $5;
1484                               AST_FOR($$,loopExpr)   = $7;
1485                           }
1486
1487                           noLineno-- ;
1488                         }
1489 ;
1490
1491 expr_opt
1492         :                       { $$ = NULL ; }
1493         |       expr
1494         ;
1495
1496 jump_statement
1497    : GOTO identifier ';'   {
1498                               $2->islbl = 1;
1499                               $$ = newAst_VALUE(symbolVal($2));
1500                               $$ = newNode(GOTO,$$,NULL);
1501                            }
1502    | CONTINUE ';'          {
1503        /* make sure continue is in context */
1504        if (STACK_PEEK(continueStack) == NULL) {
1505            werror(E_BREAK_CONTEXT);
1506            $$ = NULL;
1507        }
1508        else {
1509            $$ = newAst_VALUE(symbolVal(STACK_PEEK(continueStack)));
1510            $$ = newNode(GOTO,$$,NULL);
1511            /* mark the continue label as referenced */
1512            STACK_PEEK(continueStack)->isref = 1;
1513        }
1514    }
1515    | BREAK ';'             {
1516        if (STACK_PEEK(breakStack) == NULL) {
1517            werror(E_BREAK_CONTEXT);
1518            $$ = NULL;
1519        } else {
1520            $$ = newAst_VALUE(symbolVal(STACK_PEEK(breakStack)));
1521            $$ = newNode(GOTO,$$,NULL);
1522            STACK_PEEK(breakStack)->isref = 1;
1523        }
1524    }
1525    | RETURN ';'            {
1526        if (inCritical) {
1527            werror(E_INVALID_CRITICAL);
1528            $$ = NULL;
1529        } else {
1530            $$ = newNode(RETURN,NULL,NULL);
1531        }
1532    }
1533    | RETURN expr ';'       {
1534        if (inCritical) {
1535            werror(E_INVALID_CRITICAL);
1536            $$ = NULL;
1537        } else {
1538            $$ = newNode(RETURN,NULL,$2);
1539        }
1540    }
1541    ;
1542
1543 identifier
1544    : IDENTIFIER   { $$ = newSymbol ($1,NestLevel) ; }
1545    ;
1546 %%
1547