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