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