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