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