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