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      $1->next=p;
1150    }
1151    | abstract_declarator2 '(' parameter_type_list ')' {
1152      if (!IS_VOID($3->type)) {
1153        // this is nonsense, so let's just burp something
1154        werror(E_TOO_FEW_PARMS);
1155      } else {
1156        // $1 must be a pointer to a function
1157        sym_link *p=newLink();
1158        DCL_TYPE(p) = FUNCTION;
1159        $1->next=p;
1160      }
1161    }
1162
1163 initializer
1164    : assignment_expr                { $$ = newiList(INIT_NODE,$1); }
1165    | '{'  initializer_list '}'      { $$ = newiList(INIT_DEEP,revinit($2)); }
1166    | '{'  initializer_list ',' '}'  { $$ = newiList(INIT_DEEP,revinit($2)); }
1167    ;
1168
1169 initializer_list
1170    : initializer
1171    | initializer_list ',' initializer  {  $3->next = $1; $$ = $3; }
1172    ;
1173
1174 statement
1175    : labeled_statement
1176    | compound_statement
1177    | expression_statement
1178    | selection_statement
1179    | iteration_statement
1180    | jump_statement
1181    | INLINEASM  ';'      {
1182                             ast *ex = newNode(INLINEASM,NULL,NULL);
1183                             ex->values.inlineasm = malloc(strlen($1)+1);
1184                             strcpy(ex->values.inlineasm,$1);
1185                             $$ = ex;
1186                          }
1187    ;
1188
1189 labeled_statement
1190 //   : identifier ':' statement          {  $$ = createLabel($1,$3);  }
1191    : identifier ':'                    {  $$ = createLabel($1,NULL);  }
1192    | CASE constant_expr ':' statement  {  $$ = createCase(STACK_PEEK(swStk),$2,$4); }
1193    | DEFAULT ':' statement             {  $$ = createDefault(STACK_PEEK(swStk),$3); }
1194    ;
1195
1196 start_block : '{' { STACK_PUSH(blockNum,currBlockno); currBlockno = ++blockNo ;  }
1197             ;
1198
1199 end_block   : '}'     { currBlockno = STACK_POP(blockNum); }
1200             ;
1201
1202 compound_statement
1203    : start_block end_block                    { $$ = createBlock(NULL,NULL); }
1204    | start_block statement_list end_block     { $$ = createBlock(NULL,$2) ;  }
1205    | start_block
1206           declaration_list                    { addSymChain($2); }
1207      end_block                                { $$ = createBlock($2,NULL) ;  }
1208    | start_block
1209           declaration_list                    {  addSymChain ($2); }
1210           statement_list
1211      end_block                                {$$ = createBlock($2,$4)   ;  }
1212    | error ';'                                { $$ = NULL ; }
1213    ;
1214
1215 declaration_list
1216    : declaration
1217      {
1218        /* if this is typedef declare it immediately */
1219        if ( $1 && IS_TYPEDEF($1->etype)) {
1220          allocVariables ($1);
1221          $$ = NULL ;
1222        }
1223        else
1224          $$ = $1 ;
1225      }
1226
1227    | declaration_list declaration
1228      {
1229        symbol   *sym;
1230
1231        /* if this is a typedef */
1232        if ($2 && IS_TYPEDEF($2->etype)) {
1233          allocVariables ($2);
1234          $$ = $1 ;
1235        }
1236        else {
1237                                 /* get to the end of the previous decl */
1238          if ( $1 ) {
1239            $$ = sym = $1 ;
1240            while (sym->next)
1241              sym = sym->next ;
1242            sym->next = $2;
1243          }
1244          else
1245            $$ = $2 ;
1246        }
1247      }
1248    ;
1249
1250 statement_list
1251    : statement
1252    | statement_list statement          {  $$ = newNode(NULLOP,$1,$2) ;}
1253    ;
1254
1255 expression_statement
1256    : ';'                { $$ = NULL;}
1257    | expr ';'
1258    ;
1259
1260 else_statement
1261    :  ELSE  statement   { $$ = $2  ; }
1262    |                    { $$ = NULL;}
1263    ;
1264
1265
1266 selection_statement
1267    : IF '(' expr ')'  statement else_statement { noLineno++ ; $$ = createIf ($3, $5, $6 ); noLineno--;}
1268    | SWITCH '(' expr ')'   {
1269                               ast *ex ;
1270                               static   int swLabel = 0 ;
1271
1272                               /* create a node for expression  */
1273                               ex = newNode(SWITCH,$3,NULL);
1274                               STACK_PUSH(swStk,ex);   /* save it in the stack */
1275                               ex->values.switchVals.swNum = swLabel ;
1276
1277                               /* now create the label */
1278                               sprintf(lbuff,"_swBrk_%d",swLabel++);
1279                               $<sym>$  =  newSymbol(lbuff,NestLevel);
1280                               /* put label in the break stack  */
1281                               STACK_PUSH(breakStack,$<sym>$);
1282                            }
1283      statement             {
1284                               /* get back the switch form the stack  */
1285                               $$ = STACK_POP(swStk)  ;
1286                               $$->right = newNode (NULLOP,$6,createLabel($<sym>5,NULL));
1287                               STACK_POP(breakStack);
1288                            }
1289         ;
1290
1291 while : WHILE  {  /* create and push the continue , break & body labels */
1292                   static int Lblnum = 0 ;
1293                   /* continue */
1294                   sprintf (lbuff,"_whilecontinue_%d",Lblnum);
1295                   STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1296                   /* break */
1297                   sprintf (lbuff,"_whilebreak_%d",Lblnum);
1298                   STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1299                   /* body */
1300                   sprintf (lbuff,"_whilebody_%d",Lblnum++);
1301                   $$ = newSymbol(lbuff,NestLevel);
1302                }
1303
1304 do : DO {  /* create and push the continue , break & body Labels */
1305            static int Lblnum = 0 ;
1306
1307            /* continue */
1308            sprintf(lbuff,"_docontinue_%d",Lblnum);
1309            STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1310            /* break */
1311            sprintf (lbuff,"_dobreak_%d",Lblnum);
1312            STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1313            /* do body */
1314            sprintf (lbuff,"_dobody_%d",Lblnum++);
1315            $$ = newSymbol (lbuff,NestLevel);
1316         }
1317 for : FOR { /* create & push continue, break & body labels */
1318             static int Lblnum = 0 ;
1319
1320             /* continue */
1321             sprintf (lbuff,"_forcontinue_%d",Lblnum);
1322             STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1323             /* break    */
1324             sprintf (lbuff,"_forbreak_%d",Lblnum);
1325             STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1326             /* body */
1327             sprintf (lbuff,"_forbody_%d",Lblnum);
1328             $$ = newSymbol(lbuff,NestLevel);
1329             /* condition */
1330             sprintf (lbuff,"_forcond_%d",Lblnum++);
1331             STACK_PUSH(forStack,newSymbol(lbuff,NestLevel));
1332           }
1333
1334 iteration_statement
1335    : while '(' expr ')'  statement
1336                          {
1337                            noLineno++ ;
1338                            $$ = createWhile ( $1, STACK_POP(continueStack),
1339                                               STACK_POP(breakStack), $3, $5 );
1340                            $$->lineno = $1->lineDef ;
1341                            noLineno-- ;
1342                          }
1343    | do statement   WHILE '(' expr ')' ';'
1344                         {
1345                           noLineno++ ;
1346                           $$ = createDo ( $1 , STACK_POP(continueStack),
1347                                           STACK_POP(breakStack), $5, $2);
1348                           $$->lineno = $1->lineDef ;
1349                           noLineno-- ;
1350                         }
1351    | for '(' expr_opt   ';' expr_opt ';' expr_opt ')'  statement
1352                         {
1353                           noLineno++ ;
1354
1355                           /* if break or continue statement present
1356                              then create a general case loop */
1357                           if (STACK_PEEK(continueStack)->isref ||
1358                               STACK_PEEK(breakStack)->isref) {
1359                               $$ = createFor ($1, STACK_POP(continueStack),
1360                                               STACK_POP(breakStack) ,
1361                                               STACK_POP(forStack)   ,
1362                                               $3 , $5 , $7, $9 );
1363                           } else {
1364                               $$ = newNode(FOR,$9,NULL);
1365                               AST_FOR($$,trueLabel) = $1;
1366                               AST_FOR($$,continueLabel) =  STACK_POP(continueStack);
1367                               AST_FOR($$,falseLabel) = STACK_POP(breakStack);
1368                               AST_FOR($$,condLabel)  = STACK_POP(forStack)  ;
1369                               AST_FOR($$,initExpr)   = $3;
1370                               AST_FOR($$,condExpr)   = $5;
1371                               AST_FOR($$,loopExpr)   = $7;
1372                           }
1373
1374                           noLineno-- ;
1375                         }
1376 ;
1377
1378 expr_opt
1379         :                       { $$ = NULL ; }
1380         |       expr
1381         ;
1382
1383 jump_statement
1384    : GOTO identifier ';'   {
1385                               $2->islbl = 1;
1386                               $$ = newAst_VALUE(symbolVal($2));
1387                               $$ = newNode(GOTO,$$,NULL);
1388                            }
1389    | CONTINUE ';'          {
1390        /* make sure continue is in context */
1391        if (STACK_PEEK(continueStack) == NULL) {
1392            werror(E_BREAK_CONTEXT);
1393            $$ = NULL;
1394        }
1395        else {
1396            $$ = newAst_VALUE(symbolVal(STACK_PEEK(continueStack)));
1397            $$ = newNode(GOTO,$$,NULL);
1398            /* mark the continue label as referenced */
1399            STACK_PEEK(continueStack)->isref = 1;
1400        }
1401    }
1402    | BREAK ';'             {
1403        if (STACK_PEEK(breakStack) == NULL) {
1404            werror(E_BREAK_CONTEXT);
1405            $$ = NULL;
1406        } else {
1407            $$ = newAst_VALUE(symbolVal(STACK_PEEK(breakStack)));
1408            $$ = newNode(GOTO,$$,NULL);
1409            STACK_PEEK(breakStack)->isref = 1;
1410        }
1411    }
1412    | RETURN ';'            { $$ = newNode(RETURN,NULL,NULL)    ; }
1413    | RETURN expr ';'       { $$ = newNode(RETURN,NULL,$2) ; }
1414    ;
1415
1416 identifier
1417    : IDENTIFIER   { $$ = newSymbol ($1,NestLevel) ; }
1418    ;
1419 %%
1420