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_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 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     { 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    : unqualified_pointer { $$ = $1 ;}
 937    | unqualified_pointer type_specifier_list
 938          {
 939              $$ = $1  ;
 940              DCL_TSPEC($1) = $2;
 941          }
 942    | unqualified_pointer pointer
 943          {
 944              $$ = $1 ;
 945              $$->next = $2 ;
 946              DCL_TYPE($2)=GPOINTER;
 947          }
 948    | unqualified_pointer type_specifier_list pointer
 949          {
 950              $$ = $1 ;
 951              if (IS_SPEC($2) && DCL_TYPE($3) == UPOINTER) {
 952                  DCL_PTR_CONST($1) = SPEC_CONST($2);
 953                  DCL_PTR_VOLATILE($1) = SPEC_VOLATILE($2);
 954                  switch (SPEC_SCLS($2)) {
 955                  case S_XDATA:
 956                      DCL_TYPE($3) = FPOINTER;
 957                      break;
 958                  case S_IDATA:
 959                      DCL_TYPE($3) = IPOINTER ;
 960                      break;
 961                  case S_PDATA:
 962                      DCL_TYPE($3) = PPOINTER ;
 963                      break;
 964                  case S_DATA:
 965                      DCL_TYPE($3) = POINTER ;
 966                      break;
 967                  case S_CODE:
 968                      DCL_PTR_CONST($3) = 1;
 969                      DCL_TYPE($3) = CPOINTER ;
 970                      break;
 971                  case S_EEPROM:
 972                      DCL_TYPE($3) = EEPPOINTER;
 973                      break;
 974                  default:
 975                      werror(W_PTR_TYPE_INVALID);
 976                  }
 977              }
 978              else
 979                  werror (W_PTR_TYPE_INVALID);
 980              $$->next = $3 ;
 981          }
 982    ;
 983
 984 unqualified_pointer
 985    :  '*'
 986       {
 987         $$ = newLink();
 988         DCL_TYPE($$)=UPOINTER;
 989       }
 990    ;
 991
 992 type_specifier_list
 993    : type_specifier
 994    | type_specifier_list type_specifier         {  $$ = mergeSpec ($1,$2, "type_specifier_list"); }
 995    ;
 996
 997 parameter_identifier_list
 998    : identifier_list
 999    | identifier_list ',' ELIPSIS
1000    ;
1001
1002 identifier_list
1003    : identifier
1004    | identifier_list ',' identifier
1005          {
1006            $3->next = $1;
1007            $$ = $3 ;
1008          }
1009    ;
1010
1011 parameter_type_list
1012         : parameter_list
1013         | parameter_list ',' VAR_ARGS { $1->vArgs = 1;}
1014         ;
1015
1016 parameter_list
1017    : parameter_declaration
1018    | parameter_list ',' parameter_declaration
1019          {
1020             $3->next = $1 ;
1021             $$ = $3 ;
1022          }
1023    ;
1024
1025 parameter_declaration
1026    : type_specifier_list declarator
1027                {
1028                   symbol *loop ;
1029                   pointerTypes($2->type,$1);
1030                   addDecl ($2,0,$1);
1031                   for (loop=$2;loop;loop->_isparm=1,loop=loop->next);
1032                   addSymChain ($2);
1033                   $$ = symbolVal($2);
1034                }
1035    | type_name {
1036                   $$ = newValue() ;
1037                   $$->type = $1;
1038                   $$->etype = getSpec($$->type);
1039                }
1040    ;
1041
1042 type_name
1043    : type_specifier_list  { $$ = $1 ;}
1044    | type_specifier_list abstract_declarator
1045                {
1046                  /* go to the end of the list */
1047                  sym_link *p;
1048                  pointerTypes($2,$1);
1049                  for ( p = $2 ; p->next ; p=p->next);
1050                   p->next = $1 ;
1051                   $$ = $2 ;
1052                }
1053    ;
1054
1055 abstract_declarator
1056    : pointer { $$ = reverseLink($1); }
1057    | abstract_declarator2
1058    | pointer abstract_declarator2   { $1 = reverseLink($1); $1->next = $2 ; $$ = $1;}
1059    ;
1060
1061 abstract_declarator2
1062    : '(' abstract_declarator ')'    { $$ = $2 ; }
1063    | '[' ']'                        {
1064                                        $$ = newLink ();
1065                                        DCL_TYPE($$) = ARRAY ;
1066                                        DCL_ELEM($$) = 0     ;
1067                                     }
1068    | '[' constant_expr ']'          {
1069                                        value *val ;
1070                                        $$ = newLink ();
1071                                        DCL_TYPE($$) = ARRAY ;
1072                                        DCL_ELEM($$) = (int) floatFromVal(val = constExprValue($2,TRUE));
1073                                     }
1074    | abstract_declarator2 '[' ']'   {
1075                                        $$ = newLink ();
1076                                        DCL_TYPE($$) = ARRAY ;
1077                                        DCL_ELEM($$) = 0     ;
1078                                        $$->next = $1 ;
1079                                     }
1080    | abstract_declarator2 '[' constant_expr ']'
1081                                     {
1082                                        value *val ;
1083                                        $$ = newLink ();
1084                                        DCL_TYPE($$) = ARRAY ;
1085                                        DCL_ELEM($$) = (int) floatFromVal(val = constExprValue($3,TRUE));
1086                                        $$->next = $1 ;
1087                                     }
1088    | '(' ')'                        { $$ = NULL;}
1089    | '(' parameter_type_list ')'    { $$ = NULL;}
1090    | abstract_declarator2 '(' ')' {
1091      // $1 must be a pointer to a function
1092      sym_link *p=newLink();
1093      DCL_TYPE(p) = FUNCTION;
1094      $1->next=p;
1095    }
1096    | abstract_declarator2 '(' parameter_type_list ')' {
1097      if (!IS_VOID($3->type)) {
1098        // this is nonsense, so let's just burp something
1099        werror(E_TOO_FEW_PARMS);
1100      } else {
1101        // $1 must be a pointer to a function
1102        sym_link *p=newLink();
1103        DCL_TYPE(p) = FUNCTION;
1104        $1->next=p;
1105      }
1106    }
1107
1108 initializer
1109    : assignment_expr                { $$ = newiList(INIT_NODE,$1); }
1110    | '{'  initializer_list '}'      { $$ = newiList(INIT_DEEP,revinit($2)); }
1111    | '{'  initializer_list ',' '}'  { $$ = newiList(INIT_DEEP,revinit($2)); }
1112    ;
1113
1114 initializer_list
1115    : initializer
1116    | initializer_list ',' initializer  {  $3->next = $1; $$ = $3; }
1117    ;
1118
1119 statement
1120    : labeled_statement
1121    | compound_statement
1122    | expression_statement
1123    | selection_statement
1124    | iteration_statement
1125    | jump_statement
1126    | INLINEASM  ';'      {
1127                             ast *ex = newNode(INLINEASM,NULL,NULL);
1128                             ex->values.inlineasm = Safe_calloc(1,strlen($1)+1);
1129                             strcpy(ex->values.inlineasm,$1);
1130                             $$ = ex;
1131                          }
1132    ;
1133
1134 labeled_statement
1135    : identifier ':' statement          {  $$ = createLabel($1,$3);  }
1136    | CASE constant_expr ':' statement  {  $$ = createCase(STACK_PEEK(swStk),$2,$4); }
1137    | DEFAULT ':' statement             {  $$ = createDefault(STACK_PEEK(swStk),$3); }
1138    ;
1139
1140 start_block : '{' { STACK_PUSH(blockNum,currBlockno); currBlockno = ++blockNo ;  }
1141             ;
1142
1143 end_block   : '}'     { currBlockno = STACK_POP(blockNum); }
1144             ;
1145
1146 compound_statement
1147    : start_block end_block                    { $$ = createBlock(NULL,NULL); }
1148    | start_block statement_list end_block     { $$ = createBlock(NULL,$2) ;  }
1149    | start_block
1150           declaration_list                    { addSymChain($2); }
1151      end_block                                { $$ = createBlock($2,NULL) ;  }
1152    | start_block
1153           declaration_list                    {  addSymChain ($2); }
1154           statement_list
1155      end_block                                {$$ = createBlock($2,$4)   ;  }
1156    | error ';'                                { $$ = NULL ; }
1157    ;
1158
1159 declaration_list
1160    : declaration
1161      {
1162        /* if this is typedef declare it immediately */
1163        if ( $1 && IS_TYPEDEF($1->etype)) {
1164          allocVariables ($1);
1165          $$ = NULL ;
1166        }
1167        else
1168          $$ = $1 ;
1169      }
1170
1171    | declaration_list declaration
1172      {
1173        symbol   *sym;
1174
1175        /* if this is a typedef */
1176        if ($2 && IS_TYPEDEF($2->etype)) {
1177          allocVariables ($2);
1178          $$ = $1 ;
1179        }
1180        else {
1181                                 /* get to the end of the previous decl */
1182          if ( $1 ) {
1183            $$ = sym = $1 ;
1184            while (sym->next)
1185              sym = sym->next ;
1186            sym->next = $2;
1187          }
1188          else
1189            $$ = $2 ;
1190        }
1191      }
1192    ;
1193
1194 statement_list
1195    : statement
1196    | statement_list statement          {  $$ = newNode(NULLOP,$1,$2) ;}
1197    ;
1198
1199 expression_statement
1200    : ';'                { $$ = NULL;}
1201    | expr ';'
1202    ;
1203
1204 else_statement
1205    :  ELSE  statement   { $$ = $2  ; }
1206    |                    { $$ = NULL;}
1207    ;
1208
1209
1210 selection_statement
1211    : IF '(' expr ')'  statement else_statement { noLineno++ ; $$ = createIf ($3, $5, $6 ); noLineno--;}
1212    | SWITCH '(' expr ')'   {
1213                               ast *ex ;
1214                               static   int swLabel = 0 ;
1215
1216                               /* create a node for expression  */
1217                               ex = newNode(SWITCH,$3,NULL);
1218                               STACK_PUSH(swStk,ex);   /* save it in the stack */
1219                               ex->values.switchVals.swNum = swLabel ;
1220
1221                               /* now create the label */
1222                               sprintf(lbuff,"_swBrk_%d",swLabel++);
1223                               $<sym>$  =  newSymbol(lbuff,NestLevel);
1224                               /* put label in the break stack  */
1225                               STACK_PUSH(breakStack,$<sym>$);
1226                            }
1227      statement             {
1228                               /* get back the switch form the stack  */
1229                               $$ = STACK_POP(swStk)  ;
1230                               $$->right = newNode (NULLOP,$6,createLabel($<sym>5,NULL));
1231                               STACK_POP(breakStack);
1232                            }
1233         ;
1234
1235 while : WHILE  {  /* create and push the continue , break & body labels */
1236                   static int Lblnum = 0 ;
1237                   /* continue */
1238                   sprintf (lbuff,"_whilecontinue_%d",Lblnum);
1239                   STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1240                   /* break */
1241                   sprintf (lbuff,"_whilebreak_%d",Lblnum);
1242                   STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1243                   /* body */
1244                   sprintf (lbuff,"_whilebody_%d",Lblnum++);
1245                   $$ = newSymbol(lbuff,NestLevel);
1246                }
1247
1248 do : DO {  /* create and push the continue , break & body Labels */
1249            static int Lblnum = 0 ;
1250
1251            /* continue */
1252            sprintf(lbuff,"_docontinue_%d",Lblnum);
1253            STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1254            /* break */
1255            sprintf (lbuff,"_dobreak_%d",Lblnum);
1256            STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1257            /* do body */
1258            sprintf (lbuff,"_dobody_%d",Lblnum++);
1259            $$ = newSymbol (lbuff,NestLevel);
1260         }
1261 for : FOR { /* create & push continue, break & body labels */
1262             static int Lblnum = 0 ;
1263
1264             /* continue */
1265             sprintf (lbuff,"_forcontinue_%d",Lblnum);
1266             STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1267             /* break    */
1268             sprintf (lbuff,"_forbreak_%d",Lblnum);
1269             STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1270             /* body */
1271             sprintf (lbuff,"_forbody_%d",Lblnum);
1272             $$ = newSymbol(lbuff,NestLevel);
1273             /* condition */
1274             sprintf (lbuff,"_forcond_%d",Lblnum++);
1275             STACK_PUSH(forStack,newSymbol(lbuff,NestLevel));
1276           }
1277
1278 iteration_statement
1279    : while '(' expr ')'  statement
1280                          {
1281                            noLineno++ ;
1282                            $$ = createWhile ( $1, STACK_POP(continueStack),
1283                                               STACK_POP(breakStack), $3, $5 );
1284                            $$->lineno = $1->lineDef ;
1285                            noLineno-- ;
1286                          }
1287    | do statement   WHILE '(' expr ')' ';'
1288                         {
1289                           noLineno++ ;
1290                           $$ = createDo ( $1 , STACK_POP(continueStack),
1291                                           STACK_POP(breakStack), $5, $2);
1292                           $$->lineno = $1->lineDef ;
1293                           noLineno-- ;
1294                         }
1295    | for '(' expr_opt   ';' expr_opt ';' expr_opt ')'  statement
1296                         {
1297                           noLineno++ ;
1298
1299                           /* if break or continue statement present
1300                              then create a general case loop */
1301                           if (STACK_PEEK(continueStack)->isref ||
1302                               STACK_PEEK(breakStack)->isref) {
1303                               $$ = createFor ($1, STACK_POP(continueStack),
1304                                               STACK_POP(breakStack) ,
1305                                               STACK_POP(forStack)   ,
1306                                               $3 , $5 , $7, $9 );
1307                           } else {
1308                               $$ = newNode(FOR,$9,NULL);
1309                               AST_FOR($$,trueLabel) = $1;
1310                               AST_FOR($$,continueLabel) =  STACK_POP(continueStack);
1311                               AST_FOR($$,falseLabel) = STACK_POP(breakStack);
1312                               AST_FOR($$,condLabel)  = STACK_POP(forStack)  ;
1313                               AST_FOR($$,initExpr)   = $3;
1314                               AST_FOR($$,condExpr)   = $5;
1315                               AST_FOR($$,loopExpr)   = $7;
1316                           }
1317
1318                           noLineno-- ;
1319                         }
1320 ;
1321
1322 expr_opt
1323         :                       { $$ = NULL ; }
1324         |       expr
1325         ;
1326
1327 jump_statement
1328    : GOTO identifier ';'   {
1329                               $2->islbl = 1;
1330                               $$ = newAst_VALUE(symbolVal($2));
1331                               $$ = newNode(GOTO,$$,NULL);
1332                            }
1333    | CONTINUE ';'          {
1334        /* make sure continue is in context */
1335        if (STACK_PEEK(continueStack) == NULL) {
1336            werror(E_BREAK_CONTEXT);
1337            $$ = NULL;
1338        }
1339        else {
1340            $$ = newAst_VALUE(symbolVal(STACK_PEEK(continueStack)));
1341            $$ = newNode(GOTO,$$,NULL);
1342            /* mark the continue label as referenced */
1343            STACK_PEEK(continueStack)->isref = 1;
1344        }
1345    }
1346    | BREAK ';'             {
1347        if (STACK_PEEK(breakStack) == NULL) {
1348            werror(E_BREAK_CONTEXT);
1349            $$ = NULL;
1350        } else {
1351            $$ = newAst_VALUE(symbolVal(STACK_PEEK(breakStack)));
1352            $$ = newNode(GOTO,$$,NULL);
1353            STACK_PEEK(breakStack)->isref = 1;
1354        }
1355    }
1356    | RETURN ';'            { $$ = newNode(RETURN,NULL,NULL)    ; }
1357    | RETURN expr ';'       { $$ = newNode(RETURN,NULL,$2) ; }
1358    ;
1359
1360 identifier
1361    : IDENTIFIER   { $$ = newSymbol ($1,NestLevel) ; }
1362    ;
1363 %%
1364