git.gag.com Git - fw/sdcc/blob - src/SDCC.y

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