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                            int bitsize;
 793                            $$ = newSymbol (genSymName(NestLevel),NestLevel) ;
 794                            bitsize= (int) floatFromVal(constExprValue($2,TRUE));
 795                            if (bitsize > (port->s.int_size * 8)) {
 796                              bitsize = port->s.int_size * 8;
 797                              werror(E_BITFLD_SIZE, bitsize);
 798                            }
 799                            if (!bitsize)
 800                              bitsize = BITVAR_PAD;
 801                            $$->bitVar = bitsize;
 802                         }
 803    | declarator ':' constant_expr
 804                         {
 805                           int bitsize;
 806                           bitsize= (int) floatFromVal(constExprValue($3,TRUE));
 807                           if (bitsize > (port->s.int_size * 8)) {
 808                             bitsize = port->s.int_size * 8;
 809                             werror(E_BITFLD_SIZE, bitsize);
 810                           }
 811                           if (!bitsize) {
 812                             $$ = newSymbol (genSymName(NestLevel),NestLevel) ;
 813                             $$->bitVar = BITVAR_PAD;
 814                             werror(W_BITFLD_NAMED);
 815                           }
 816                           else
 817                             $1->bitVar = bitsize;
 818                         }
 819    ;
 820
 821 enum_specifier
 822    : ENUM            '{' enumerator_list '}' {
 823            symbol *sym, *dsym;
 824            char _error=0;
 825
 826            // check for duplicate enums
 827            for (sym=$3; sym; sym=sym->next) {
 828              for (dsym=sym->next; dsym; dsym=dsym->next) {
 829                if (strcmp(sym->name, dsym->name)==0) {
 830                  werror(E_DUPLICATE_MEMBER, "enum", sym->name);
 831                  _error++;
 832                }
 833              }
 834            }
 835            if (_error==0) {
 836              $$ = copyLinkChain(cenum->type);
 837            } else {
 838              $$ = newIntLink();
 839              SPEC_NOUN($$)=0;
 840            }
 841          }
 842
 843    | ENUM identifier '{' enumerator_list '}' {
 844      symbol *csym ;
 845
 846      $2->type = copyLinkChain(cenum->type);
 847      $2->etype = getSpec($2->type);
 848      /* add this to the enumerator table */
 849      if (!(csym=findSym(enumTab,$2,$2->name)) &&
 850          (csym && csym->level == $2->level))
 851        werror(E_DUPLICATE_TYPEDEF,csym->name);
 852
 853      addSym ( enumTab,$2,$2->name,$2->level,$2->block, 0);
 854      //addSymChain ($4);
 855      //allocVariables (reverseSyms($4));
 856      $$ = copyLinkChain(cenum->type);
 857      SPEC_SCLS(getSpec($$)) = 0 ;
 858    }
 859    | ENUM identifier                         {
 860      symbol *csym ;
 861
 862      /* check the enumerator table */
 863      if ((csym = findSym(enumTab,$2,$2->name)))
 864        $$ = copyLinkChain(csym->type);
 865      else  {
 866        $$ = newLink(SPECIFIER) ;
 867        SPEC_NOUN($$) = V_INT   ;
 868      }
 869
 870      SPEC_SCLS(getSpec($$)) = 0 ;
 871    }
 872    ;
 873
 874 enumerator_list
 875    : enumerator
 876    | enumerator_list ',' {
 877                          }
 878    | enumerator_list ',' enumerator {
 879                                        $3->next = $1 ;
 880                                        $$ = $3  ;
 881                                     }
 882    ;
 883
 884 enumerator
 885    : identifier opt_assign_expr
 886      {
 887        /* make the symbol one level up */
 888        $1->level-- ;
 889        $1->type = copyLinkChain($2->type);
 890        $1->etype= getSpec($1->type);
 891        SPEC_ENUM($1->etype) = 1;
 892        $$ = $1 ;
 893        // do this now, so we can use it for the next enums in the list
 894        addSymChain($1);
 895      }
 896    ;
 897
 898 opt_assign_expr
 899    :  '='   constant_expr  {
 900                               value *val ;
 901
 902                               val = constExprValue($2,TRUE);
 903                               $$ = cenum = val ;
 904                            }
 905    |                       {
 906                               if (cenum)  {
 907                                  SNPRINTF(lbuff, sizeof(lbuff),
 908                                           "%d",(int) floatFromVal(cenum)+1);
 909                                  $$ = cenum = constVal(lbuff);
 910                               }
 911                               else {
 912                                  SNPRINTF(lbuff, sizeof(lbuff),
 913                                           "%d",0);
 914                                  $$ = cenum = constVal(lbuff);
 915                               }
 916                            }
 917    ;
 918
 919 declarator
 920    : declarator2_function_attributes    { $$ = $1; }
 921    | pointer declarator2_function_attributes
 922          {
 923              addDecl ($2,0,reverseLink($1));
 924              $$ = $2 ;
 925          }
 926    ;
 927
 928 declarator2_function_attributes
 929    : declarator2                  { $$ = $1 ; }
 930    | declarator2 function_attribute  {
 931        // copy the functionAttributes (not the args and hasVargs !!)
 932        sym_link *funcType=$1->etype;
 933        struct value *args=FUNC_ARGS(funcType);
 934        unsigned hasVargs=FUNC_HASVARARGS(funcType);
 935
 936        memcpy (&funcType->funcAttrs, &$2->funcAttrs,
 937                sizeof($2->funcAttrs));
 938
 939        FUNC_ARGS(funcType)=args;
 940        FUNC_HASVARARGS(funcType)=hasVargs;
 941
 942        // just to be sure
 943        memset (&$2->funcAttrs, 0,
 944                sizeof($2->funcAttrs));
 945
 946        addDecl ($1,0,$2);
 947    }
 948    ;
 949
 950 declarator2
 951    : identifier
 952    | '(' declarator ')'     { $$ = $2; }
 953    | declarator2 '[' ']'
 954          {
 955             sym_link   *p;
 956
 957             p = newLink (DECLARATOR);
 958             DCL_TYPE(p) = ARRAY ;
 959             DCL_ELEM(p) = 0     ;
 960             addDecl($1,0,p);
 961          }
 962    | declarator2 '[' constant_expr ']'
 963          {
 964             sym_link   *p ;
 965                         value *tval;
 966
 967             p = (tval = constExprValue($3,TRUE))->etype;
 968             /* if it is not a constant then Error  */
 969             if ( SPEC_SCLS(p) != S_LITERAL)
 970                werror(E_CONST_EXPECTED) ;
 971             else {
 972                p = newLink (DECLARATOR);
 973                DCL_TYPE(p) = ARRAY ;
 974                DCL_ELEM(p) = (int) floatFromVal(tval) ;
 975                addDecl($1,0,p);
 976             }
 977          }
 978    | declarator2 '('  ')'       {  addDecl ($1,FUNCTION,NULL) ;   }
 979    | declarator2 '(' { NestLevel++ ; currBlockno++; } parameter_type_list ')'
 980          {
 981
 982              addDecl ($1,FUNCTION,NULL) ;
 983
 984              FUNC_HASVARARGS($1->type) = IS_VARG($4);
 985              FUNC_ARGS($1->type) = reverseVal($4);
 986
 987              /* nest level was incremented to take care of the parms  */
 988              NestLevel-- ;
 989              currBlockno--;
 990
 991              // if this was a pointer (to a function)
 992              if (IS_PTR($1->type)) {
 993                // move the args and hasVargs to the function
 994                FUNC_ARGS($1->etype)=FUNC_ARGS($1->type);
 995                FUNC_HASVARARGS($1->etype)=FUNC_HASVARARGS($1->type);
 996                memset (&$1->type->funcAttrs, 0,
 997                        sizeof($1->type->funcAttrs));
 998                // remove the symbol args (if any)
 999                cleanUpLevel(SymbolTab,NestLevel+1);
1000              }
1001
1002              $$ = $1;
1003          }
1004    | declarator2 '(' parameter_identifier_list ')'
1005          {
1006            werror(E_OLD_STYLE,$1->name) ;
1007
1008            /* assume it returns an int */
1009            $1->type = $1->etype = newIntLink();
1010            $$ = $1 ;
1011          }
1012    ;
1013
1014 pointer
1015    : unqualified_pointer { $$ = $1 ;}
1016    | unqualified_pointer type_specifier_list
1017          {
1018              $$ = $1  ;
1019              DCL_TSPEC($1) = $2;
1020          }
1021    | unqualified_pointer pointer
1022          {
1023              $$ = $1 ;
1024              $$->next = $2 ;
1025              DCL_TYPE($2)=port->unqualified_pointer;
1026          }
1027    | unqualified_pointer type_specifier_list pointer
1028          {
1029              $$ = $1 ;
1030              if (IS_SPEC($2) && DCL_TYPE($3) == UPOINTER) {
1031                  DCL_PTR_CONST($1) = SPEC_CONST($2);
1032                  DCL_PTR_VOLATILE($1) = SPEC_VOLATILE($2);
1033                  switch (SPEC_SCLS($2)) {
1034                  case S_XDATA:
1035                      DCL_TYPE($3) = FPOINTER;
1036                      break;
1037                  case S_IDATA:
1038                      DCL_TYPE($3) = IPOINTER ;
1039                      break;
1040                  case S_PDATA:
1041                      DCL_TYPE($3) = PPOINTER ;
1042                      break;
1043                  case S_DATA:
1044                      DCL_TYPE($3) = POINTER ;
1045                      break;
1046                  case S_CODE:
1047                      DCL_PTR_CONST($3) = 1;
1048                      DCL_TYPE($3) = CPOINTER ;
1049                      break;
1050                  case S_EEPROM:
1051                      DCL_TYPE($3) = EEPPOINTER;
1052                      break;
1053                  default:
1054                    // this could be just "constant"
1055                    // werror(W_PTR_TYPE_INVALID);
1056                      ;
1057                  }
1058              }
1059              else
1060                  werror (W_PTR_TYPE_INVALID);
1061              $$->next = $3 ;
1062          }
1063    ;
1064
1065 unqualified_pointer
1066    :  '*'
1067       {
1068         $$ = newLink(DECLARATOR);
1069         DCL_TYPE($$)=UPOINTER;
1070       }
1071    ;
1072
1073 type_specifier_list
1074    : type_specifier
1075    //| type_specifier_list type_specifier         {  $$ = mergeSpec ($1,$2, "type_specifier_list"); }
1076    | type_specifier_list type_specifier {
1077      /* if the decl $2 is not a specifier */
1078      /* find the spec and replace it      */
1079      if ( !IS_SPEC($2)) {
1080        sym_link *lnk = $2 ;
1081        while (lnk && !IS_SPEC(lnk->next))
1082          lnk = lnk->next;
1083        lnk->next = mergeSpec($1,lnk->next, "type_specifier_list type_specifier skipped");
1084        $$ = $2 ;
1085      }
1086      else
1087        $$ = mergeSpec($1,$2, "type_specifier_list type_specifier");
1088    }
1089    ;
1090
1091 parameter_identifier_list
1092    : identifier_list
1093    | identifier_list ',' ELIPSIS
1094    ;
1095
1096 identifier_list
1097    : identifier
1098    | identifier_list ',' identifier
1099          {
1100            $3->next = $1;
1101            $$ = $3 ;
1102          }
1103    ;
1104
1105 parameter_type_list
1106         : parameter_list
1107         | parameter_list ',' VAR_ARGS { $1->vArgs = 1;}
1108         ;
1109
1110 parameter_list
1111    : parameter_declaration
1112    | parameter_list ',' parameter_declaration
1113          {
1114             $3->next = $1 ;
1115             $$ = $3 ;
1116          }
1117    ;
1118
1119 parameter_declaration
1120    : type_specifier_list declarator
1121                {
1122                   symbol *loop ;
1123                   pointerTypes($2->type,$1);
1124                   addDecl ($2,0,$1);
1125                   for (loop=$2;loop;loop->_isparm=1,loop=loop->next);
1126                   addSymChain ($2);
1127                   $$ = symbolVal($2);
1128                }
1129    | type_name {
1130                   $$ = newValue() ;
1131                   $$->type = $1;
1132                   $$->etype = getSpec($$->type);
1133                }
1134    ;
1135
1136 type_name
1137    : type_specifier_list  { $$ = $1 ;}
1138    | type_specifier_list abstract_declarator
1139                {
1140                  /* go to the end of the list */
1141                  sym_link *p;
1142                  pointerTypes($2,$1);
1143                  for ( p = $2 ; p && p->next ; p=p->next);
1144                  if (!p) {
1145                    werror(E_SYNTAX_ERROR, yytext);
1146                  } else {
1147                    p->next = $1 ;
1148                  }
1149                  $$ = $2 ;
1150                }
1151    ;
1152
1153 abstract_declarator
1154    : pointer { $$ = reverseLink($1); }
1155    | abstract_declarator2
1156    | pointer abstract_declarator2   { $1 = reverseLink($1); $1->next = $2 ; $$ = $1;}
1157    ;
1158
1159 abstract_declarator2
1160    : '(' abstract_declarator ')'    { $$ = $2 ; }
1161    | '[' ']'                        {
1162                                        $$ = newLink (DECLARATOR);
1163                                        DCL_TYPE($$) = ARRAY ;
1164                                        DCL_ELEM($$) = 0     ;
1165                                     }
1166    | '[' constant_expr ']'          {
1167                                        value *val ;
1168                                        $$ = newLink (DECLARATOR);
1169                                        DCL_TYPE($$) = ARRAY ;
1170                                        DCL_ELEM($$) = (int) floatFromVal(val = constExprValue($2,TRUE));
1171                                     }
1172    | abstract_declarator2 '[' ']'   {
1173                                        $$ = newLink (DECLARATOR);
1174                                        DCL_TYPE($$) = ARRAY ;
1175                                        DCL_ELEM($$) = 0     ;
1176                                        $$->next = $1 ;
1177                                     }
1178    | abstract_declarator2 '[' constant_expr ']'
1179                                     {
1180                                        value *val ;
1181                                        $$ = newLink (DECLARATOR);
1182                                        DCL_TYPE($$) = ARRAY ;
1183                                        DCL_ELEM($$) = (int) floatFromVal(val = constExprValue($3,TRUE));
1184                                        $$->next = $1 ;
1185                                     }
1186    | '(' ')'                        { $$ = NULL;}
1187    | '(' parameter_type_list ')'    { $$ = NULL;}
1188    | abstract_declarator2 '(' ')' {
1189      // $1 must be a pointer to a function
1190      sym_link *p=newLink(DECLARATOR);
1191      DCL_TYPE(p) = FUNCTION;
1192      if (!$1) {
1193        // ((void (code *) ()) 0) ()
1194        $1=newLink(DECLARATOR);
1195        DCL_TYPE($1)=CPOINTER;
1196        $$ = $1;
1197      }
1198      $1->next=p;
1199    }
1200    | abstract_declarator2 '(' parameter_type_list ')' {
1201      if (!IS_VOID($3->etype)) {
1202        // this is nonsense, so let's just burp something
1203        werror(E_TOO_FEW_PARMS);
1204      } else {
1205        // $1 must be a pointer to a function
1206        sym_link *p=newLink(DECLARATOR);
1207        DCL_TYPE(p) = FUNCTION;
1208        if (!$1) {
1209          // ((void (code *) (void)) 0) ()
1210          $1=newLink(DECLARATOR);
1211          DCL_TYPE($1)=CPOINTER;
1212          $$ = $1;
1213        }
1214        $1->next=p;
1215      }
1216    }
1217    ;
1218
1219 initializer
1220    : assignment_expr                { $$ = newiList(INIT_NODE,$1); }
1221    | '{'  initializer_list '}'      { $$ = newiList(INIT_DEEP,revinit($2)); }
1222    | '{'  initializer_list ',' '}'  { $$ = newiList(INIT_DEEP,revinit($2)); }
1223    ;
1224
1225 initializer_list
1226    : initializer
1227    | initializer_list ',' initializer  {  $3->next = $1; $$ = $3; }
1228    ;
1229
1230 statement
1231    : labeled_statement
1232    | compound_statement
1233    | expression_statement
1234    | selection_statement
1235    | iteration_statement
1236    | jump_statement
1237    | INLINEASM  ';'      {
1238                             ast *ex = newNode(INLINEASM,NULL,NULL);
1239                             ex->values.inlineasm = strdup($1);
1240                             $$ = ex;
1241                          }
1242    ;
1243
1244 labeled_statement
1245 //   : identifier ':' statement          {  $$ = createLabel($1,$3);  }
1246    : identifier ':'                    {  $$ = createLabel($1,NULL);  }
1247    | CASE constant_expr ':' statement  {  $$ = createCase(STACK_PEEK(swStk),$2,$4); }
1248    | DEFAULT ':' statement             {  $$ = createDefault(STACK_PEEK(swStk),$3); }
1249    ;
1250
1251 start_block : '{' { STACK_PUSH(blockNum,currBlockno); currBlockno = ++blockNo ;  }
1252             ;
1253
1254 end_block   : '}'     { currBlockno = STACK_POP(blockNum); }
1255             ;
1256
1257 compound_statement
1258    : start_block end_block                    { $$ = createBlock(NULL,NULL); }
1259    | start_block statement_list end_block     { $$ = createBlock(NULL,$2) ;  }
1260    | start_block
1261           declaration_list                    { addSymChain($2); }
1262      end_block                                { $$ = createBlock($2,NULL) ;  }
1263    | start_block
1264           declaration_list                    {  addSymChain ($2); }
1265           statement_list
1266      end_block                                {$$ = createBlock($2,$4)   ;  }
1267    | error ';'                                { $$ = NULL ; }
1268    ;
1269
1270 declaration_list
1271    : declaration
1272      {
1273        /* if this is typedef declare it immediately */
1274        if ( $1 && IS_TYPEDEF($1->etype)) {
1275          allocVariables ($1);
1276          $$ = NULL ;
1277        }
1278        else
1279          $$ = $1 ;
1280      }
1281
1282    | declaration_list declaration
1283      {
1284        symbol   *sym;
1285
1286        /* if this is a typedef */
1287        if ($2 && IS_TYPEDEF($2->etype)) {
1288          allocVariables ($2);
1289          $$ = $1 ;
1290        }
1291        else {
1292                                 /* get to the end of the previous decl */
1293          if ( $1 ) {
1294            $$ = sym = $1 ;
1295            while (sym->next)
1296              sym = sym->next ;
1297            sym->next = $2;
1298          }
1299          else
1300            $$ = $2 ;
1301        }
1302      }
1303    ;
1304
1305 statement_list
1306    : statement
1307    | statement_list statement          {  $$ = newNode(NULLOP,$1,$2) ;}
1308    ;
1309
1310 expression_statement
1311    : ';'                { $$ = NULL;}
1312    | expr ';'
1313    ;
1314
1315 else_statement
1316    :  ELSE  statement   { $$ = $2  ; }
1317    |                    { $$ = NULL;}
1318    ;
1319
1320
1321 selection_statement
1322    : IF '(' expr ')'  statement else_statement { noLineno++ ; $$ = createIf ($3, $5, $6 ); noLineno--;}
1323    | SWITCH '(' expr ')'   {
1324                               ast *ex ;
1325                               static   int swLabel = 0 ;
1326
1327                               /* create a node for expression  */
1328                               ex = newNode(SWITCH,$3,NULL);
1329                               STACK_PUSH(swStk,ex);   /* save it in the stack */
1330                               ex->values.switchVals.swNum = swLabel ;
1331
1332                               /* now create the label */
1333                               SNPRINTF(lbuff, sizeof(lbuff),
1334                                        "_swBrk_%d",swLabel++);
1335                               $<sym>$  =  newSymbol(lbuff,NestLevel);
1336                               /* put label in the break stack  */
1337                               STACK_PUSH(breakStack,$<sym>$);
1338                            }
1339      statement             {
1340                               /* get back the switch form the stack  */
1341                               $$ = STACK_POP(swStk)  ;
1342                               $$->right = newNode (NULLOP,$6,createLabel($<sym>5,NULL));
1343                               STACK_POP(breakStack);
1344                            }
1345         ;
1346
1347 while : WHILE  {  /* create and push the continue , break & body labels */
1348                   static int Lblnum = 0 ;
1349                   /* continue */
1350                   SNPRINTF (lbuff, sizeof(lbuff), "_whilecontinue_%d",Lblnum);
1351                   STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1352                   /* break */
1353                   SNPRINTF (lbuff, sizeof(lbuff), "_whilebreak_%d",Lblnum);
1354                   STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1355                   /* body */
1356                   SNPRINTF (lbuff, sizeof(lbuff), "_whilebody_%d",Lblnum++);
1357                   $$ = newSymbol(lbuff,NestLevel);
1358                }
1359    ;
1360
1361 do : DO {  /* create and push the continue , break & body Labels */
1362            static int Lblnum = 0 ;
1363
1364            /* continue */
1365            SNPRINTF(lbuff, sizeof(lbuff), "_docontinue_%d",Lblnum);
1366            STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1367            /* break */
1368            SNPRINTF(lbuff, sizeof(lbuff), "_dobreak_%d",Lblnum);
1369            STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1370            /* do body */
1371            SNPRINTF(lbuff, sizeof(lbuff), "_dobody_%d",Lblnum++);
1372            $$ = newSymbol (lbuff,NestLevel);
1373         }
1374    ;
1375
1376 for : FOR { /* create & push continue, break & body labels */
1377             static int Lblnum = 0 ;
1378
1379             /* continue */
1380             SNPRINTF(lbuff, sizeof(lbuff), "_forcontinue_%d",Lblnum);
1381             STACK_PUSH(continueStack,newSymbol(lbuff,NestLevel));
1382             /* break    */
1383             SNPRINTF(lbuff, sizeof(lbuff), "_forbreak_%d",Lblnum);
1384             STACK_PUSH(breakStack,newSymbol(lbuff,NestLevel));
1385             /* body */
1386             SNPRINTF(lbuff, sizeof(lbuff), "_forbody_%d",Lblnum);
1387             $$ = newSymbol(lbuff,NestLevel);
1388             /* condition */
1389             SNPRINTF(lbuff, sizeof(lbuff), "_forcond_%d",Lblnum++);
1390             STACK_PUSH(forStack,newSymbol(lbuff,NestLevel));
1391           }
1392    ;
1393
1394 iteration_statement
1395    : while '(' expr ')'  statement
1396                          {
1397                            noLineno++ ;
1398                            $$ = createWhile ( $1, STACK_POP(continueStack),
1399                                               STACK_POP(breakStack), $3, $5 );
1400                            $$->lineno = $1->lineDef ;
1401                            noLineno-- ;
1402                          }
1403    | do statement   WHILE '(' expr ')' ';'
1404                         {
1405                           noLineno++ ;
1406                           $$ = createDo ( $1 , STACK_POP(continueStack),
1407                                           STACK_POP(breakStack), $5, $2);
1408                           $$->lineno = $1->lineDef ;
1409                           noLineno-- ;
1410                         }
1411    | for '(' expr_opt   ';' expr_opt ';' expr_opt ')'  statement
1412                         {
1413                           noLineno++ ;
1414
1415                           /* if break or continue statement present
1416                              then create a general case loop */
1417                           if (STACK_PEEK(continueStack)->isref ||
1418                               STACK_PEEK(breakStack)->isref) {
1419                               $$ = createFor ($1, STACK_POP(continueStack),
1420                                               STACK_POP(breakStack) ,
1421                                               STACK_POP(forStack)   ,
1422                                               $3 , $5 , $7, $9 );
1423                           } else {
1424                               $$ = newNode(FOR,$9,NULL);
1425                               AST_FOR($$,trueLabel) = $1;
1426                               AST_FOR($$,continueLabel) =  STACK_POP(continueStack);
1427                               AST_FOR($$,falseLabel) = STACK_POP(breakStack);
1428                               AST_FOR($$,condLabel)  = STACK_POP(forStack)  ;
1429                               AST_FOR($$,initExpr)   = $3;
1430                               AST_FOR($$,condExpr)   = $5;
1431                               AST_FOR($$,loopExpr)   = $7;
1432                           }
1433
1434                           noLineno-- ;
1435                         }
1436 ;
1437
1438 expr_opt
1439         :                       { $$ = NULL ; }
1440         |       expr
1441         ;
1442
1443 jump_statement
1444    : GOTO identifier ';'   {
1445                               $2->islbl = 1;
1446                               $$ = newAst_VALUE(symbolVal($2));
1447                               $$ = newNode(GOTO,$$,NULL);
1448                            }
1449    | CONTINUE ';'          {
1450        /* make sure continue is in context */
1451        if (STACK_PEEK(continueStack) == NULL) {
1452            werror(E_BREAK_CONTEXT);
1453            $$ = NULL;
1454        }
1455        else {
1456            $$ = newAst_VALUE(symbolVal(STACK_PEEK(continueStack)));
1457            $$ = newNode(GOTO,$$,NULL);
1458            /* mark the continue label as referenced */
1459            STACK_PEEK(continueStack)->isref = 1;
1460        }
1461    }
1462    | BREAK ';'             {
1463        if (STACK_PEEK(breakStack) == NULL) {
1464            werror(E_BREAK_CONTEXT);
1465            $$ = NULL;
1466        } else {
1467            $$ = newAst_VALUE(symbolVal(STACK_PEEK(breakStack)));
1468            $$ = newNode(GOTO,$$,NULL);
1469            STACK_PEEK(breakStack)->isref = 1;
1470        }
1471    }
1472    | RETURN ';'            { $$ = newNode(RETURN,NULL,NULL)    ; }
1473    | RETURN expr ';'       { $$ = newNode(RETURN,NULL,$2) ; }
1474    ;
1475
1476 identifier
1477    : IDENTIFIER   { $$ = newSymbol ($1,NestLevel) ; }
1478    ;
1479 %%
1480