Changeset 2f22cc4


Ignore:
Timestamp:
Aug 10, 2016, 2:02:10 PM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
321f55d, a563f01
Parents:
a6dd5b0
Message:

more refactoring of parser code

Location:
src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/ExpressionNode.cc

    ra6dd5b0 r2f22cc4  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug  9 12:28:40 2016
    13 // Update Count     : 482
     12// Last Modified On : Wed Aug 10 11:07:38 2016
     13// Update Count     : 486
    1414//
    1515
     
    168168//##############################################################################
    169169
    170 //Expression *build_varref( ExpressionNode expr ) {
    171 //      return new NameExpr( get_name(), maybeBuild<Expression>( get_argName() ) );
    172 //}
    173 
    174 // VarRefNode::VarRefNode( const string *name, bool labelp ) : ExpressionNode( nullptr, name ), isLabel( labelp ) {}
    175 
    176 // VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {}
    177 
    178 // Expression *VarRefNode::build() const {
    179 //      return new NameExpr( get_name(), maybeBuild< Expression >( get_argName() ) );
    180 // }
    181 
    182 // void VarRefNode::printOneLine( std::ostream &os, int indent ) const {
    183 //      printDesignation( os );
    184 //      os << get_name() << ' ';
    185 // }
    186 
    187 // void VarRefNode::print( std::ostream &os, int indent ) const {
    188 //      printDesignation( os );
    189 //      os << string( indent, ' ' ) << "Referencing: ";
    190 //      os << "Variable: " << get_name();
    191 //      os << endl;
    192 // }
    193 
    194170NameExpr * build_varref( const string *name, bool labelp ) {
    195171        return new NameExpr( *name, nullptr );
    196172}
    197 
    198 //##############################################################################
    199 
    200 // DesignatorNode::DesignatorNode( ExpressionNode *expr, bool isArrayIndex, bool isVarRef ) : isArrayIndex( isArrayIndex ) {
    201 //      set_argName( expr );
    202 // }
    203 
    204 // DesignatorNode::DesignatorNode( const DesignatorNode &other ) : ExpressionNode( other ), isArrayIndex( other.isArrayIndex ) {}
    205 
    206 // class DesignatorFixer : public Mutator {
    207 //   public:
    208 //      virtual Expression* mutate( NameExpr *nameExpr ) {
    209 //              if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
    210 //                      Constant val( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nameExpr->get_name() );
    211 //                      delete nameExpr;
    212 //                      return new ConstantExpr( val );
    213 //              }
    214 //              return nameExpr;
    215 //      }
    216 // };
    217 
    218 // Expression *DesignatorNode::build() const {
    219 //      return maybeBuild<Expression>(get_argName());
    220 // }
    221 
    222 // void DesignatorNode::printOneLine( std::ostream &os, int indent ) const {
    223 //      if ( get_argName() ) {
    224 //              if ( isArrayIndex ) {
    225 //                      os << "[";
    226 //                      get_argName()->printOneLine( os, indent );
    227 //                      os << "]";
    228 //              } else {
    229 //                      os << ".";
    230 //                      get_argName()->printOneLine( os, indent );
    231 //              }
    232 //      } // if
    233 // }
    234 
    235 // void DesignatorNode::print( std::ostream &os, int indent ) const {
    236 //      if ( get_argName() ) {
    237 //              if ( isArrayIndex ) {
    238 //                      os << "[";
    239 //                      get_argName()->print( os, indent );
    240 //                      os << "]";
    241 //              } else {
    242 //                      os << ".";
    243 //                      get_argName()->print( os, indent );
    244 //              }
    245 //      } // if
    246 // }
    247173
    248174//##############################################################################
     
    366292//##############################################################################
    367293
    368 // Expression *AsmExprNode::build() const {
    369 //      return new AsmExpr( maybeBuild< Expression >( inout ), (ConstantExpr *)maybeBuild<Expression>(constraint), maybeBuild<Expression>(operand) );
    370 // }
    371 
    372 // void AsmExprNode::print( std::ostream &os, int indent ) const {
    373 //      os << string( indent, ' ' ) << "Assembler Expression:" << endl;
    374 //      if ( inout ) {
    375 //              os << string( indent, ' ' ) << "inout: " << std::endl;
    376 //              inout->print( os, indent + 2 );
    377 //      } // if
    378 //      if ( constraint ) {
    379 //              os << string( indent, ' ' ) << "constraint: " << std::endl;
    380 //              constraint->print( os, indent + 2 );
    381 //      } // if
    382 //      if ( operand ) {
    383 //              os << string( indent, ' ' ) << "operand: " << std::endl;
    384 //              operand->print( os, indent + 2 );
    385 //      } // if
    386 // }
    387 
    388 // void AsmExprNode::printOneLine( std::ostream &os, int indent ) const {
    389 //      printDesignation( os );
    390 //      os << "( ";
    391 //      if ( inout ) inout->printOneLine( os, indent + 2 );
    392 //      os << ", ";
    393 //      if ( constraint ) constraint->printOneLine( os, indent + 2 );
    394 //      os << ", ";
    395 //      if ( operand ) operand->printOneLine( os, indent + 2 );
    396 //      os << ") ";
    397 // }
    398 
    399294Expression *build_asm( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) {
    400295        return new AsmExpr( maybeBuild< Expression >( inout ), constraint, maybeBuild<Expression>(operand) );
     
    409304//##############################################################################
    410305
    411 // ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {}
    412 
    413 // ValofExprNode::ValofExprNode( const ValofExprNode &other ) : ExpressionNode( other ), body( maybeClone( body ) ) {
    414 // }
    415 
    416 // ValofExprNode::~ValofExprNode() {
    417 //      delete body;
    418 // }
    419 
    420 // void ValofExprNode::print( std::ostream &os, int indent ) const {
    421 //      os << string( indent, ' ' ) << "Valof Expression:" << std::endl;
    422 //      get_body()->print( os, indent + 4);
    423 // }
    424 
    425 // void ValofExprNode::printOneLine( std::ostream &, int indent ) const {
    426 //      assert( false );
    427 // }
    428 
    429 // Expression *ValofExprNode::build() const {
    430 //      return new UntypedValofExpr( maybeBuild<Statement>(get_body()), nullptr );
    431 // }
    432 
    433306Expression *build_valexpr( StatementNode *s ) {
    434307        return new UntypedValofExpr( maybeBuild<Statement>(s), nullptr );
     
    436309
    437310//##############################################################################
    438 
    439 ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
    440         if ( init_ == 0 )
    441                 init = 0;
    442         else {
    443                 DeclarationNode *decl;
    444                 ExpressionNode *exp;
    445 
    446                 if (( decl = dynamic_cast<DeclarationNode *>(init_) ) != 0)
    447                         init = new StatementNode( decl );
    448                 else if (( exp = dynamic_cast<ExpressionNode *>( init_)) != 0)
    449                         init = new StatementNode( StatementNode::Exp, exp );
    450                 else
    451                         throw SemanticError("Error in for control expression");
    452         }
    453 }
    454 
    455 ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other )
    456         : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) {
    457 }
    458 
    459 ForCtlExprNode::~ForCtlExprNode() {
    460         delete init;
    461         delete condition;
    462         delete change;
    463 }
    464 
    465 Expression *ForCtlExprNode::build() const {
    466         // this shouldn't be used!
    467         assert( false );
    468         return 0;
    469 }
    470 
    471 void ForCtlExprNode::print( std::ostream &os, int indent ) const{
    472         os << string( indent,' ' ) << "For Control Expression -- :" << endl;
    473 
    474         os << string( indent + 2, ' ' ) << "initialization:" << endl;
    475         if ( init != 0 )
    476                 init->printList( os, indent + 4 );
    477 
    478         os << string( indent + 2, ' ' ) << "condition: " << endl;
    479         if ( condition != 0 )
    480                 condition->print( os, indent + 4 );
    481         os << string( indent + 2, ' ' ) << "increment: " << endl;
    482         if ( change != 0 )
    483                 change->print( os, indent + 4 );
    484 }
    485 
    486 void ForCtlExprNode::printOneLine( std::ostream &, int indent ) const {
    487         assert( false );
    488 }
    489 
    490 //##############################################################################
    491 
    492 // TypeValueNode::TypeValueNode( DeclarationNode *decl ) : decl( decl ) {
    493 // }
    494 
    495 // TypeValueNode::TypeValueNode( const TypeValueNode &other ) : ExpressionNode( other ), decl( maybeClone( other.decl ) ) {
    496 // }
    497 
    498 // Expression *TypeValueNode::build() const {
    499 //      return new TypeExpr( decl->buildType() );
    500 // }
    501 
    502 // void TypeValueNode::print( std::ostream &os, int indent ) const {
    503 //      os << std::string( indent, ' ' ) << "Type:";
    504 //      get_decl()->print( os, indent + 2);
    505 // }
    506 
    507 // void TypeValueNode::printOneLine( std::ostream &os, int indent ) const {
    508 //      os << "Type:";
    509 //      get_decl()->print( os, indent + 2);
    510 // }
     311 
     312// ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
     313//      if ( init_ == 0 )
     314//              init = 0;
     315//      else {
     316//              DeclarationNode *decl;
     317//              ExpressionNode *exp;
     318
     319//              if (( decl = dynamic_cast<DeclarationNode *>(init_) ) != 0)
     320//                      init = new StatementNode( decl );
     321//              else if (( exp = dynamic_cast<ExpressionNode *>( init_)) != 0)
     322//                      init = new StatementNode( StatementNode::Exp, exp );
     323//              else
     324//                      throw SemanticError("Error in for control expression");
     325//      }
     326// }
     327
     328// ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other )
     329//      : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) {
     330// }
     331
     332// ForCtlExprNode::~ForCtlExprNode() {
     333//      delete init;
     334//      delete condition;
     335//      delete change;
     336// }
     337
     338// Expression *ForCtlExprNode::build() const {
     339//      // this shouldn't be used!
     340//      assert( false );
     341//      return 0;
     342// }
     343
     344// void ForCtlExprNode::print( std::ostream &os, int indent ) const{
     345//      os << string( indent,' ' ) << "For Control Expression -- :" << endl;
     346
     347//      os << string( indent + 2, ' ' ) << "initialization:" << endl;
     348//      if ( init != 0 )
     349//              init->printList( os, indent + 4 );
     350
     351//      os << string( indent + 2, ' ' ) << "condition: " << endl;
     352//      if ( condition != 0 )
     353//              condition->print( os, indent + 4 );
     354//      os << string( indent + 2, ' ' ) << "increment: " << endl;
     355//      if ( change != 0 )
     356//              change->print( os, indent + 4 );
     357// }
     358
     359// void ForCtlExprNode::printOneLine( std::ostream &, int indent ) const {
     360//      assert( false );
     361// }
     362
     363//##############################################################################
    511364
    512365Expression *build_typevalue( DeclarationNode *decl ) {
     
    515368
    516369//##############################################################################
    517 
    518 // CompoundLiteralNode::CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids ) : type( type ), kids( kids ) {}
    519 // CompoundLiteralNode::CompoundLiteralNode( const CompoundLiteralNode &other ) : ExpressionNode( other ), type( other.type ), kids( other.kids ) {}
    520 
    521 // CompoundLiteralNode::~CompoundLiteralNode() {
    522 //      delete kids;
    523 //      delete type;
    524 // }
    525 
    526 // CompoundLiteralNode *CompoundLiteralNode::clone() const {
    527 //      return new CompoundLiteralNode( *this );
    528 // }
    529 
    530 // void CompoundLiteralNode::print( std::ostream &os, int indent ) const {
    531 //      os << string( indent,' ' ) << "CompoundLiteralNode:" << endl;
    532 
    533 //      os << string( indent + 2, ' ' ) << "type:" << endl;
    534 //      if ( type != 0 )
    535 //              type->print( os, indent + 4 );
    536 
    537 //      os << string( indent + 2, ' ' ) << "initialization:" << endl;
    538 //      if ( kids != 0 )
    539 //              kids->printList( os, indent + 4 );
    540 // }
    541 
    542 // void CompoundLiteralNode::printOneLine( std::ostream &os, int indent ) const {
    543 //      os << "( ";
    544 //      if ( type ) type->print( os );
    545 //      os << ", ";
    546 //      if ( kids ) kids->printOneLine( os );
    547 //      os << ") ";
    548 // }
    549 
    550 // Expression *CompoundLiteralNode::build() const {
    551 //      Declaration * newDecl = maybeBuild<Declaration>(type); // compound literal type
    552 //      if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
    553 //              return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeBuild<Initializer>(kids) );
    554 //      // these types do not have associated type information
    555 //      } else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
    556 //              return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeBuild<Initializer>(kids) );
    557 //      } else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
    558 //              return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeBuild<Initializer>(kids) );
    559 //      } else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
    560 //              return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild<Initializer>(kids) );
    561 //      } else {
    562 //              assert( false );
    563 //      } // if
    564 // }
    565370
    566371Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids ) {
  • src/Parser/ParseNode.h

    ra6dd5b0 r2f22cc4  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug  9 12:28:12 2016
    13 // Update Count     : 389
     12// Last Modified On : Wed Aug 10 13:08:46 2016
     13// Update Count     : 436
    1414//
    1515
     
    2626#include "SynTree/Type.h"
    2727#include "SynTree/Expression.h"
     28#include "SynTree/Statement.h"
    2829//#include "SynTree/Declaration.h"
    2930#include "Common/UniqueName.h"
     
    5758        virtual void printList( std::ostream &os, int indent = 0 ) const;
    5859
    59         ParseNode &operator,( ParseNode &);
     60        ParseNode &operator,( ParseNode & );
    6061  protected:
    6162        std::string name;
     
    134135//##############################################################################
    135136
    136 // NullExprNode is used in tuples as a place-holder where a tuple component is omitted e.g., [ 2, , 3 ]
    137 // class NullExprNode : public ExpressionNode {
    138 //   public:
    139 //      NullExprNode() {}
    140 
    141 //      virtual NullExprNode *clone() const { assert( false ); }
    142 
    143 //      virtual void print( std::ostream &os, int indent = 0) const {}
    144 //      virtual void printOneLine( std::ostream &os, int indent = 0) const {}
    145 
    146 //      virtual Expression *build() const { assert( false ); return 0; }
    147 // };
    148 
    149 //##############################################################################
    150 
    151 // class ConstantNode : public ExpressionNode {
    152 //   public:
    153 //      ConstantNode( ConstantExpr *expr ) : expr( expr ) {}
    154 //      ConstantNode( const ConstantNode &other ) : expr( other.expr->clone() ) {}
    155 //      virtual ~ConstantNode() {}
    156 
    157 //      virtual ConstantNode *clone() const { assert( false ); return new ConstantNode( *this ); }
    158 
    159 //      ConstantExpr *get_expr() const { return expr; }
    160 
    161 //      virtual void print( std::ostream &os, int indent = 0 ) const {}
    162 //      virtual void printOneLine( std::ostream &os, int indent = 0 ) const {}
    163 
    164 //      Expression *build() const { return expr; }
    165 //   private:
    166 //      ConstantExpr *expr;
    167 // };
    168 
    169137Expression *build_constantInteger( std::string &str );
    170138Expression *build_constantFloat( std::string &str );
     
    174142//##############################################################################
    175143
    176 // class VarRefNode : public ExpressionNode {
    177 //   public:
    178 //      VarRefNode( const std::string *, bool isLabel = false );
    179 //      VarRefNode( const VarRefNode &other );
    180 
    181 //      virtual Expression *build() const ;
    182 
    183 //      virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
    184 
    185 //      virtual void print( std::ostream &os, int indent = 0 ) const;
    186 //      virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
    187 //   private:
    188 //      bool isLabel;
    189 // };
    190 
    191144NameExpr *build_varref( const std::string *name, bool labelp = false );
    192145
    193146//##############################################################################
    194147
    195 // class DesignatorNode : public ExpressionNode {
    196 //   public:
    197 //      DesignatorNode( ExpressionNode *expr, bool isArrayIndex = false );
    198 //      DesignatorNode( const DesignatorNode &other );
    199 
    200 //      virtual Expression *build() const ;
    201 //      virtual DesignatorNode *clone() const { return new DesignatorNode( *this ); }
    202 
    203 //      virtual void print( std::ostream &os, int indent = 0 ) const;
    204 //      virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
    205 //   private:
    206 //      bool isArrayIndex;
    207 // };
    208 
    209 //##############################################################################
    210 
    211 // class TypeValueNode : public ExpressionNode {
    212 //   public:
    213 //      TypeValueNode( DeclarationNode * );
    214 //      TypeValueNode( const TypeValueNode &other );
    215 
    216 //      DeclarationNode *get_decl() const { return decl; }
    217 
    218 //      virtual Expression *build() const ;
    219 
    220 //      virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }
    221 
    222 //      virtual void print( std::ostream &os, int indent = 0) const;
    223 //      virtual void printOneLine( std::ostream &os, int indent = 0) const;
    224 //   private:
    225 //      DeclarationNode *decl;
    226 // };
    227 
    228148Expression *build_typevalue( DeclarationNode *decl );
    229149
    230150//##############################################################################
    231 
    232 // class CompositeExprNode : public ExpressionNode {
    233 //   public:
    234 //      CompositeExprNode( Expression *expr ) : expr( expr ) {}
    235 //      CompositeExprNode( const CompositeExprNode &other ) : expr( other.expr->clone() ) {}
    236 //      virtual ~CompositeExprNode() {}
    237 
    238 //      CompositeExprNode *clone() const { assert( false ); return new CompositeExprNode( *this ); }
    239 
    240 //      Expression *build() const { return expr; }
    241 
    242 //      void print( std::ostream &os, int indent = 0 ) const {}
    243 //      void printOneLine( std::ostream &os, int indent = 0 ) const {}
    244 //   private:
    245 //      Expression *expr;
    246 // };
    247151
    248152enum class OperKinds {
     
    282186//##############################################################################
    283187
    284 // class AsmExprNode : public ExpressionNode {
    285 //   public:
    286 //      AsmExprNode();
    287 //      AsmExprNode( ExpressionNode *inout, ConstantNode *constraint, ExpressionNode *operand ) : inout( inout ), constraint( constraint ), operand( operand ) {}
    288 //      virtual ~AsmExprNode() { delete inout; delete constraint; delete operand; }
    289 
    290 //      virtual AsmExprNode *clone() const { return new AsmExprNode( *this ); }
    291 //      virtual Expression *build() const;
    292 
    293 //      virtual void print( std::ostream &os, int indent = 0) const;
    294 //      virtual void printOneLine( std::ostream &os, int indent = 0) const;
    295 
    296 //      ExpressionNode *get_inout() const { return inout; };
    297 //      void set_inout( ExpressionNode *newValue ) { inout = newValue; }
    298 
    299 //      ConstantNode *get_constraint() const { return constraint; };
    300 //      void set_constraint( ConstantNode *newValue ) { constraint = newValue; }
    301 
    302 //      ExpressionNode *get_operand() const { return operand; };
    303 //      void set_operand( ExpressionNode *newValue ) { operand = newValue; }
    304 //   private:
    305 //      ExpressionNode *inout;
    306 //      ConstantNode *constraint;
    307 //      ExpressionNode *operand;
    308 // };
    309 
    310188Expression *build_asm( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand );
    311189
     
    328206//##############################################################################
    329207
    330 class ForCtlExprNode : public ExpressionNode {
    331   public:
    332         ForCtlExprNode( ParseNode *, ExpressionNode *, ExpressionNode * ) throw ( SemanticError );
    333         ForCtlExprNode( const ForCtlExprNode &other );
    334         ~ForCtlExprNode();
    335 
    336         StatementNode *get_init() const { return init; }
    337         ExpressionNode *get_condition() const { return condition; }
    338         ExpressionNode *get_change() const { return change; }
    339 
    340         virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); }
    341         virtual Expression *build() const;
    342 
    343         virtual void print( std::ostream &os, int indent = 0 ) const;
    344         virtual void printOneLine( std::ostream &os, int indent = 0 ) const;
    345   private:
    346         StatementNode *init;
    347         ExpressionNode *condition;
    348         ExpressionNode *change;
    349 };
    350 
    351 //##############################################################################
    352 
    353 // class ValofExprNode : public ExpressionNode {
    354 //   public:
    355 //      ValofExprNode();
    356 //      ValofExprNode( StatementNode *s = 0 );
    357 //      ValofExprNode( const ValofExprNode &other );
    358 //      ~ValofExprNode();
    359 
    360 //      virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
    361 
    362 //      StatementNode *get_body() const { return body; }
    363 //      void print( std::ostream &os, int indent = 0 ) const;
    364 //      void printOneLine( std::ostream &os, int indent = 0 ) const;
    365 //      Expression *build() const;
    366 
    367 //   private:
    368 //      StatementNode *body;
    369 // };
    370 
    371208Expression *build_valexpr( StatementNode *s );
    372209
    373210//##############################################################################
    374 
    375 // class CompoundLiteralNode : public ExpressionNode {
    376 //   public:
    377 //      CompoundLiteralNode( DeclarationNode *type, InitializerNode *kids );
    378 //      CompoundLiteralNode( const CompoundLiteralNode &type );
    379 //      ~CompoundLiteralNode();
    380 
    381 //      virtual CompoundLiteralNode *clone() const;
    382 
    383 //      DeclarationNode *get_type() const { return type; }
    384 //      CompoundLiteralNode *set_type( DeclarationNode *t ) { type = t; return this; }
    385 
    386 //      InitializerNode *get_initializer() const { return kids; }
    387 //      CompoundLiteralNode *set_initializer( InitializerNode *k ) { kids = k; return this; }
    388 
    389 //      void print( std::ostream &os, int indent = 0 ) const;
    390 //      void printOneLine( std::ostream &os, int indent = 0 ) const;
    391 
    392 //      virtual Expression *build() const;
    393 //   private:
    394 //      DeclarationNode *type;
    395 //      InitializerNode *kids;
    396 // };
    397211
    398212Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids );
     
    531345        static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
    532346
    533         StatementNode *set_block( StatementNode *b ) {  block = b; return this; }
     347        StatementNode *set_block( StatementNode *b ) { block = b; return this; }
    534348        StatementNode *get_block() const { return block; }
    535349
     
    539353        StatementNode::Type get_type() const { return type; }
    540354
    541         StatementNode *add_label( const std::string * );
    542         const std::list<std::string> &get_labels() const { return labels; }
     355        virtual StatementNode *add_label( const std::string * );
     356        virtual std::list<std::string> get_labels() const { return labels; }
    543357
    544358        void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
     
    565379}; // StatementNode
    566380
     381class StatementNode2 : public StatementNode {
     382  public:
     383        StatementNode2() {}
     384        StatementNode2( Statement *stmt ) : stmt( stmt ) {}
     385        virtual ~StatementNode2() {}
     386
     387        virtual StatementNode2 *clone() const { assert( false ); return nullptr; }
     388        virtual Statement *build() const { return stmt; }
     389
     390        virtual StatementNode2 *add_label( const std::string * name ) {
     391                stmt->get_labels().emplace_back( *name );
     392                return this;
     393        }
     394        virtual std::list<std::string> get_labels() const { assert( false ); return StatementNode::get_labels(); }
     395
     396        virtual void print( std::ostream &os, int indent = 0 ) {}
     397        virtual void printList( std::ostream &os, int indent = 0 ) {}
     398  private:
     399        Statement *stmt;
     400}; // StatementNode
     401
     402struct ForCtl {
     403        ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
     404                init( new StatementNode( StatementNode::Exp, expr ) ), condition( condition ), change( change ) {}
     405        ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
     406                init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
     407
     408        StatementNode *init;
     409        ExpressionNode *condition;
     410        ExpressionNode *change;
     411};
     412
     413Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
     414Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
     415Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind = false );
     416Statement *build_for( ForCtl *forctl, StatementNode *stmt );
     417
    567418//##############################################################################
    568419
     
    602453
    603454template< typename SynTreeType, typename NodeType >
    604 void buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList ) {
     455void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
    605456        SemanticError errors;
    606457        std::back_insert_iterator< std::list< SynTreeType *> > out( outputList );
  • src/Parser/StatementNode.cc

    ra6dd5b0 r2f22cc4  
    1010// Created On       : Sat May 16 14:59:41 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug  9 10:14:33 2016
    13 // Update Count     : 141
     12// Last Modified On : Wed Aug 10 13:54:21 2016
     13// Update Count     : 170
    1414//
    1515
     
    206206                }
    207207          case If:
    208                 {
    209                         Statement *thenb = 0, *elseb = 0;
    210                         assert( branches.size() >= 1 );
    211 
    212                         thenb = branches.front();
    213                         branches.pop_front();
    214                         if ( ! branches.empty() ) {
    215                                 elseb = branches.front();
    216                                 branches.pop_front();
    217                         } // if
    218                         return new IfStmt( labs, notZeroExpr( maybeBuild<Expression>(get_control()) ), thenb, elseb );
    219                 }
    220           case While:
    221                 assert( branches.size() == 1 );
    222                 return new WhileStmt( labs, notZeroExpr( maybeBuild<Expression>(get_control()) ), branches.front() );
    223           case Do:
    224                 assert( branches.size() == 1 );
    225                 return new WhileStmt( labs, notZeroExpr( maybeBuild<Expression>(get_control()) ), branches.front(), true );
    226           case For:
    227                 {
    228                         assert( branches.size() == 1 );
    229 
    230                         ForCtlExprNode *ctl = dynamic_cast<ForCtlExprNode *>( get_control() );
    231                         assert( ctl != 0 );
    232 
    233                         std::list<Statement *> init;
    234                         if ( ctl->get_init() != 0 ) {
    235                                 buildList( ctl->get_init(), init );
    236                         } // if
    237 
    238                         Expression *cond = 0;
    239                         if ( ctl->get_condition() != 0 )
    240                                 cond = notZeroExpr( maybeBuild<Expression>(ctl->get_condition()) );
    241 
    242                         Expression *incr = 0;
    243                         if ( ctl->get_change() != 0 )
    244                                 incr = maybeBuild<Expression>(ctl->get_change());
    245 
    246                         return new ForStmt( labs, init, cond, incr, branches.front() );
    247                 }
     208                // {
     209                //      Statement *thenb = 0, *elseb = 0;
     210                //      assert( branches.size() >= 1 );
     211
     212                //      thenb = branches.front();
     213                //      branches.pop_front();
     214                //      if ( ! branches.empty() ) {
     215                //              elseb = branches.front();
     216                //              branches.pop_front();
     217                //      } // if
     218                //      return new IfStmt( labs, notZeroExpr( maybeBuild<Expression>(get_control()) ), thenb, elseb );
     219                // }
     220                assert( false );
    248221          case Switch:
    249                 return new SwitchStmt( labs, maybeBuild<Expression>(get_control()), branches );
     222                //return new SwitchStmt( labs, maybeBuild<Expression>(get_control()), branches );
     223                assert( false );
    250224          case Case:
    251                 return new CaseStmt( labs, maybeBuild<Expression>(get_control()), branches );
     225                return new CaseStmt( labs, maybeBuild<Expression>(get_control() ), branches );
    252226          case Default:
    253227                return new CaseStmt( labs, 0, branches, true );
     228          case While:
     229                // assert( branches.size() == 1 );
     230                // return new WhileStmt( labs, notZeroExpr( maybeBuild<Expression>(get_control()) ), branches.front() );
     231                assert( false );
     232          case Do:
     233                // assert( branches.size() == 1 );
     234                // return new WhileStmt( labs, notZeroExpr( maybeBuild<Expression>(get_control()) ), branches.front(), true );
     235                assert( false );
     236          case For:
     237                // {
     238                //      assert( branches.size() == 1 );
     239
     240                //      ForCtlExprNode *ctl = dynamic_cast<ForCtlExprNode *>( get_control() );
     241                //      assert( ctl != 0 );
     242
     243                //      std::list<Statement *> init;
     244                //      if ( ctl->get_init() != 0 ) {
     245                //              buildList( ctl->get_init(), init );
     246                //      } // if
     247
     248                //      Expression *cond = 0;
     249                //      if ( ctl->get_condition() != 0 )
     250                //              cond = notZeroExpr( maybeBuild<Expression>(ctl->get_condition()) );
     251
     252                //      Expression *incr = 0;
     253                //      if ( ctl->get_change() != 0 )
     254                //              incr = maybeBuild<Expression>(ctl->get_change());
     255
     256                //      return new ForStmt( labs, init, cond, incr, branches.front() );
     257                // }
     258                assert( false );
    254259          case Goto:
    255260                {
     
    305310}
    306311
     312Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt ) {
     313        Statement *thenb, *elseb = 0;
     314        std::list<Statement *> branches;
     315        buildList<Statement, StatementNode>( then_stmt, branches );
     316        assert( branches.size() >= 1 );
     317        thenb = branches.front();
     318
     319        if ( else_stmt ) {
     320                std::list<Statement *> branches;
     321                buildList<Statement, StatementNode>( else_stmt, branches );
     322                assert( branches.size() >= 1 );
     323                elseb = branches.front();
     324        } // if
     325        return new IfStmt( noLabels, notZeroExpr( maybeBuild<Expression>(ctl) ), thenb, elseb );
     326}
     327
     328Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ) {
     329        std::list<Statement *> branches;
     330        buildList<Statement, StatementNode>( stmt, branches );
     331        assert( branches.size() >= 1 );
     332        return new SwitchStmt( noLabels, maybeBuild<Expression>(ctl), branches );
     333}
     334
     335Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind ) {
     336        std::list<Statement *> branches;
     337        buildList<Statement, StatementNode>( stmt, branches );
     338        assert( branches.size() == 1 );
     339        return new WhileStmt( noLabels, notZeroExpr( maybeBuild<Expression>(ctl) ), branches.front(), kind );
     340}
     341
     342Statement *build_for( ForCtl *forctl, StatementNode *stmt ) {
     343        std::list<Statement *> branches;
     344        buildList<Statement, StatementNode>( stmt, branches );
     345        assert( branches.size() == 1 );
     346
     347        std::list<Statement *> init;
     348        if ( forctl->init != 0 ) {
     349                buildList( forctl->init, init );
     350        } // if
     351
     352        Expression *cond = 0;
     353        if ( forctl->condition != 0 )
     354                cond = notZeroExpr( maybeBuild<Expression>(forctl->condition) );
     355
     356        Expression *incr = 0;
     357        if ( forctl->change != 0 )
     358                incr = maybeBuild<Expression>(forctl->change);
     359
     360        delete forctl;
     361        return new ForStmt( noLabels, init, cond, incr, branches.front() );
     362}
     363
    307364
    308365CompoundStmtNode::CompoundStmtNode() : first( 0 ), last( 0 ) {}
  • src/Parser/parser.cc

    ra6dd5b0 r2f22cc4  
    357357        StatementNode *sn;
    358358        ConstantExpr *constant;
     359        ForCtl *fctl;
    359360        LabelNode *label;
    360361        InitializerNode *in;
     
    365366
    366367/* Line 293 of yacc.c  */
    367 #line 368 "Parser/parser.cc"
     368#line 369 "Parser/parser.cc"
    368369} YYSTYPE;
    369370# define YYSTYPE_IS_TRIVIAL 1
     
    377378
    378379/* Line 343 of yacc.c  */
    379 #line 380 "Parser/parser.cc"
     380#line 381 "Parser/parser.cc"
    380381
    381382#ifdef short
     
    10191020static const yytype_uint16 yyrline[] =
    10201021{
    1021        0,   296,   296,   302,   311,   312,   313,   317,   318,   319,
    1022      323,   324,   328,   329,   333,   334,   338,   339,   350,   352,
    1023      354,   356,   361,   362,   368,   372,   374,   375,   377,   378,
    1024      380,   382,   384,   393,   394,   400,   401,   405,   406,   410,
    1025      414,   416,   418,   420,   425,   428,   430,   432,   437,   450,
    1026      452,   454,   456,   458,   460,   462,   464,   466,   468,   470,
    1027      477,   478,   484,   485,   486,   487,   491,   492,   494,   499,
    1028      500,   502,   504,   509,   510,   512,   517,   518,   520,   525,
    1029      526,   528,   530,   532,   537,   538,   540,   545,   546,   551,
    1030      552,   557,   558,   563,   564,   569,   570,   575,   576,   579,
    1031      581,   586,   591,   592,   594,   600,   601,   605,   606,   607,
    1032      608,   609,   610,   611,   612,   613,   614,   615,   621,   623,
    1033      625,   627,   632,   633,   638,   639,   645,   646,   652,   653,
    1034      654,   655,   656,   657,   658,   659,   660,   670,   677,   679,
    1035      689,   690,   695,   697,   703,   705,   709,   710,   715,   720,
    1036      723,   725,   727,   737,   739,   750,   751,   753,   757,   759,
    1037      763,   764,   769,   770,   774,   779,   780,   784,   786,   792,
    1038      793,   797,   799,   801,   803,   809,   810,   814,   816,   821,
    1039      823,   825,   830,   832,   837,   839,   843,   846,   850,   853,
    1040      857,   859,   863,   865,   872,   874,   876,   885,   887,   889,
    1041      891,   893,   898,   900,   902,   904,   909,   922,   923,   928,
    1042      930,   935,   939,   941,   943,   945,   947,   953,   954,   960,
    1043      961,   965,   966,   971,   973,   979,   980,   982,   987,   989,
    1044      996,   998,  1002,  1003,  1008,  1010,  1014,  1015,  1019,  1021,
    1045     1025,  1026,  1030,  1031,  1035,  1036,  1051,  1052,  1053,  1054,
    1046     1055,  1059,  1064,  1071,  1081,  1086,  1091,  1099,  1104,  1109,
    1047     1114,  1119,  1127,  1149,  1154,  1161,  1163,  1170,  1175,  1180,
    1048     1191,  1196,  1201,  1206,  1211,  1220,  1225,  1233,  1234,  1235,
    1049     1236,  1242,  1247,  1255,  1256,  1257,  1258,  1262,  1263,  1264,
    1050     1265,  1270,  1271,  1280,  1281,  1286,  1287,  1292,  1294,  1296,
    1051     1298,  1300,  1303,  1302,  1314,  1315,  1317,  1327,  1328,  1333,
    1052     1337,  1339,  1341,  1343,  1345,  1347,  1349,  1351,  1356,  1358,
    1053     1360,  1362,  1364,  1366,  1368,  1370,  1372,  1374,  1376,  1378,
    1054     1380,  1386,  1387,  1389,  1391,  1393,  1398,  1399,  1405,  1406,
    1055     1408,  1410,  1415,  1417,  1419,  1421,  1426,  1427,  1429,  1431,
    1056     1436,  1437,  1439,  1444,  1445,  1447,  1449,  1454,  1456,  1458,
    1057     1463,  1464,  1468,  1470,  1476,  1475,  1479,  1481,  1486,  1488,
    1058     1494,  1495,  1500,  1501,  1503,  1504,  1513,  1514,  1516,  1518,
    1059     1523,  1525,  1531,  1532,  1534,  1537,  1540,  1545,  1546,  1551,
    1060     1556,  1560,  1562,  1568,  1567,  1574,  1576,  1582,  1583,  1591,
    1061     1592,  1596,  1597,  1598,  1600,  1602,  1609,  1610,  1612,  1614,
    1062     1619,  1620,  1626,  1627,  1631,  1632,  1637,  1638,  1639,  1641,
    1063     1649,  1650,  1652,  1655,  1657,  1661,  1662,  1663,  1665,  1667,
    1064     1671,  1676,  1684,  1685,  1694,  1696,  1701,  1702,  1703,  1707,
    1065     1708,  1709,  1713,  1714,  1715,  1719,  1720,  1721,  1726,  1727,
    1066     1728,  1729,  1735,  1736,  1738,  1743,  1744,  1749,  1750,  1751,
    1067     1752,  1753,  1768,  1769,  1774,  1775,  1781,  1783,  1786,  1788,
    1068     1790,  1813,  1814,  1816,  1818,  1823,  1824,  1826,  1831,  1836,
    1069     1837,  1843,  1842,  1846,  1850,  1852,  1854,  1860,  1861,  1866,
    1070     1871,  1873,  1878,  1880,  1881,  1883,  1888,  1890,  1892,  1897,
    1071     1899,  1904,  1909,  1917,  1923,  1922,  1936,  1937,  1942,  1943,
    1072     1947,  1952,  1957,  1965,  1970,  1981,  1982,  1993,  1994,  2000,
    1073     2001,  2005,  2006,  2007,  2010,  2009,  2020,  2029,  2035,  2041,
    1074     2050,  2056,  2062,  2068,  2074,  2082,  2088,  2096,  2102,  2111,
    1075     2112,  2113,  2117,  2121,  2123,  2128,  2129,  2133,  2134,  2139,
    1076     2145,  2146,  2149,  2151,  2152,  2156,  2157,  2158,  2159,  2193,
    1077     2195,  2196,  2198,  2203,  2208,  2213,  2215,  2217,  2222,  2224,
    1078     2226,  2228,  2233,  2235,  2244,  2246,  2247,  2252,  2254,  2256,
    1079     2261,  2263,  2265,  2270,  2272,  2274,  2283,  2284,  2285,  2289,
    1080     2291,  2293,  2298,  2300,  2302,  2307,  2309,  2311,  2326,  2328,
    1081     2329,  2331,  2336,  2337,  2342,  2344,  2346,  2351,  2353,  2355,
    1082     2357,  2362,  2364,  2366,  2376,  2378,  2379,  2381,  2386,  2388,
    1083     2390,  2395,  2397,  2399,  2401,  2406,  2408,  2410,  2441,  2443,
    1084     2444,  2446,  2451,  2456,  2464,  2466,  2468,  2473,  2475,  2480,
    1085     2482,  2496,  2497,  2499,  2504,  2506,  2508,  2510,  2512,  2517,
    1086     2518,  2520,  2522,  2527,  2529,  2531,  2537,  2539,  2541,  2545,
    1087     2547,  2549,  2551,  2565,  2566,  2568,  2573,  2575,  2577,  2579,
    1088     2581,  2586,  2587,  2589,  2591,  2596,  2598,  2600,  2606,  2607,
    1089     2609,  2618,  2621,  2623,  2626,  2628,  2630,  2643,  2644,  2646,
    1090     2651,  2653,  2655,  2657,  2659,  2664,  2665,  2667,  2669,  2674,
    1091     2676,  2684,  2685,  2686,  2691,  2692,  2696,  2698,  2700,  2702,
    1092     2704,  2706,  2713,  2715,  2717,  2719,  2721,  2723,  2725,  2727,
    1093     2729,  2731,  2736,  2738,  2740,  2745,  2771,  2772,  2774,  2778,
    1094     2779,  2783,  2785,  2787,  2789,  2791,  2793,  2800,  2802,  2804,
    1095     2806,  2808,  2810,  2815,  2820,  2822,  2824,  2842,  2844,  2849,
    1096     2850
     1022       0,   299,   299,   305,   314,   315,   316,   320,   321,   322,
     1023     326,   327,   331,   332,   336,   337,   341,   342,   353,   355,
     1024     357,   359,   364,   365,   371,   375,   377,   378,   380,   381,
     1025     383,   385,   387,   396,   397,   403,   404,   408,   409,   413,
     1026     417,   419,   421,   423,   428,   431,   433,   435,   440,   453,
     1027     455,   457,   459,   461,   463,   465,   467,   469,   471,   473,
     1028     480,   481,   487,   488,   489,   490,   494,   495,   497,   502,
     1029     503,   505,   507,   512,   513,   515,   520,   521,   523,   528,
     1030     529,   531,   533,   535,   540,   541,   543,   548,   549,   554,
     1031     555,   560,   561,   566,   567,   572,   573,   578,   579,   582,
     1032     584,   589,   594,   595,   597,   603,   604,   608,   609,   610,
     1033     611,   612,   613,   614,   615,   616,   617,   618,   624,   626,
     1034     628,   630,   635,   636,   641,   642,   648,   649,   655,   656,
     1035     657,   658,   659,   660,   661,   662,   663,   673,   680,   682,
     1036     692,   693,   698,   700,   706,   708,   712,   713,   718,   723,
     1037     727,   730,   733,   743,   746,   758,   759,   761,   765,   767,
     1038     771,   772,   777,   778,   782,   787,   788,   792,   794,   800,
     1039     801,   805,   807,   809,   811,   817,   818,   822,   824,   829,
     1040     831,   833,   838,   840,   845,   847,   851,   854,   858,   861,
     1041     865,   867,   871,   873,   880,   882,   884,   893,   895,   897,
     1042     899,   901,   906,   908,   910,   912,   917,   930,   931,   936,
     1043     938,   943,   947,   949,   951,   953,   955,   961,   962,   968,
     1044     969,   973,   974,   979,   981,   987,   988,   990,   995,   997,
     1045    1004,  1006,  1010,  1011,  1016,  1018,  1022,  1023,  1027,  1029,
     1046    1033,  1034,  1038,  1039,  1043,  1044,  1059,  1060,  1061,  1062,
     1047    1063,  1067,  1072,  1079,  1089,  1094,  1099,  1107,  1112,  1117,
     1048    1122,  1127,  1135,  1157,  1162,  1169,  1171,  1178,  1183,  1188,
     1049    1199,  1204,  1209,  1214,  1219,  1228,  1233,  1241,  1242,  1243,
     1050    1244,  1250,  1255,  1263,  1264,  1265,  1266,  1270,  1271,  1272,
     1051    1273,  1278,  1279,  1288,  1289,  1294,  1295,  1300,  1302,  1304,
     1052    1306,  1308,  1311,  1310,  1322,  1323,  1325,  1335,  1336,  1341,
     1053    1345,  1347,  1349,  1351,  1353,  1355,  1357,  1359,  1364,  1366,
     1054    1368,  1370,  1372,  1374,  1376,  1378,  1380,  1382,  1384,  1386,
     1055    1388,  1394,  1395,  1397,  1399,  1401,  1406,  1407,  1413,  1414,
     1056    1416,  1418,  1423,  1425,  1427,  1429,  1434,  1435,  1437,  1439,
     1057    1444,  1445,  1447,  1452,  1453,  1455,  1457,  1462,  1464,  1466,
     1058    1471,  1472,  1476,  1478,  1484,  1483,  1487,  1489,  1494,  1496,
     1059    1502,  1503,  1508,  1509,  1511,  1512,  1521,  1522,  1524,  1526,
     1060    1531,  1533,  1539,  1540,  1542,  1545,  1548,  1553,  1554,  1559,
     1061    1564,  1568,  1570,  1576,  1575,  1582,  1584,  1590,  1591,  1599,
     1062    1600,  1604,  1605,  1606,  1608,  1610,  1617,  1618,  1620,  1622,
     1063    1627,  1628,  1634,  1635,  1639,  1640,  1645,  1646,  1647,  1649,
     1064    1657,  1658,  1660,  1663,  1665,  1669,  1670,  1671,  1673,  1675,
     1065    1679,  1684,  1692,  1693,  1702,  1704,  1709,  1710,  1711,  1715,
     1066    1716,  1717,  1721,  1722,  1723,  1727,  1728,  1729,  1734,  1735,
     1067    1736,  1737,  1743,  1744,  1746,  1751,  1752,  1757,  1758,  1759,
     1068    1760,  1761,  1776,  1777,  1782,  1783,  1789,  1791,  1794,  1796,
     1069    1798,  1821,  1822,  1824,  1826,  1831,  1832,  1834,  1839,  1844,
     1070    1845,  1851,  1850,  1854,  1858,  1860,  1862,  1868,  1869,  1874,
     1071    1879,  1881,  1886,  1888,  1889,  1891,  1896,  1898,  1900,  1905,
     1072    1907,  1912,  1917,  1925,  1931,  1930,  1944,  1945,  1950,  1951,
     1073    1955,  1960,  1965,  1973,  1978,  1989,  1990,  2001,  2002,  2008,
     1074    2009,  2013,  2014,  2015,  2018,  2017,  2028,  2037,  2043,  2049,
     1075    2058,  2064,  2070,  2076,  2082,  2090,  2096,  2104,  2110,  2119,
     1076    2120,  2121,  2125,  2129,  2131,  2136,  2137,  2141,  2142,  2147,
     1077    2153,  2154,  2157,  2159,  2160,  2164,  2165,  2166,  2167,  2201,
     1078    2203,  2204,  2206,  2211,  2216,  2221,  2223,  2225,  2230,  2232,
     1079    2234,  2236,  2241,  2243,  2252,  2254,  2255,  2260,  2262,  2264,
     1080    2269,  2271,  2273,  2278,  2280,  2282,  2291,  2292,  2293,  2297,
     1081    2299,  2301,  2306,  2308,  2310,  2315,  2317,  2319,  2334,  2336,
     1082    2337,  2339,  2344,  2345,  2350,  2352,  2354,  2359,  2361,  2363,
     1083    2365,  2370,  2372,  2374,  2384,  2386,  2387,  2389,  2394,  2396,
     1084    2398,  2403,  2405,  2407,  2409,  2414,  2416,  2418,  2449,  2451,
     1085    2452,  2454,  2459,  2464,  2472,  2474,  2476,  2481,  2483,  2488,
     1086    2490,  2504,  2505,  2507,  2512,  2514,  2516,  2518,  2520,  2525,
     1087    2526,  2528,  2530,  2535,  2537,  2539,  2545,  2547,  2549,  2553,
     1088    2555,  2557,  2559,  2573,  2574,  2576,  2581,  2583,  2585,  2587,
     1089    2589,  2594,  2595,  2597,  2599,  2604,  2606,  2608,  2614,  2615,
     1090    2617,  2626,  2629,  2631,  2634,  2636,  2638,  2651,  2652,  2654,
     1091    2659,  2661,  2663,  2665,  2667,  2672,  2673,  2675,  2677,  2682,
     1092    2684,  2692,  2693,  2694,  2699,  2700,  2704,  2706,  2708,  2710,
     1093    2712,  2714,  2721,  2723,  2725,  2727,  2729,  2731,  2733,  2735,
     1094    2737,  2739,  2744,  2746,  2748,  2753,  2779,  2780,  2782,  2786,
     1095    2787,  2791,  2793,  2795,  2797,  2799,  2801,  2808,  2810,  2812,
     1096    2814,  2816,  2818,  2823,  2828,  2830,  2832,  2850,  2852,  2857,
     1097    2858
    10971098};
    10981099#endif
     
    49594960
    49604961/* Line 1806 of yacc.c  */
    4961 #line 296 "parser.yy"
     4962#line 299 "parser.yy"
    49624963    {
    49634964                        typedefTable.enterScope();
     
    49684969
    49694970/* Line 1806 of yacc.c  */
    4970 #line 302 "parser.yy"
     4971#line 305 "parser.yy"
    49714972    {
    49724973                        typedefTable.leaveScope();
     
    49774978
    49784979/* Line 1806 of yacc.c  */
    4979 #line 311 "parser.yy"
     4980#line 314 "parser.yy"
    49804981    { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
    49814982    break;
     
    49844985
    49854986/* Line 1806 of yacc.c  */
    4986 #line 312 "parser.yy"
     4987#line 315 "parser.yy"
    49874988    { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
    49884989    break;
     
    49914992
    49924993/* Line 1806 of yacc.c  */
    4993 #line 313 "parser.yy"
     4994#line 316 "parser.yy"
    49944995    { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); }
    49954996    break;
     
    49984999
    49995000/* Line 1806 of yacc.c  */
    5000 #line 338 "parser.yy"
     5001#line 341 "parser.yy"
    50015002    { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].tok) ); }
    50025003    break;
     
    50055006
    50065007/* Line 1806 of yacc.c  */
    5007 #line 340 "parser.yy"
     5008#line 343 "parser.yy"
    50085009    {
    50095010                        appendStr( (yyvsp[(1) - (2)].constant)->get_constant()->get_value(), (yyvsp[(2) - (2)].tok) );
     
    50165017
    50175018/* Line 1806 of yacc.c  */
    5018 #line 351 "parser.yy"
     5019#line 354 "parser.yy"
    50195020    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    50205021    break;
     
    50235024
    50245025/* Line 1806 of yacc.c  */
    5025 #line 353 "parser.yy"
     5026#line 356 "parser.yy"
    50265027    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    50275028    break;
     
    50305031
    50315032/* Line 1806 of yacc.c  */
    5032 #line 355 "parser.yy"
     5033#line 358 "parser.yy"
    50335034    { (yyval.en) = (yyvsp[(2) - (3)].en); }
    50345035    break;
     
    50375038
    50385039/* Line 1806 of yacc.c  */
    5039 #line 357 "parser.yy"
     5040#line 360 "parser.yy"
    50405041    { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); }
    50415042    break;
     
    50445045
    50455046/* Line 1806 of yacc.c  */
    5046 #line 367 "parser.yy"
     5047#line 370 "parser.yy"
    50475048    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
    50485049    break;
     
    50515052
    50525053/* Line 1806 of yacc.c  */
    5053 #line 369 "parser.yy"
     5054#line 372 "parser.yy"
    50545055    { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
    50555056    break;
     
    50585059
    50595060/* Line 1806 of yacc.c  */
    5060 #line 373 "parser.yy"
     5061#line 376 "parser.yy"
    50615062    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
    50625063    break;
     
    50655066
    50665067/* Line 1806 of yacc.c  */
    5067 #line 376 "parser.yy"
     5068#line 379 "parser.yy"
    50685069    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
    50695070    break;
     
    50725073
    50735074/* Line 1806 of yacc.c  */
    5074 #line 379 "parser.yy"
     5075#line 382 "parser.yy"
    50755076    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
    50765077    break;
     
    50795080
    50805081/* Line 1806 of yacc.c  */
    5081 #line 381 "parser.yy"
     5082#line 384 "parser.yy"
    50825083    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
    50835084    break;
     
    50865087
    50875088/* Line 1806 of yacc.c  */
    5088 #line 383 "parser.yy"
     5089#line 386 "parser.yy"
    50895090    { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
    50905091    break;
     
    50935094
    50945095/* Line 1806 of yacc.c  */
    5095 #line 385 "parser.yy"
     5096#line 388 "parser.yy"
    50965097    {
    50975098                        Token fn;
     
    51045105
    51055106/* Line 1806 of yacc.c  */
    5106 #line 395 "parser.yy"
     5107#line 398 "parser.yy"
    51075108    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    51085109    break;
     
    51115112
    51125113/* Line 1806 of yacc.c  */
    5113 #line 400 "parser.yy"
     5114#line 403 "parser.yy"
    51145115    { (yyval.en) = 0; }
    51155116    break;
     
    51185119
    51195120/* Line 1806 of yacc.c  */
    5120 #line 406 "parser.yy"
     5121#line 409 "parser.yy"
    51215122    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    51225123    break;
     
    51255126
    51265127/* Line 1806 of yacc.c  */
    5127 #line 411 "parser.yy"
     5128#line 414 "parser.yy"
    51285129    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    51295130    break;
     
    51325133
    51335134/* Line 1806 of yacc.c  */
    5134 #line 415 "parser.yy"
     5135#line 418 "parser.yy"
    51355136    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
    51365137    break;
     
    51395140
    51405141/* Line 1806 of yacc.c  */
    5141 #line 417 "parser.yy"
     5142#line 420 "parser.yy"
    51425143    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
    51435144    break;
     
    51465147
    51475148/* Line 1806 of yacc.c  */
    5148 #line 419 "parser.yy"
     5149#line 422 "parser.yy"
    51495150    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
    51505151    break;
     
    51535154
    51545155/* Line 1806 of yacc.c  */
    5155 #line 421 "parser.yy"
     5156#line 424 "parser.yy"
    51565157    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
    51575158    break;
     
    51605161
    51615162/* Line 1806 of yacc.c  */
    5162 #line 429 "parser.yy"
     5163#line 432 "parser.yy"
    51635164    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    51645165    break;
     
    51675168
    51685169/* Line 1806 of yacc.c  */
    5169 #line 431 "parser.yy"
     5170#line 434 "parser.yy"
    51705171    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    51715172    break;
     
    51745175
    51755176/* Line 1806 of yacc.c  */
    5176 #line 433 "parser.yy"
     5177#line 436 "parser.yy"
    51775178    { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
    51785179    break;
     
    51815182
    51825183/* Line 1806 of yacc.c  */
    5183 #line 438 "parser.yy"
     5184#line 441 "parser.yy"
    51845185    {
    51855186                        switch ( (yyvsp[(1) - (2)].op) ) {
     
    51995200
    52005201/* Line 1806 of yacc.c  */
    5201 #line 451 "parser.yy"
     5202#line 454 "parser.yy"
    52025203    { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
    52035204    break;
     
    52065207
    52075208/* Line 1806 of yacc.c  */
    5208 #line 453 "parser.yy"
     5209#line 456 "parser.yy"
    52095210    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
    52105211    break;
     
    52135214
    52145215/* Line 1806 of yacc.c  */
    5215 #line 455 "parser.yy"
     5216#line 458 "parser.yy"
    52165217    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
    52175218    break;
     
    52205221
    52215222/* Line 1806 of yacc.c  */
    5222 #line 457 "parser.yy"
     5223#line 460 "parser.yy"
    52235224    { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    52245225    break;
     
    52275228
    52285229/* Line 1806 of yacc.c  */
    5229 #line 459 "parser.yy"
     5230#line 462 "parser.yy"
    52305231    { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52315232    break;
     
    52345235
    52355236/* Line 1806 of yacc.c  */
    5236 #line 461 "parser.yy"
     5237#line 464 "parser.yy"
    52375238    { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    52385239    break;
     
    52415242
    52425243/* Line 1806 of yacc.c  */
    5243 #line 463 "parser.yy"
     5244#line 466 "parser.yy"
    52445245    { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52455246    break;
     
    52485249
    52495250/* Line 1806 of yacc.c  */
    5250 #line 465 "parser.yy"
     5251#line 468 "parser.yy"
    52515252    { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
    52525253    break;
     
    52555256
    52565257/* Line 1806 of yacc.c  */
    5257 #line 467 "parser.yy"
     5258#line 470 "parser.yy"
    52585259    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
    52595260    break;
     
    52625263
    52635264/* Line 1806 of yacc.c  */
    5264 #line 469 "parser.yy"
     5265#line 472 "parser.yy"
    52655266    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
    52665267    break;
     
    52695270
    52705271/* Line 1806 of yacc.c  */
    5271 #line 471 "parser.yy"
     5272#line 474 "parser.yy"
    52725273    { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
    52735274    break;
     
    52765277
    52775278/* Line 1806 of yacc.c  */
    5278 #line 477 "parser.yy"
     5279#line 480 "parser.yy"
    52795280    { (yyval.op) = OperKinds::PointTo; }
    52805281    break;
     
    52835284
    52845285/* Line 1806 of yacc.c  */
    5285 #line 478 "parser.yy"
     5286#line 481 "parser.yy"
    52865287    { (yyval.op) = OperKinds::AddressOf; }
    52875288    break;
     
    52905291
    52915292/* Line 1806 of yacc.c  */
    5292 #line 484 "parser.yy"
     5293#line 487 "parser.yy"
    52935294    { (yyval.op) = OperKinds::UnPlus; }
    52945295    break;
     
    52975298
    52985299/* Line 1806 of yacc.c  */
    5299 #line 485 "parser.yy"
     5300#line 488 "parser.yy"
    53005301    { (yyval.op) = OperKinds::UnMinus; }
    53015302    break;
     
    53045305
    53055306/* Line 1806 of yacc.c  */
    5306 #line 486 "parser.yy"
     5307#line 489 "parser.yy"
    53075308    { (yyval.op) = OperKinds::Neg; }
    53085309    break;
     
    53115312
    53125313/* Line 1806 of yacc.c  */
    5313 #line 487 "parser.yy"
     5314#line 490 "parser.yy"
    53145315    { (yyval.op) = OperKinds::BitNeg; }
    53155316    break;
     
    53185319
    53195320/* Line 1806 of yacc.c  */
    5320 #line 493 "parser.yy"
     5321#line 496 "parser.yy"
    53215322    { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
    53225323    break;
     
    53255326
    53265327/* Line 1806 of yacc.c  */
    5327 #line 495 "parser.yy"
     5328#line 498 "parser.yy"
    53285329    { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
    53295330    break;
     
    53325333
    53335334/* Line 1806 of yacc.c  */
    5334 #line 501 "parser.yy"
     5335#line 504 "parser.yy"
    53355336    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53365337    break;
     
    53395340
    53405341/* Line 1806 of yacc.c  */
    5341 #line 503 "parser.yy"
     5342#line 506 "parser.yy"
    53425343    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53435344    break;
     
    53465347
    53475348/* Line 1806 of yacc.c  */
    5348 #line 505 "parser.yy"
     5349#line 508 "parser.yy"
    53495350    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53505351    break;
     
    53535354
    53545355/* Line 1806 of yacc.c  */
    5355 #line 511 "parser.yy"
     5356#line 514 "parser.yy"
    53565357    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53575358    break;
     
    53605361
    53615362/* Line 1806 of yacc.c  */
    5362 #line 513 "parser.yy"
     5363#line 516 "parser.yy"
    53635364    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53645365    break;
     
    53675368
    53685369/* Line 1806 of yacc.c  */
    5369 #line 519 "parser.yy"
     5370#line 522 "parser.yy"
    53705371    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53715372    break;
     
    53745375
    53755376/* Line 1806 of yacc.c  */
    5376 #line 521 "parser.yy"
     5377#line 524 "parser.yy"
    53775378    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53785379    break;
     
    53815382
    53825383/* Line 1806 of yacc.c  */
    5383 #line 527 "parser.yy"
     5384#line 530 "parser.yy"
    53845385    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53855386    break;
     
    53885389
    53895390/* Line 1806 of yacc.c  */
    5390 #line 529 "parser.yy"
     5391#line 532 "parser.yy"
    53915392    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53925393    break;
     
    53955396
    53965397/* Line 1806 of yacc.c  */
    5397 #line 531 "parser.yy"
     5398#line 534 "parser.yy"
    53985399    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53995400    break;
     
    54025403
    54035404/* Line 1806 of yacc.c  */
    5404 #line 533 "parser.yy"
     5405#line 536 "parser.yy"
    54055406    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54065407    break;
     
    54095410
    54105411/* Line 1806 of yacc.c  */
    5411 #line 539 "parser.yy"
     5412#line 542 "parser.yy"
    54125413    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54135414    break;
     
    54165417
    54175418/* Line 1806 of yacc.c  */
    5418 #line 541 "parser.yy"
     5419#line 544 "parser.yy"
    54195420    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54205421    break;
     
    54235424
    54245425/* Line 1806 of yacc.c  */
    5425 #line 547 "parser.yy"
     5426#line 550 "parser.yy"
    54265427    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54275428    break;
     
    54305431
    54315432/* Line 1806 of yacc.c  */
    5432 #line 553 "parser.yy"
     5433#line 556 "parser.yy"
    54335434    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54345435    break;
     
    54375438
    54385439/* Line 1806 of yacc.c  */
    5439 #line 559 "parser.yy"
     5440#line 562 "parser.yy"
    54405441    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54415442    break;
     
    54445445
    54455446/* Line 1806 of yacc.c  */
    5446 #line 565 "parser.yy"
     5447#line 568 "parser.yy"
    54475448    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
    54485449    break;
     
    54515452
    54525453/* Line 1806 of yacc.c  */
    5453 #line 571 "parser.yy"
     5454#line 574 "parser.yy"
    54545455    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
    54555456    break;
     
    54585459
    54595460/* Line 1806 of yacc.c  */
    5460 #line 577 "parser.yy"
     5461#line 580 "parser.yy"
    54615462    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    54625463    break;
     
    54655466
    54665467/* Line 1806 of yacc.c  */
    5467 #line 580 "parser.yy"
     5468#line 583 "parser.yy"
    54685469    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
    54695470    break;
     
    54725473
    54735474/* Line 1806 of yacc.c  */
    5474 #line 582 "parser.yy"
     5475#line 585 "parser.yy"
    54755476    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    54765477    break;
     
    54795480
    54805481/* Line 1806 of yacc.c  */
    5481 #line 593 "parser.yy"
     5482#line 596 "parser.yy"
    54825483    { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54835484    break;
     
    54865487
    54875488/* Line 1806 of yacc.c  */
    5488 #line 595 "parser.yy"
     5489#line 598 "parser.yy"
    54895490    { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new ExpressionNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
    54905491    break;
     
    54935494
    54945495/* Line 1806 of yacc.c  */
    5495 #line 600 "parser.yy"
     5496#line 603 "parser.yy"
    54965497    { (yyval.en) = nullptr; }
    54975498    break;
     
    55005501
    55015502/* Line 1806 of yacc.c  */
    5502 #line 605 "parser.yy"
     5503#line 608 "parser.yy"
    55035504    { (yyval.op) = OperKinds::Assign; }
    55045505    break;
     
    55075508
    55085509/* Line 1806 of yacc.c  */
    5509 #line 606 "parser.yy"
     5510#line 609 "parser.yy"
    55105511    { (yyval.op) = OperKinds::MulAssn; }
    55115512    break;
     
    55145515
    55155516/* Line 1806 of yacc.c  */
    5516 #line 607 "parser.yy"
     5517#line 610 "parser.yy"
    55175518    { (yyval.op) = OperKinds::DivAssn; }
    55185519    break;
     
    55215522
    55225523/* Line 1806 of yacc.c  */
    5523 #line 608 "parser.yy"
     5524#line 611 "parser.yy"
    55245525    { (yyval.op) = OperKinds::ModAssn; }
    55255526    break;
     
    55285529
    55295530/* Line 1806 of yacc.c  */
    5530 #line 609 "parser.yy"
     5531#line 612 "parser.yy"
    55315532    { (yyval.op) = OperKinds::PlusAssn; }
    55325533    break;
     
    55355536
    55365537/* Line 1806 of yacc.c  */
    5537 #line 610 "parser.yy"
     5538#line 613 "parser.yy"
    55385539    { (yyval.op) = OperKinds::MinusAssn; }
    55395540    break;
     
    55425543
    55435544/* Line 1806 of yacc.c  */
    5544 #line 611 "parser.yy"
     5545#line 614 "parser.yy"
    55455546    { (yyval.op) = OperKinds::LSAssn; }
    55465547    break;
     
    55495550
    55505551/* Line 1806 of yacc.c  */
    5551 #line 612 "parser.yy"
     5552#line 615 "parser.yy"
    55525553    { (yyval.op) = OperKinds::RSAssn; }
    55535554    break;
     
    55565557
    55575558/* Line 1806 of yacc.c  */
    5558 #line 613 "parser.yy"
     5559#line 616 "parser.yy"
    55595560    { (yyval.op) = OperKinds::AndAssn; }
    55605561    break;
     
    55635564
    55645565/* Line 1806 of yacc.c  */
    5565 #line 614 "parser.yy"
     5566#line 617 "parser.yy"
    55665567    { (yyval.op) = OperKinds::ERAssn; }
    55675568    break;
     
    55705571
    55715572/* Line 1806 of yacc.c  */
    5572 #line 615 "parser.yy"
     5573#line 618 "parser.yy"
    55735574    { (yyval.op) = OperKinds::OrAssn; }
    55745575    break;
     
    55775578
    55785579/* Line 1806 of yacc.c  */
    5579 #line 622 "parser.yy"
     5580#line 625 "parser.yy"
    55805581    { (yyval.en) = new ExpressionNode( build_tuple() ); }
    55815582    break;
     
    55845585
    55855586/* Line 1806 of yacc.c  */
    5586 #line 624 "parser.yy"
     5587#line 627 "parser.yy"
    55875588    { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
    55885589    break;
     
    55915592
    55925593/* Line 1806 of yacc.c  */
    5593 #line 626 "parser.yy"
     5594#line 629 "parser.yy"
    55945595    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_link( (yyvsp[(4) - (6)].en) ) ) ); }
    55955596    break;
     
    55985599
    55995600/* Line 1806 of yacc.c  */
    5600 #line 628 "parser.yy"
     5601#line 631 "parser.yy"
    56015602    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( (yyvsp[(5) - (7)].en) ) ) ); }
    56025603    break;
     
    56055606
    56065607/* Line 1806 of yacc.c  */
    5607 #line 634 "parser.yy"
     5608#line 637 "parser.yy"
    56085609    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    56095610    break;
     
    56125613
    56135614/* Line 1806 of yacc.c  */
    5614 #line 640 "parser.yy"
     5615#line 643 "parser.yy"
    56155616    { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56165617    break;
     
    56195620
    56205621/* Line 1806 of yacc.c  */
    5621 #line 645 "parser.yy"
     5622#line 648 "parser.yy"
    56225623    { (yyval.en) = 0; }
    56235624    break;
     
    56265627
    56275628/* Line 1806 of yacc.c  */
    5628 #line 654 "parser.yy"
     5629#line 657 "parser.yy"
    56295630    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    56305631    break;
     
    56335634
    56345635/* Line 1806 of yacc.c  */
    5635 #line 661 "parser.yy"
     5636#line 664 "parser.yy"
    56365637    {
    56375638                        Token fn;
     
    56445645
    56455646/* Line 1806 of yacc.c  */
    5646 #line 671 "parser.yy"
     5647#line 674 "parser.yy"
    56475648    {
    56485649                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
     
    56535654
    56545655/* Line 1806 of yacc.c  */
    5655 #line 678 "parser.yy"
     5656#line 681 "parser.yy"
    56565657    { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
    56575658    break;
     
    56605661
    56615662/* Line 1806 of yacc.c  */
    5662 #line 685 "parser.yy"
     5663#line 688 "parser.yy"
    56635664    { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); }
    56645665    break;
     
    56675668
    56685669/* Line 1806 of yacc.c  */
    5669 #line 691 "parser.yy"
     5670#line 694 "parser.yy"
    56705671    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    56715672    break;
     
    56745675
    56755676/* Line 1806 of yacc.c  */
    5676 #line 696 "parser.yy"
     5677#line 699 "parser.yy"
    56775678    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    56785679    break;
     
    56815682
    56825683/* Line 1806 of yacc.c  */
    5683 #line 698 "parser.yy"
     5684#line 701 "parser.yy"
    56845685    {   // mark all fields in list
    56855686                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    56925693
    56935694/* Line 1806 of yacc.c  */
    5694 #line 704 "parser.yy"
     5695#line 707 "parser.yy"
    56955696    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    56965697    break;
     
    56995700
    57005701/* Line 1806 of yacc.c  */
    5701 #line 711 "parser.yy"
     5702#line 714 "parser.yy"
    57025703    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    57035704    break;
     
    57065707
    57075708/* Line 1806 of yacc.c  */
    5708 #line 716 "parser.yy"
     5709#line 719 "parser.yy"
    57095710    { (yyval.sn) = new StatementNode( StatementNode::Exp, (yyvsp[(1) - (2)].en), 0 ); }
    57105711    break;
     
    57135714
    57145715/* Line 1806 of yacc.c  */
    5715 #line 722 "parser.yy"
    5716     { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
     5716#line 726 "parser.yy"
     5717    { (yyval.sn) = new StatementNode2( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
    57175718    break;
    57185719
     
    57205721
    57215722/* Line 1806 of yacc.c  */
    5722 #line 724 "parser.yy"
    5723     { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn) )) ); }
     5723#line 729 "parser.yy"
     5724    { (yyval.sn) = new StatementNode2( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
    57245725    break;
    57255726
     
    57275728
    57285729/* Line 1806 of yacc.c  */
    5729 #line 726 "parser.yy"
    5730     { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
     5730#line 732 "parser.yy"
     5731    { (yyval.sn) = new StatementNode2( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    57315732    break;
    57325733
     
    57345735
    57355736/* Line 1806 of yacc.c  */
    5736 #line 728 "parser.yy"
     5737#line 734 "parser.yy"
    57375738    {
    5738                         StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     5739                        StatementNode *sw = new StatementNode2( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
    57395740                        // The semantics of the declaration list is changed to include associated initialization, which is performed
    57405741                        // *before* the transfer to the appropriate case clause by hoisting the declarations into a compound
     
    57495750
    57505751/* Line 1806 of yacc.c  */
    5751 #line 738 "parser.yy"
    5752     { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
     5752#line 745 "parser.yy"
     5753    { (yyval.sn) = new StatementNode2( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    57535754    break;
    57545755
     
    57565757
    57575758/* Line 1806 of yacc.c  */
    5758 #line 740 "parser.yy"
     5759#line 747 "parser.yy"
    57595760    {
    5760                         StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     5761                        //StatementNode *sw = new StatementNode( StatementNode::Switch, $3, $8 );
     5762                        StatementNode *sw = new StatementNode2( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
    57615763                        (yyval.sn) = (yyvsp[(7) - (9)].decl) != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( (yyvsp[(7) - (9)].decl) ))->set_link( sw )) ) : sw;
    57625764                }
     
    57665768
    57675769/* Line 1806 of yacc.c  */
    5768 #line 750 "parser.yy"
     5770#line 758 "parser.yy"
    57695771    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    57705772    break;
     
    57735775
    57745776/* Line 1806 of yacc.c  */
    5775 #line 752 "parser.yy"
     5777#line 760 "parser.yy"
    57765778    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    57775779    break;
     
    57805782
    57815783/* Line 1806 of yacc.c  */
    5782 #line 757 "parser.yy"
     5784#line 765 "parser.yy"
    57835785    { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(1) - (1)].en), 0 ); }
    57845786    break;
     
    57875789
    57885790/* Line 1806 of yacc.c  */
    5789 #line 759 "parser.yy"
     5791#line 767 "parser.yy"
    57905792    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode( StatementNode::Case, (yyvsp[(3) - (3)].en), 0 ) ) ); }
    57915793    break;
     
    57945796
    57955797/* Line 1806 of yacc.c  */
    5796 #line 763 "parser.yy"
     5798#line 771 "parser.yy"
    57975799    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    57985800    break;
     
    58015803
    58025804/* Line 1806 of yacc.c  */
    5803 #line 764 "parser.yy"
     5805#line 772 "parser.yy"
    58045806    { (yyval.sn) = new StatementNode( StatementNode::Default ); }
    58055807    break;
     
    58085810
    58095811/* Line 1806 of yacc.c  */
    5810 #line 770 "parser.yy"
     5812#line 778 "parser.yy"
    58115813    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
    58125814    break;
     
    58155817
    58165818/* Line 1806 of yacc.c  */
    5817 #line 774 "parser.yy"
     5819#line 782 "parser.yy"
    58185820    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    58195821    break;
     
    58225824
    58235825/* Line 1806 of yacc.c  */
    5824 #line 779 "parser.yy"
     5826#line 787 "parser.yy"
    58255827    { (yyval.sn) = 0; }
    58265828    break;
     
    58295831
    58305832/* Line 1806 of yacc.c  */
    5831 #line 785 "parser.yy"
     5833#line 793 "parser.yy"
    58325834    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    58335835    break;
     
    58365838
    58375839/* Line 1806 of yacc.c  */
    5838 #line 787 "parser.yy"
     5840#line 795 "parser.yy"
    58395841    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    58405842    break;
     
    58435845
    58445846/* Line 1806 of yacc.c  */
    5845 #line 792 "parser.yy"
     5847#line 800 "parser.yy"
    58465848    { (yyval.sn) = 0; }
    58475849    break;
     
    58505852
    58515853/* Line 1806 of yacc.c  */
    5852 #line 798 "parser.yy"
     5854#line 806 "parser.yy"
    58535855    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    58545856    break;
     
    58575859
    58585860/* Line 1806 of yacc.c  */
    5859 #line 800 "parser.yy"
     5861#line 808 "parser.yy"
    58605862    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
    58615863    break;
     
    58645866
    58655867/* Line 1806 of yacc.c  */
    5866 #line 802 "parser.yy"
     5868#line 810 "parser.yy"
    58675869    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    58685870    break;
     
    58715873
    58725874/* Line 1806 of yacc.c  */
    5873 #line 804 "parser.yy"
     5875#line 812 "parser.yy"
    58745876    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_link( (yyvsp[(2) - (4)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(3) - (4)].sn), *(yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
    58755877    break;
     
    58785880
    58795881/* Line 1806 of yacc.c  */
    5880 #line 809 "parser.yy"
     5882#line 817 "parser.yy"
    58815883    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    58825884    break;
     
    58855887
    58865888/* Line 1806 of yacc.c  */
    5887 #line 815 "parser.yy"
     5889#line 823 "parser.yy"
    58885890    { (yyval.sn) = 0; }
    58895891    break;
     
    58925894
    58935895/* Line 1806 of yacc.c  */
    5894 #line 817 "parser.yy"
     5896#line 825 "parser.yy"
    58955897    { (yyval.sn) = 0; }
    58965898    break;
     
    58995901
    59005902/* Line 1806 of yacc.c  */
    5901 #line 822 "parser.yy"
    5902     { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
     5903#line 830 "parser.yy"
     5904    { (yyval.sn) = new StatementNode2( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    59035905    break;
    59045906
     
    59065908
    59075909/* Line 1806 of yacc.c  */
    5908 #line 824 "parser.yy"
    5909     { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); }
     5910#line 832 "parser.yy"
     5911    { (yyval.sn) = new StatementNode2( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ) ); }
    59105912    break;
    59115913
     
    59135915
    59145916/* Line 1806 of yacc.c  */
    5915 #line 826 "parser.yy"
    5916     { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); }
     5917#line 834 "parser.yy"
     5918    { (yyval.sn) = new StatementNode2( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
    59175919    break;
    59185920
     
    59205922
    59215923/* Line 1806 of yacc.c  */
    5922 #line 831 "parser.yy"
    5923     { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
     5924#line 839 "parser.yy"
     5925    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    59245926    break;
    59255927
     
    59275929
    59285930/* Line 1806 of yacc.c  */
    5929 #line 833 "parser.yy"
    5930     { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
     5931#line 841 "parser.yy"
     5932    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    59315933    break;
    59325934
     
    59345936
    59355937/* Line 1806 of yacc.c  */
    5936 #line 838 "parser.yy"
     5938#line 846 "parser.yy"
    59375939    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
    59385940    break;
     
    59415943
    59425944/* Line 1806 of yacc.c  */
    5943 #line 842 "parser.yy"
     5945#line 850 "parser.yy"
    59445946    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
    59455947    break;
     
    59485950
    59495951/* Line 1806 of yacc.c  */
    5950 #line 845 "parser.yy"
     5952#line 853 "parser.yy"
    59515953    { (yyval.sn) = new StatementNode( StatementNode::Continue ); }
    59525954    break;
     
    59555957
    59565958/* Line 1806 of yacc.c  */
    5957 #line 849 "parser.yy"
     5959#line 857 "parser.yy"
    59585960    { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
    59595961    break;
     
    59625964
    59635965/* Line 1806 of yacc.c  */
    5964 #line 852 "parser.yy"
     5966#line 860 "parser.yy"
    59655967    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    59665968    break;
     
    59695971
    59705972/* Line 1806 of yacc.c  */
    5971 #line 856 "parser.yy"
     5973#line 864 "parser.yy"
    59725974    { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
    59735975    break;
     
    59765978
    59775979/* Line 1806 of yacc.c  */
    5978 #line 858 "parser.yy"
     5980#line 866 "parser.yy"
    59795981    { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); }
    59805982    break;
     
    59835985
    59845986/* Line 1806 of yacc.c  */
    5985 #line 860 "parser.yy"
     5987#line 868 "parser.yy"
    59865988    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    59875989    break;
     
    59905992
    59915993/* Line 1806 of yacc.c  */
    5992 #line 864 "parser.yy"
     5994#line 872 "parser.yy"
    59935995    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    59945996    break;
     
    59975999
    59986000/* Line 1806 of yacc.c  */
    5999 #line 866 "parser.yy"
     6001#line 874 "parser.yy"
    60006002    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (5)].en), 0 ); }
    60016003    break;
     
    60046006
    60056007/* Line 1806 of yacc.c  */
    6006 #line 873 "parser.yy"
     6008#line 881 "parser.yy"
    60076009    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    60086010    break;
     
    60116013
    60126014/* Line 1806 of yacc.c  */
    6013 #line 875 "parser.yy"
     6015#line 883 "parser.yy"
    60146016    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    60156017    break;
     
    60186020
    60196021/* Line 1806 of yacc.c  */
    6020 #line 877 "parser.yy"
     6022#line 885 "parser.yy"
    60216023    {
    60226024                        (yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) );
     
    60286030
    60296031/* Line 1806 of yacc.c  */
    6030 #line 888 "parser.yy"
     6032#line 896 "parser.yy"
    60316033    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    60326034    break;
     
    60356037
    60366038/* Line 1806 of yacc.c  */
    6037 #line 890 "parser.yy"
     6039#line 898 "parser.yy"
    60386040    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    60396041    break;
     
    60426044
    60436045/* Line 1806 of yacc.c  */
    6044 #line 892 "parser.yy"
     6046#line 900 "parser.yy"
    60456047    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    60466048    break;
     
    60496051
    60506052/* Line 1806 of yacc.c  */
    6051 #line 894 "parser.yy"
     6053#line 902 "parser.yy"
    60526054    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    60536055    break;
     
    60566058
    60576059/* Line 1806 of yacc.c  */
    6058 #line 899 "parser.yy"
     6060#line 907 "parser.yy"
    60596061    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    60606062    break;
     
    60636065
    60646066/* Line 1806 of yacc.c  */
    6065 #line 901 "parser.yy"
     6067#line 909 "parser.yy"
    60666068    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    60676069    break;
     
    60706072
    60716073/* Line 1806 of yacc.c  */
    6072 #line 903 "parser.yy"
     6074#line 911 "parser.yy"
    60736075    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    60746076    break;
     
    60776079
    60786080/* Line 1806 of yacc.c  */
    6079 #line 905 "parser.yy"
     6081#line 913 "parser.yy"
    60806082    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    60816083    break;
     
    60846086
    60856087/* Line 1806 of yacc.c  */
    6086 #line 910 "parser.yy"
     6088#line 918 "parser.yy"
    60876089    {
    60886090                        (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
     
    60946096
    60956097/* Line 1806 of yacc.c  */
    6096 #line 924 "parser.yy"
     6098#line 932 "parser.yy"
    60976099    {
    60986100                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61046106
    61056107/* Line 1806 of yacc.c  */
    6106 #line 929 "parser.yy"
     6108#line 937 "parser.yy"
    61076109    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    61086110    break;
     
    61116113
    61126114/* Line 1806 of yacc.c  */
    6113 #line 931 "parser.yy"
     6115#line 939 "parser.yy"
    61146116    {
    61156117                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61216123
    61226124/* Line 1806 of yacc.c  */
    6123 #line 940 "parser.yy"
     6125#line 948 "parser.yy"
    61246126    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
    61256127    break;
     
    61286130
    61296131/* Line 1806 of yacc.c  */
    6130 #line 942 "parser.yy"
     6132#line 950 "parser.yy"
    61316133    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
    61326134    break;
     
    61356137
    61366138/* Line 1806 of yacc.c  */
    6137 #line 944 "parser.yy"
     6139#line 952 "parser.yy"
    61386140    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
    61396141    break;
     
    61426144
    61436145/* Line 1806 of yacc.c  */
    6144 #line 946 "parser.yy"
     6146#line 954 "parser.yy"
    61456147    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ); }
    61466148    break;
     
    61496151
    61506152/* Line 1806 of yacc.c  */
    6151 #line 948 "parser.yy"
     6153#line 956 "parser.yy"
    61526154    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ); }
    61536155    break;
     
    61566158
    61576159/* Line 1806 of yacc.c  */
    6158 #line 953 "parser.yy"
     6160#line 961 "parser.yy"
    61596161    { (yyval.flag) = false; }
    61606162    break;
     
    61636165
    61646166/* Line 1806 of yacc.c  */
    6165 #line 955 "parser.yy"
     6167#line 963 "parser.yy"
    61666168    { (yyval.flag) = true; }
    61676169    break;
     
    61706172
    61716173/* Line 1806 of yacc.c  */
    6172 #line 960 "parser.yy"
     6174#line 968 "parser.yy"
    61736175    { (yyval.en) = 0; }
    61746176    break;
     
    61776179
    61786180/* Line 1806 of yacc.c  */
    6179 #line 967 "parser.yy"
     6181#line 975 "parser.yy"
    61806182    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    61816183    break;
     
    61846186
    61856187/* Line 1806 of yacc.c  */
    6186 #line 972 "parser.yy"
     6188#line 980 "parser.yy"
    61876189    { (yyval.en) = new ExpressionNode( build_asm( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
    61886190    break;
     
    61916193
    61926194/* Line 1806 of yacc.c  */
    6193 #line 974 "parser.yy"
     6195#line 982 "parser.yy"
    61946196    { (yyval.en) = new ExpressionNode( build_asm( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
    61956197    break;
     
    61986200
    61996201/* Line 1806 of yacc.c  */
    6200 #line 979 "parser.yy"
     6202#line 987 "parser.yy"
    62016203    { (yyval.en) = 0; }
    62026204    break;
     
    62056207
    62066208/* Line 1806 of yacc.c  */
    6207 #line 981 "parser.yy"
     6209#line 989 "parser.yy"
    62086210    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    62096211    break;
     
    62126214
    62136215/* Line 1806 of yacc.c  */
    6214 #line 983 "parser.yy"
     6216#line 991 "parser.yy"
    62156217    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
    62166218    break;
     
    62196221
    62206222/* Line 1806 of yacc.c  */
    6221 #line 988 "parser.yy"
     6223#line 996 "parser.yy"
    62226224    { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
    62236225    break;
     
    62266228
    62276229/* Line 1806 of yacc.c  */
    6228 #line 990 "parser.yy"
     6230#line 998 "parser.yy"
    62296231    { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
    62306232    break;
     
    62336235
    62346236/* Line 1806 of yacc.c  */
    6235 #line 997 "parser.yy"
     6237#line 1005 "parser.yy"
    62366238    { (yyval.decl) = 0; }
    62376239    break;
     
    62406242
    62416243/* Line 1806 of yacc.c  */
    6242 #line 1004 "parser.yy"
     6244#line 1012 "parser.yy"
    62436245    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    62446246    break;
     
    62476249
    62486250/* Line 1806 of yacc.c  */
    6249 #line 1009 "parser.yy"
     6251#line 1017 "parser.yy"
    62506252    { (yyval.decl) = 0; }
    62516253    break;
     
    62546256
    62556257/* Line 1806 of yacc.c  */
    6256 #line 1016 "parser.yy"
     6258#line 1024 "parser.yy"
    62576259    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    62586260    break;
     
    62616263
    62626264/* Line 1806 of yacc.c  */
    6263 #line 1030 "parser.yy"
     6265#line 1038 "parser.yy"
    62646266    {}
    62656267    break;
     
    62686270
    62696271/* Line 1806 of yacc.c  */
    6270 #line 1031 "parser.yy"
     6272#line 1039 "parser.yy"
    62716273    {}
    62726274    break;
     
    62756277
    62766278/* Line 1806 of yacc.c  */
    6277 #line 1060 "parser.yy"
     6279#line 1068 "parser.yy"
    62786280    {
    62796281                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    62856287
    62866288/* Line 1806 of yacc.c  */
    6287 #line 1067 "parser.yy"
     6289#line 1075 "parser.yy"
    62886290    {
    62896291                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    62956297
    62966298/* Line 1806 of yacc.c  */
    6297 #line 1072 "parser.yy"
     6299#line 1080 "parser.yy"
    62986300    {
    62996301                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
     
    63056307
    63066308/* Line 1806 of yacc.c  */
    6307 #line 1082 "parser.yy"
     6309#line 1090 "parser.yy"
    63086310    {
    63096311                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63156317
    63166318/* Line 1806 of yacc.c  */
    6317 #line 1087 "parser.yy"
     6319#line 1095 "parser.yy"
    63186320    {
    63196321                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63256327
    63266328/* Line 1806 of yacc.c  */
    6327 #line 1092 "parser.yy"
     6329#line 1100 "parser.yy"
    63286330    {
    63296331                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
     
    63356337
    63366338/* Line 1806 of yacc.c  */
    6337 #line 1100 "parser.yy"
     6339#line 1108 "parser.yy"
    63386340    {
    63396341                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63456347
    63466348/* Line 1806 of yacc.c  */
    6347 #line 1105 "parser.yy"
     6349#line 1113 "parser.yy"
    63486350    {
    63496351                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63556357
    63566358/* Line 1806 of yacc.c  */
    6357 #line 1110 "parser.yy"
     6359#line 1118 "parser.yy"
    63586360    {
    63596361                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63656367
    63666368/* Line 1806 of yacc.c  */
    6367 #line 1115 "parser.yy"
     6369#line 1123 "parser.yy"
    63686370    {
    63696371                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63756377
    63766378/* Line 1806 of yacc.c  */
    6377 #line 1120 "parser.yy"
     6379#line 1128 "parser.yy"
    63786380    {
    63796381                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    63856387
    63866388/* Line 1806 of yacc.c  */
    6387 #line 1128 "parser.yy"
     6389#line 1136 "parser.yy"
    63886390    {
    63896391                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
     
    63946396
    63956397/* Line 1806 of yacc.c  */
    6396 #line 1151 "parser.yy"
     6398#line 1159 "parser.yy"
    63976399    {
    63986400                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    64036405
    64046406/* Line 1806 of yacc.c  */
    6405 #line 1155 "parser.yy"
     6407#line 1163 "parser.yy"
    64066408    {
    64076409                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    64126414
    64136415/* Line 1806 of yacc.c  */
    6414 #line 1162 "parser.yy"
     6416#line 1170 "parser.yy"
    64156417    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    64166418    break;
     
    64196421
    64206422/* Line 1806 of yacc.c  */
    6421 #line 1166 "parser.yy"
     6423#line 1174 "parser.yy"
    64226424    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    64236425    break;
     
    64266428
    64276429/* Line 1806 of yacc.c  */
    6428 #line 1171 "parser.yy"
     6430#line 1179 "parser.yy"
    64296431    {
    64306432                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64366438
    64376439/* Line 1806 of yacc.c  */
    6438 #line 1176 "parser.yy"
     6440#line 1184 "parser.yy"
    64396441    {
    64406442                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64466448
    64476449/* Line 1806 of yacc.c  */
    6448 #line 1181 "parser.yy"
     6450#line 1189 "parser.yy"
    64496451    {
    64506452                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
     
    64566458
    64576459/* Line 1806 of yacc.c  */
    6458 #line 1192 "parser.yy"
     6460#line 1200 "parser.yy"
    64596461    {
    64606462                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64666468
    64676469/* Line 1806 of yacc.c  */
    6468 #line 1197 "parser.yy"
     6470#line 1205 "parser.yy"
    64696471    {
    64706472                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64766478
    64776479/* Line 1806 of yacc.c  */
    6478 #line 1202 "parser.yy"
     6480#line 1210 "parser.yy"
    64796481    {
    64806482                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64866488
    64876489/* Line 1806 of yacc.c  */
    6488 #line 1207 "parser.yy"
     6490#line 1215 "parser.yy"
    64896491    {
    64906492                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64966498
    64976499/* Line 1806 of yacc.c  */
    6498 #line 1212 "parser.yy"
     6500#line 1220 "parser.yy"
    64996501    {
    65006502                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65066508
    65076509/* Line 1806 of yacc.c  */
    6508 #line 1221 "parser.yy"
     6510#line 1229 "parser.yy"
    65096511    {
    65106512                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
     
    65166518
    65176519/* Line 1806 of yacc.c  */
    6518 #line 1226 "parser.yy"
     6520#line 1234 "parser.yy"
    65196521    {
    65206522                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
     
    65266528
    65276529/* Line 1806 of yacc.c  */
    6528 #line 1243 "parser.yy"
     6530#line 1251 "parser.yy"
    65296531    {
    65306532                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65366538
    65376539/* Line 1806 of yacc.c  */
    6538 #line 1248 "parser.yy"
     6540#line 1256 "parser.yy"
    65396541    {
    65406542                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65466548
    65476549/* Line 1806 of yacc.c  */
    6548 #line 1270 "parser.yy"
     6550#line 1278 "parser.yy"
    65496551    { (yyval.decl) = 0; }
    65506552    break;
     
    65536555
    65546556/* Line 1806 of yacc.c  */
    6555 #line 1282 "parser.yy"
     6557#line 1290 "parser.yy"
    65566558    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    65576559    break;
     
    65606562
    65616563/* Line 1806 of yacc.c  */
    6562 #line 1293 "parser.yy"
     6564#line 1301 "parser.yy"
    65636565    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    65646566    break;
     
    65676569
    65686570/* Line 1806 of yacc.c  */
    6569 #line 1295 "parser.yy"
     6571#line 1303 "parser.yy"
    65706572    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    65716573    break;
     
    65746576
    65756577/* Line 1806 of yacc.c  */
    6576 #line 1297 "parser.yy"
     6578#line 1305 "parser.yy"
    65776579    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    65786580    break;
     
    65816583
    65826584/* Line 1806 of yacc.c  */
    6583 #line 1299 "parser.yy"
     6585#line 1307 "parser.yy"
    65846586    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    65856587    break;
     
    65886590
    65896591/* Line 1806 of yacc.c  */
    6590 #line 1301 "parser.yy"
     6592#line 1309 "parser.yy"
    65916593    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    65926594    break;
     
    65956597
    65966598/* Line 1806 of yacc.c  */
    6597 #line 1303 "parser.yy"
     6599#line 1311 "parser.yy"
    65986600    {
    65996601                        typedefTable.enterScope();
     
    66046606
    66056607/* Line 1806 of yacc.c  */
    6606 #line 1307 "parser.yy"
     6608#line 1315 "parser.yy"
    66076609    {
    66086610                        typedefTable.leaveScope();
     
    66146616
    66156617/* Line 1806 of yacc.c  */
    6616 #line 1316 "parser.yy"
     6618#line 1324 "parser.yy"
    66176619    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66186620    break;
     
    66216623
    66226624/* Line 1806 of yacc.c  */
    6623 #line 1318 "parser.yy"
     6625#line 1326 "parser.yy"
    66246626    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    66256627    break;
     
    66286630
    66296631/* Line 1806 of yacc.c  */
    6630 #line 1329 "parser.yy"
     6632#line 1337 "parser.yy"
    66316633    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66326634    break;
     
    66356637
    66366638/* Line 1806 of yacc.c  */
    6637 #line 1338 "parser.yy"
     6639#line 1346 "parser.yy"
    66386640    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    66396641    break;
     
    66426644
    66436645/* Line 1806 of yacc.c  */
    6644 #line 1340 "parser.yy"
     6646#line 1348 "parser.yy"
    66456647    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    66466648    break;
     
    66496651
    66506652/* Line 1806 of yacc.c  */
    6651 #line 1342 "parser.yy"
     6653#line 1350 "parser.yy"
    66526654    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    66536655    break;
     
    66566658
    66576659/* Line 1806 of yacc.c  */
    6658 #line 1344 "parser.yy"
     6660#line 1352 "parser.yy"
    66596661    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    66606662    break;
     
    66636665
    66646666/* Line 1806 of yacc.c  */
    6665 #line 1346 "parser.yy"
     6667#line 1354 "parser.yy"
    66666668    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    66676669    break;
     
    66706672
    66716673/* Line 1806 of yacc.c  */
    6672 #line 1348 "parser.yy"
     6674#line 1356 "parser.yy"
    66736675    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    66746676    break;
     
    66776679
    66786680/* Line 1806 of yacc.c  */
    6679 #line 1350 "parser.yy"
     6681#line 1358 "parser.yy"
    66806682    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
    66816683    break;
     
    66846686
    66856687/* Line 1806 of yacc.c  */
    6686 #line 1352 "parser.yy"
     6688#line 1360 "parser.yy"
    66876689    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    66886690    break;
     
    66916693
    66926694/* Line 1806 of yacc.c  */
    6693 #line 1357 "parser.yy"
     6695#line 1365 "parser.yy"
    66946696    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    66956697    break;
     
    66986700
    66996701/* Line 1806 of yacc.c  */
    6700 #line 1359 "parser.yy"
     6702#line 1367 "parser.yy"
    67016703    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    67026704    break;
     
    67056707
    67066708/* Line 1806 of yacc.c  */
    6707 #line 1361 "parser.yy"
     6709#line 1369 "parser.yy"
    67086710    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    67096711    break;
     
    67126714
    67136715/* Line 1806 of yacc.c  */
    6714 #line 1363 "parser.yy"
     6716#line 1371 "parser.yy"
    67156717    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    67166718    break;
     
    67196721
    67206722/* Line 1806 of yacc.c  */
    6721 #line 1365 "parser.yy"
     6723#line 1373 "parser.yy"
    67226724    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
    67236725    break;
     
    67266728
    67276729/* Line 1806 of yacc.c  */
    6728 #line 1367 "parser.yy"
     6730#line 1375 "parser.yy"
    67296731    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
    67306732    break;
     
    67336735
    67346736/* Line 1806 of yacc.c  */
    6735 #line 1369 "parser.yy"
     6737#line 1377 "parser.yy"
    67366738    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
    67376739    break;
     
    67406742
    67416743/* Line 1806 of yacc.c  */
    6742 #line 1371 "parser.yy"
     6744#line 1379 "parser.yy"
    67436745    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
    67446746    break;
     
    67476749
    67486750/* Line 1806 of yacc.c  */
    6749 #line 1373 "parser.yy"
     6751#line 1381 "parser.yy"
    67506752    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    67516753    break;
     
    67546756
    67556757/* Line 1806 of yacc.c  */
    6756 #line 1375 "parser.yy"
     6758#line 1383 "parser.yy"
    67576759    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    67586760    break;
     
    67616763
    67626764/* Line 1806 of yacc.c  */
    6763 #line 1377 "parser.yy"
     6765#line 1385 "parser.yy"
    67646766    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
    67656767    break;
     
    67686770
    67696771/* Line 1806 of yacc.c  */
    6770 #line 1379 "parser.yy"
     6772#line 1387 "parser.yy"
    67716773    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
    67726774    break;
     
    67756777
    67766778/* Line 1806 of yacc.c  */
    6777 #line 1381 "parser.yy"
     6779#line 1389 "parser.yy"
    67786780    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    67796781    break;
     
    67826784
    67836785/* Line 1806 of yacc.c  */
    6784 #line 1388 "parser.yy"
     6786#line 1396 "parser.yy"
    67856787    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    67866788    break;
     
    67896791
    67906792/* Line 1806 of yacc.c  */
    6791 #line 1390 "parser.yy"
     6793#line 1398 "parser.yy"
    67926794    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    67936795    break;
     
    67966798
    67976799/* Line 1806 of yacc.c  */
    6798 #line 1392 "parser.yy"
     6800#line 1400 "parser.yy"
    67996801    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68006802    break;
     
    68036805
    68046806/* Line 1806 of yacc.c  */
    6805 #line 1394 "parser.yy"
     6807#line 1402 "parser.yy"
    68066808    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    68076809    break;
     
    68106812
    68116813/* Line 1806 of yacc.c  */
    6812 #line 1400 "parser.yy"
     6814#line 1408 "parser.yy"
    68136815    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68146816    break;
     
    68176819
    68186820/* Line 1806 of yacc.c  */
    6819 #line 1407 "parser.yy"
     6821#line 1415 "parser.yy"
    68206822    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68216823    break;
     
    68246826
    68256827/* Line 1806 of yacc.c  */
    6826 #line 1409 "parser.yy"
     6828#line 1417 "parser.yy"
    68276829    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68286830    break;
     
    68316833
    68326834/* Line 1806 of yacc.c  */
    6833 #line 1411 "parser.yy"
     6835#line 1419 "parser.yy"
    68346836    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    68356837    break;
     
    68386840
    68396841/* Line 1806 of yacc.c  */
    6840 #line 1416 "parser.yy"
     6842#line 1424 "parser.yy"
    68416843    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    68426844    break;
     
    68456847
    68466848/* Line 1806 of yacc.c  */
    6847 #line 1418 "parser.yy"
     6849#line 1426 "parser.yy"
    68486850    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    68496851    break;
     
    68526854
    68536855/* Line 1806 of yacc.c  */
    6854 #line 1420 "parser.yy"
     6856#line 1428 "parser.yy"
    68556857    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    68566858    break;
     
    68596861
    68606862/* Line 1806 of yacc.c  */
    6861 #line 1422 "parser.yy"
     6863#line 1430 "parser.yy"
    68626864    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    68636865    break;
     
    68666868
    68676869/* Line 1806 of yacc.c  */
    6868 #line 1428 "parser.yy"
     6870#line 1436 "parser.yy"
    68696871    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68706872    break;
     
    68736875
    68746876/* Line 1806 of yacc.c  */
    6875 #line 1430 "parser.yy"
     6877#line 1438 "parser.yy"
    68766878    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68776879    break;
     
    68806882
    68816883/* Line 1806 of yacc.c  */
    6882 #line 1432 "parser.yy"
     6884#line 1440 "parser.yy"
    68836885    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68846886    break;
    68856887
    68866888  case 351:
    6887 
    6888 /* Line 1806 of yacc.c  */
    6889 #line 1438 "parser.yy"
    6890     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    6891     break;
    6892 
    6893   case 352:
    6894 
    6895 /* Line 1806 of yacc.c  */
    6896 #line 1440 "parser.yy"
    6897     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    6898     break;
    6899 
    6900   case 354:
    69016889
    69026890/* Line 1806 of yacc.c  */
     
    69056893    break;
    69066894
    6907   case 355:
     6895  case 352:
    69086896
    69096897/* Line 1806 of yacc.c  */
     
    69126900    break;
    69136901
     6902  case 354:
     6903
     6904/* Line 1806 of yacc.c  */
     6905#line 1454 "parser.yy"
     6906    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6907    break;
     6908
     6909  case 355:
     6910
     6911/* Line 1806 of yacc.c  */
     6912#line 1456 "parser.yy"
     6913    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6914    break;
     6915
    69146916  case 356:
    69156917
    69166918/* Line 1806 of yacc.c  */
    6917 #line 1450 "parser.yy"
     6919#line 1458 "parser.yy"
    69186920    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    69196921    break;
     
    69226924
    69236925/* Line 1806 of yacc.c  */
    6924 #line 1455 "parser.yy"
     6926#line 1463 "parser.yy"
    69256927    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    69266928    break;
     
    69296931
    69306932/* Line 1806 of yacc.c  */
    6931 #line 1457 "parser.yy"
     6933#line 1465 "parser.yy"
    69326934    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69336935    break;
     
    69366938
    69376939/* Line 1806 of yacc.c  */
    6938 #line 1459 "parser.yy"
     6940#line 1467 "parser.yy"
    69396941    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69406942    break;
     
    69436945
    69446946/* Line 1806 of yacc.c  */
    6945 #line 1469 "parser.yy"
     6947#line 1477 "parser.yy"
    69466948    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
    69476949    break;
     
    69506952
    69516953/* Line 1806 of yacc.c  */
    6952 #line 1471 "parser.yy"
     6954#line 1479 "parser.yy"
    69536955    {
    69546956                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    69606962
    69616963/* Line 1806 of yacc.c  */
    6962 #line 1476 "parser.yy"
     6964#line 1484 "parser.yy"
    69636965    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    69646966    break;
     
    69676969
    69686970/* Line 1806 of yacc.c  */
    6969 #line 1478 "parser.yy"
     6971#line 1486 "parser.yy"
    69706972    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
    69716973    break;
     
    69746976
    69756977/* Line 1806 of yacc.c  */
    6976 #line 1480 "parser.yy"
     6978#line 1488 "parser.yy"
    69776979    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    69786980    break;
     
    69816983
    69826984/* Line 1806 of yacc.c  */
    6983 #line 1482 "parser.yy"
     6985#line 1490 "parser.yy"
    69846986    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    69856987    break;
     
    69886990
    69896991/* Line 1806 of yacc.c  */
    6990 #line 1487 "parser.yy"
     6992#line 1495 "parser.yy"
    69916993    { (yyval.aggKey) = DeclarationNode::Struct; }
    69926994    break;
     
    69956997
    69966998/* Line 1806 of yacc.c  */
    6997 #line 1489 "parser.yy"
     6999#line 1497 "parser.yy"
    69987000    { (yyval.aggKey) = DeclarationNode::Union; }
    69997001    break;
     
    70027004
    70037005/* Line 1806 of yacc.c  */
    7004 #line 1494 "parser.yy"
     7006#line 1502 "parser.yy"
    70057007    { (yyval.decl) = 0; }
    70067008    break;
     
    70097011
    70107012/* Line 1806 of yacc.c  */
    7011 #line 1496 "parser.yy"
     7013#line 1504 "parser.yy"
    70127014    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    70137015    break;
     
    70167018
    70177019/* Line 1806 of yacc.c  */
    7018 #line 1502 "parser.yy"
     7020#line 1510 "parser.yy"
    70197021    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    70207022    break;
     
    70237025
    70247026/* Line 1806 of yacc.c  */
    7025 #line 1505 "parser.yy"
     7027#line 1513 "parser.yy"
    70267028    {   // mark all fields in list
    70277029                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    70347036
    70357037/* Line 1806 of yacc.c  */
    7036 #line 1515 "parser.yy"
     7038#line 1523 "parser.yy"
    70377039    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    70387040    break;
     
    70417043
    70427044/* Line 1806 of yacc.c  */
    7043 #line 1517 "parser.yy"
     7045#line 1525 "parser.yy"
    70447046    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    70457047    break;
     
    70487050
    70497051/* Line 1806 of yacc.c  */
    7050 #line 1519 "parser.yy"
     7052#line 1527 "parser.yy"
    70517053    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    70527054    break;
     
    70557057
    70567058/* Line 1806 of yacc.c  */
    7057 #line 1524 "parser.yy"
     7059#line 1532 "parser.yy"
    70587060    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    70597061    break;
     
    70627064
    70637065/* Line 1806 of yacc.c  */
    7064 #line 1526 "parser.yy"
     7066#line 1534 "parser.yy"
    70657067    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    70667068    break;
     
    70697071
    70707072/* Line 1806 of yacc.c  */
    7071 #line 1531 "parser.yy"
     7073#line 1539 "parser.yy"
    70727074    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    70737075    break;
     
    70767078
    70777079/* Line 1806 of yacc.c  */
    7078 #line 1533 "parser.yy"
     7080#line 1541 "parser.yy"
    70797081    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    70807082    break;
     
    70837085
    70847086/* Line 1806 of yacc.c  */
    7085 #line 1536 "parser.yy"
     7087#line 1544 "parser.yy"
    70867088    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    70877089    break;
     
    70907092
    70917093/* Line 1806 of yacc.c  */
    7092 #line 1539 "parser.yy"
     7094#line 1547 "parser.yy"
    70937095    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    70947096    break;
     
    70977099
    70987100/* Line 1806 of yacc.c  */
    7099 #line 1545 "parser.yy"
     7101#line 1553 "parser.yy"
    71007102    { (yyval.en) = 0; }
    71017103    break;
     
    71047106
    71057107/* Line 1806 of yacc.c  */
    7106 #line 1547 "parser.yy"
     7108#line 1555 "parser.yy"
    71077109    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    71087110    break;
     
    71117113
    71127114/* Line 1806 of yacc.c  */
    7113 #line 1552 "parser.yy"
     7115#line 1560 "parser.yy"
    71147116    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    71157117    break;
     
    71187120
    71197121/* Line 1806 of yacc.c  */
    7120 #line 1561 "parser.yy"
     7122#line 1569 "parser.yy"
    71217123    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
    71227124    break;
     
    71257127
    71267128/* Line 1806 of yacc.c  */
    7127 #line 1563 "parser.yy"
     7129#line 1571 "parser.yy"
    71287130    {
    71297131                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    71357137
    71367138/* Line 1806 of yacc.c  */
    7137 #line 1568 "parser.yy"
     7139#line 1576 "parser.yy"
    71387140    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    71397141    break;
     
    71427144
    71437145/* Line 1806 of yacc.c  */
    7144 #line 1570 "parser.yy"
     7146#line 1578 "parser.yy"
    71457147    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    71467148    break;
     
    71497151
    71507152/* Line 1806 of yacc.c  */
    7151 #line 1575 "parser.yy"
     7153#line 1583 "parser.yy"
    71527154    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    71537155    break;
     
    71567158
    71577159/* Line 1806 of yacc.c  */
    7158 #line 1577 "parser.yy"
     7160#line 1585 "parser.yy"
    71597161    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    71607162    break;
     
    71637165
    71647166/* Line 1806 of yacc.c  */
    7165 #line 1582 "parser.yy"
     7167#line 1590 "parser.yy"
    71667168    { (yyval.en) = 0; }
    71677169    break;
     
    71707172
    71717173/* Line 1806 of yacc.c  */
    7172 #line 1584 "parser.yy"
     7174#line 1592 "parser.yy"
    71737175    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    71747176    break;
     
    71777179
    71787180/* Line 1806 of yacc.c  */
    7179 #line 1591 "parser.yy"
     7181#line 1599 "parser.yy"
    71807182    { (yyval.decl) = 0; }
    71817183    break;
     
    71847186
    71857187/* Line 1806 of yacc.c  */
    7186 #line 1599 "parser.yy"
     7188#line 1607 "parser.yy"
    71877189    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    71887190    break;
     
    71917193
    71927194/* Line 1806 of yacc.c  */
    7193 #line 1601 "parser.yy"
     7195#line 1609 "parser.yy"
    71947196    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    71957197    break;
     
    71987200
    71997201/* Line 1806 of yacc.c  */
    7200 #line 1603 "parser.yy"
     7202#line 1611 "parser.yy"
    72017203    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72027204    break;
     
    72057207
    72067208/* Line 1806 of yacc.c  */
    7207 #line 1611 "parser.yy"
     7209#line 1619 "parser.yy"
    72087210    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72097211    break;
    72107212
    72117213  case 408:
    7212 
    7213 /* Line 1806 of yacc.c  */
    7214 #line 1613 "parser.yy"
    7215     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7216     break;
    7217 
    7218   case 409:
    7219 
    7220 /* Line 1806 of yacc.c  */
    7221 #line 1615 "parser.yy"
    7222     { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    7223     break;
    7224 
    7225   case 411:
    72267214
    72277215/* Line 1806 of yacc.c  */
     
    72307218    break;
    72317219
     7220  case 409:
     7221
     7222/* Line 1806 of yacc.c  */
     7223#line 1623 "parser.yy"
     7224    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
     7225    break;
     7226
     7227  case 411:
     7228
     7229/* Line 1806 of yacc.c  */
     7230#line 1629 "parser.yy"
     7231    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7232    break;
     7233
    72327234  case 412:
    72337235
    72347236/* Line 1806 of yacc.c  */
    7235 #line 1626 "parser.yy"
     7237#line 1634 "parser.yy"
    72367238    { (yyval.decl) = 0; }
    72377239    break;
     
    72407242
    72417243/* Line 1806 of yacc.c  */
    7242 #line 1633 "parser.yy"
     7244#line 1641 "parser.yy"
    72437245    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72447246    break;
     
    72477249
    72487250/* Line 1806 of yacc.c  */
    7249 #line 1640 "parser.yy"
     7251#line 1648 "parser.yy"
    72507252    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72517253    break;
     
    72547256
    72557257/* Line 1806 of yacc.c  */
    7256 #line 1642 "parser.yy"
     7258#line 1650 "parser.yy"
    72577259    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72587260    break;
     
    72617263
    72627264/* Line 1806 of yacc.c  */
    7263 #line 1651 "parser.yy"
     7265#line 1659 "parser.yy"
    72647266    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    72657267    break;
     
    72687270
    72697271/* Line 1806 of yacc.c  */
    7270 #line 1654 "parser.yy"
     7272#line 1662 "parser.yy"
    72717273    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    72727274    break;
     
    72757277
    72767278/* Line 1806 of yacc.c  */
    7277 #line 1656 "parser.yy"
     7279#line 1664 "parser.yy"
    72787280    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    72797281    break;
     
    72827284
    72837285/* Line 1806 of yacc.c  */
    7284 #line 1666 "parser.yy"
     7286#line 1674 "parser.yy"
    72857287    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    72867288    break;
     
    72897291
    72907292/* Line 1806 of yacc.c  */
    7291 #line 1672 "parser.yy"
     7293#line 1680 "parser.yy"
    72927294    {
    72937295                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    72997301
    73007302/* Line 1806 of yacc.c  */
    7301 #line 1677 "parser.yy"
     7303#line 1685 "parser.yy"
    73027304    {
    73037305                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73097311
    73107312/* Line 1806 of yacc.c  */
    7311 #line 1686 "parser.yy"
     7313#line 1694 "parser.yy"
    73127314    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73137315    break;
     
    73167318
    73177319/* Line 1806 of yacc.c  */
    7318 #line 1695 "parser.yy"
     7320#line 1703 "parser.yy"
    73197321    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    73207322    break;
     
    73237325
    73247326/* Line 1806 of yacc.c  */
    7325 #line 1697 "parser.yy"
     7327#line 1705 "parser.yy"
    73267328    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    73277329    break;
    73287330
    73297331  case 447:
    7330 
    7331 /* Line 1806 of yacc.c  */
    7332 #line 1722 "parser.yy"
    7333     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    7334     break;
    7335 
    7336   case 451:
    73377332
    73387333/* Line 1806 of yacc.c  */
     
    73417336    break;
    73427337
     7338  case 451:
     7339
     7340/* Line 1806 of yacc.c  */
     7341#line 1738 "parser.yy"
     7342    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     7343    break;
     7344
    73437345  case 452:
    73447346
    73457347/* Line 1806 of yacc.c  */
    7346 #line 1735 "parser.yy"
     7348#line 1743 "parser.yy"
    73477349    { (yyval.in) = 0; }
    73487350    break;
     
    73517353
    73527354/* Line 1806 of yacc.c  */
    7353 #line 1737 "parser.yy"
     7355#line 1745 "parser.yy"
    73547356    { (yyval.in) = (yyvsp[(2) - (2)].in); }
    73557357    break;
     
    73587360
    73597361/* Line 1806 of yacc.c  */
    7360 #line 1739 "parser.yy"
     7362#line 1747 "parser.yy"
    73617363    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    73627364    break;
     
    73657367
    73667368/* Line 1806 of yacc.c  */
    7367 #line 1743 "parser.yy"
     7369#line 1751 "parser.yy"
    73687370    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    73697371    break;
     
    73727374
    73737375/* Line 1806 of yacc.c  */
    7374 #line 1744 "parser.yy"
     7376#line 1752 "parser.yy"
    73757377    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    73767378    break;
     
    73797381
    73807382/* Line 1806 of yacc.c  */
    7381 #line 1749 "parser.yy"
     7383#line 1757 "parser.yy"
    73827384    { (yyval.in) = 0; }
    73837385    break;
     
    73867388
    73877389/* Line 1806 of yacc.c  */
    7388 #line 1751 "parser.yy"
     7390#line 1759 "parser.yy"
    73897391    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    73907392    break;
     
    73937395
    73947396/* Line 1806 of yacc.c  */
    7395 #line 1752 "parser.yy"
     7397#line 1760 "parser.yy"
    73967398    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
    73977399    break;
     
    74007402
    74017403/* Line 1806 of yacc.c  */
    7402 #line 1754 "parser.yy"
     7404#line 1762 "parser.yy"
    74037405    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    74047406    break;
     
    74077409
    74087410/* Line 1806 of yacc.c  */
    7409 #line 1770 "parser.yy"
     7411#line 1778 "parser.yy"
    74107412    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
    74117413    break;
     
    74147416
    74157417/* Line 1806 of yacc.c  */
    7416 #line 1776 "parser.yy"
     7418#line 1784 "parser.yy"
    74177419    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) ) ); }
    74187420    break;
     
    74217423
    74227424/* Line 1806 of yacc.c  */
    7423 #line 1782 "parser.yy"
     7425#line 1790 "parser.yy"
    74247426    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
    74257427    break;
     
    74287430
    74297431/* Line 1806 of yacc.c  */
    7430 #line 1785 "parser.yy"
     7432#line 1793 "parser.yy"
    74317433    { (yyval.en) = (yyvsp[(3) - (5)].en); }
    74327434    break;
     
    74357437
    74367438/* Line 1806 of yacc.c  */
    7437 #line 1787 "parser.yy"
     7439#line 1795 "parser.yy"
    74387440    { (yyval.en) = (yyvsp[(3) - (5)].en); }
    74397441    break;
     
    74427444
    74437445/* Line 1806 of yacc.c  */
    7444 #line 1789 "parser.yy"
     7446#line 1797 "parser.yy"
    74457447    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
    74467448    break;
     
    74497451
    74507452/* Line 1806 of yacc.c  */
    7451 #line 1791 "parser.yy"
     7453#line 1799 "parser.yy"
    74527454    { (yyval.en) = (yyvsp[(4) - (6)].en); }
    74537455    break;
     
    74567458
    74577459/* Line 1806 of yacc.c  */
    7458 #line 1815 "parser.yy"
     7460#line 1823 "parser.yy"
    74597461    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    74607462    break;
     
    74637465
    74647466/* Line 1806 of yacc.c  */
    7465 #line 1817 "parser.yy"
     7467#line 1825 "parser.yy"
    74667468    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    74677469    break;
     
    74707472
    74717473/* Line 1806 of yacc.c  */
    7472 #line 1819 "parser.yy"
     7474#line 1827 "parser.yy"
    74737475    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    74747476    break;
     
    74777479
    74787480/* Line 1806 of yacc.c  */
    7479 #line 1825 "parser.yy"
     7481#line 1833 "parser.yy"
    74807482    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    74817483    break;
     
    74847486
    74857487/* Line 1806 of yacc.c  */
    7486 #line 1827 "parser.yy"
     7488#line 1835 "parser.yy"
    74877489    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    74887490    break;
     
    74917493
    74927494/* Line 1806 of yacc.c  */
    7493 #line 1832 "parser.yy"
     7495#line 1840 "parser.yy"
    74947496    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    74957497    break;
     
    74987500
    74997501/* Line 1806 of yacc.c  */
    7500 #line 1838 "parser.yy"
     7502#line 1846 "parser.yy"
    75017503    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    75027504    break;
     
    75057507
    75067508/* Line 1806 of yacc.c  */
    7507 #line 1843 "parser.yy"
     7509#line 1851 "parser.yy"
    75087510    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    75097511    break;
     
    75127514
    75137515/* Line 1806 of yacc.c  */
    7514 #line 1845 "parser.yy"
     7516#line 1853 "parser.yy"
    75157517    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    75167518    break;
     
    75197521
    75207522/* Line 1806 of yacc.c  */
    7521 #line 1851 "parser.yy"
     7523#line 1859 "parser.yy"
    75227524    { (yyval.tclass) = DeclarationNode::Type; }
    75237525    break;
     
    75267528
    75277529/* Line 1806 of yacc.c  */
    7528 #line 1853 "parser.yy"
     7530#line 1861 "parser.yy"
    75297531    { (yyval.tclass) = DeclarationNode::Ftype; }
    75307532    break;
     
    75337535
    75347536/* Line 1806 of yacc.c  */
    7535 #line 1855 "parser.yy"
     7537#line 1863 "parser.yy"
    75367538    { (yyval.tclass) = DeclarationNode::Dtype; }
    75377539    break;
     
    75407542
    75417543/* Line 1806 of yacc.c  */
    7542 #line 1860 "parser.yy"
     7544#line 1868 "parser.yy"
    75437545    { (yyval.decl) = 0; }
    75447546    break;
     
    75477549
    75487550/* Line 1806 of yacc.c  */
    7549 #line 1862 "parser.yy"
     7551#line 1870 "parser.yy"
    75507552    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    75517553    break;
     
    75547556
    75557557/* Line 1806 of yacc.c  */
    7556 #line 1867 "parser.yy"
     7558#line 1875 "parser.yy"
    75577559    {
    75587560                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
     
    75647566
    75657567/* Line 1806 of yacc.c  */
    7566 #line 1872 "parser.yy"
     7568#line 1880 "parser.yy"
    75677569    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    75687570    break;
     
    75717573
    75727574/* Line 1806 of yacc.c  */
    7573 #line 1874 "parser.yy"
     7575#line 1882 "parser.yy"
    75747576    { (yyval.decl) = 0; }
    75757577    break;
     
    75787580
    75797581/* Line 1806 of yacc.c  */
    7580 #line 1879 "parser.yy"
     7582#line 1887 "parser.yy"
    75817583    { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
    75827584    break;
     
    75857587
    75867588/* Line 1806 of yacc.c  */
    7587 #line 1882 "parser.yy"
     7589#line 1890 "parser.yy"
    75887590    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
    75897591    break;
     
    75927594
    75937595/* Line 1806 of yacc.c  */
    7594 #line 1884 "parser.yy"
     7596#line 1892 "parser.yy"
    75957597    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    75967598    break;
     
    75997601
    76007602/* Line 1806 of yacc.c  */
    7601 #line 1889 "parser.yy"
     7603#line 1897 "parser.yy"
    76027604    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    76037605    break;
     
    76067608
    76077609/* Line 1806 of yacc.c  */
    7608 #line 1891 "parser.yy"
     7610#line 1899 "parser.yy"
    76097611    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    76107612    break;
     
    76137615
    76147616/* Line 1806 of yacc.c  */
    7615 #line 1893 "parser.yy"
     7617#line 1901 "parser.yy"
    76167618    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    76177619    break;
     
    76207622
    76217623/* Line 1806 of yacc.c  */
    7622 #line 1898 "parser.yy"
     7624#line 1906 "parser.yy"
    76237625    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    76247626    break;
     
    76277629
    76287630/* Line 1806 of yacc.c  */
    7629 #line 1900 "parser.yy"
     7631#line 1908 "parser.yy"
    76307632    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    76317633    break;
     
    76347636
    76357637/* Line 1806 of yacc.c  */
    7636 #line 1905 "parser.yy"
     7638#line 1913 "parser.yy"
    76377639    {
    76387640                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
     
    76447646
    76457647/* Line 1806 of yacc.c  */
    7646 #line 1910 "parser.yy"
     7648#line 1918 "parser.yy"
    76477649    {
    76487650                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
     
    76547656
    76557657/* Line 1806 of yacc.c  */
    7656 #line 1918 "parser.yy"
     7658#line 1926 "parser.yy"
    76577659    {
    76587660                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
     
    76647666
    76657667/* Line 1806 of yacc.c  */
    7666 #line 1923 "parser.yy"
     7668#line 1931 "parser.yy"
    76677669    {
    76687670                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
     
    76747676
    76757677/* Line 1806 of yacc.c  */
    7676 #line 1928 "parser.yy"
     7678#line 1936 "parser.yy"
    76777679    {
    76787680                        typedefTable.leaveTrait();
     
    76857687
    76867688/* Line 1806 of yacc.c  */
    7687 #line 1938 "parser.yy"
     7689#line 1946 "parser.yy"
    76887690    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    76897691    break;
     
    76927694
    76937695/* Line 1806 of yacc.c  */
    7694 #line 1948 "parser.yy"
     7696#line 1956 "parser.yy"
    76957697    {
    76967698                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77027704
    77037705/* Line 1806 of yacc.c  */
    7704 #line 1953 "parser.yy"
     7706#line 1961 "parser.yy"
    77057707    {
    77067708                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77127714
    77137715/* Line 1806 of yacc.c  */
    7714 #line 1958 "parser.yy"
     7716#line 1966 "parser.yy"
    77157717    {
    77167718                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    77227724
    77237725/* Line 1806 of yacc.c  */
    7724 #line 1966 "parser.yy"
     7726#line 1974 "parser.yy"
    77257727    {
    77267728                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77327734
    77337735/* Line 1806 of yacc.c  */
    7734 #line 1971 "parser.yy"
     7736#line 1979 "parser.yy"
    77357737    {
    77367738                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77427744
    77437745/* Line 1806 of yacc.c  */
    7744 #line 1981 "parser.yy"
     7746#line 1989 "parser.yy"
    77457747    {}
    77467748    break;
     
    77497751
    77507752/* Line 1806 of yacc.c  */
    7751 #line 1983 "parser.yy"
     7753#line 1991 "parser.yy"
    77527754    {
    77537755                        if ( theTree ) {
     
    77627764
    77637765/* Line 1806 of yacc.c  */
    7764 #line 1995 "parser.yy"
     7766#line 2003 "parser.yy"
    77657767    { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    77667768    break;
     
    77697771
    77707772/* Line 1806 of yacc.c  */
    7771 #line 2000 "parser.yy"
     7773#line 2008 "parser.yy"
    77727774    { (yyval.decl) = 0; }
    77737775    break;
     
    77767778
    77777779/* Line 1806 of yacc.c  */
    7778 #line 2008 "parser.yy"
     7780#line 2016 "parser.yy"
    77797781    {}
    77807782    break;
     
    77837785
    77847786/* Line 1806 of yacc.c  */
    7785 #line 2010 "parser.yy"
     7787#line 2018 "parser.yy"
    77867788    {
    77877789                        linkageStack.push( linkage );
     
    77937795
    77947796/* Line 1806 of yacc.c  */
    7795 #line 2015 "parser.yy"
     7797#line 2023 "parser.yy"
    77967798    {
    77977799                        linkage = linkageStack.top();
     
    78047806
    78057807/* Line 1806 of yacc.c  */
    7806 #line 2021 "parser.yy"
     7808#line 2029 "parser.yy"
    78077809    {   // mark all fields in list
    78087810                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    78157817
    78167818/* Line 1806 of yacc.c  */
    7817 #line 2036 "parser.yy"
     7819#line 2044 "parser.yy"
    78187820    {
    78197821                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78267828
    78277829/* Line 1806 of yacc.c  */
    7828 #line 2042 "parser.yy"
     7830#line 2050 "parser.yy"
    78297831    {
    78307832                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78377839
    78387840/* Line 1806 of yacc.c  */
    7839 #line 2051 "parser.yy"
     7841#line 2059 "parser.yy"
    78407842    {
    78417843                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78487850
    78497851/* Line 1806 of yacc.c  */
    7850 #line 2057 "parser.yy"
     7852#line 2065 "parser.yy"
    78517853    {
    78527854                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78597861
    78607862/* Line 1806 of yacc.c  */
    7861 #line 2063 "parser.yy"
     7863#line 2071 "parser.yy"
    78627864    {
    78637865                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78707872
    78717873/* Line 1806 of yacc.c  */
    7872 #line 2069 "parser.yy"
     7874#line 2077 "parser.yy"
    78737875    {
    78747876                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78817883
    78827884/* Line 1806 of yacc.c  */
    7883 #line 2075 "parser.yy"
     7885#line 2083 "parser.yy"
    78847886    {
    78857887                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78927894
    78937895/* Line 1806 of yacc.c  */
    7894 #line 2083 "parser.yy"
     7896#line 2091 "parser.yy"
    78957897    {
    78967898                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79017903
    79027904  case 536:
    7903 
    7904 /* Line 1806 of yacc.c  */
    7905 #line 2089 "parser.yy"
    7906     {
    7907                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    7908                         typedefTable.leaveScope();
    7909                         (yyval.decl) = (yyvsp[(2) - (5)].decl)->addOldDeclList( (yyvsp[(4) - (5)].decl) )->addFunctionBody( (yyvsp[(5) - (5)].sn) )->addQualifiers( (yyvsp[(1) - (5)].decl) );
    7910                 }
    7911     break;
    7912 
    7913   case 537:
    79147905
    79157906/* Line 1806 of yacc.c  */
     
    79227913    break;
    79237914
     7915  case 537:
     7916
     7917/* Line 1806 of yacc.c  */
     7918#line 2105 "parser.yy"
     7919    {
     7920                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     7921                        typedefTable.leaveScope();
     7922                        (yyval.decl) = (yyvsp[(2) - (5)].decl)->addOldDeclList( (yyvsp[(4) - (5)].decl) )->addFunctionBody( (yyvsp[(5) - (5)].sn) )->addQualifiers( (yyvsp[(1) - (5)].decl) );
     7923                }
     7924    break;
     7925
    79247926  case 538:
    79257927
    79267928/* Line 1806 of yacc.c  */
    7927 #line 2103 "parser.yy"
     7929#line 2111 "parser.yy"
    79287930    {
    79297931                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79367938
    79377939/* Line 1806 of yacc.c  */
    7938 #line 2118 "parser.yy"
     7940#line 2126 "parser.yy"
    79397941    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    79407942    break;
     
    79437945
    79447946/* Line 1806 of yacc.c  */
    7945 #line 2128 "parser.yy"
     7947#line 2136 "parser.yy"
    79467948    { (yyval.decl) = 0; }
    79477949    break;
     
    79507952
    79517953/* Line 1806 of yacc.c  */
    7952 #line 2135 "parser.yy"
     7954#line 2143 "parser.yy"
    79537955    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    79547956    break;
     
    79577959
    79587960/* Line 1806 of yacc.c  */
    7959 #line 2141 "parser.yy"
     7961#line 2149 "parser.yy"
    79607962    { (yyval.decl) = 0; }
    79617963    break;
     
    79647966
    79657967/* Line 1806 of yacc.c  */
    7966 #line 2156 "parser.yy"
     7968#line 2164 "parser.yy"
    79677969    {}
    79687970    break;
     
    79717973
    79727974/* Line 1806 of yacc.c  */
    7973 #line 2157 "parser.yy"
     7975#line 2165 "parser.yy"
    79747976    {}
    79757977    break;
     
    79787980
    79797981/* Line 1806 of yacc.c  */
    7980 #line 2158 "parser.yy"
     7982#line 2166 "parser.yy"
    79817983    {}
    79827984    break;
     
    79857987
    79867988/* Line 1806 of yacc.c  */
    7987 #line 2159 "parser.yy"
     7989#line 2167 "parser.yy"
    79887990    {}
    79897991    break;
     
    79927994
    79937995/* Line 1806 of yacc.c  */
    7994 #line 2194 "parser.yy"
     7996#line 2202 "parser.yy"
    79957997    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    79967998    break;
     
    79998001
    80008002/* Line 1806 of yacc.c  */
    8001 #line 2197 "parser.yy"
     8003#line 2205 "parser.yy"
    80028004    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80038005    break;
     
    80068008
    80078009/* Line 1806 of yacc.c  */
    8008 #line 2199 "parser.yy"
     8010#line 2207 "parser.yy"
    80098011    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80108012    break;
     
    80138015
    80148016/* Line 1806 of yacc.c  */
    8015 #line 2204 "parser.yy"
     8017#line 2212 "parser.yy"
    80168018    {
    80178019                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    80238025
    80248026/* Line 1806 of yacc.c  */
    8025 #line 2209 "parser.yy"
     8027#line 2217 "parser.yy"
    80268028    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80278029    break;
     
    80308032
    80318033/* Line 1806 of yacc.c  */
    8032 #line 2214 "parser.yy"
     8034#line 2222 "parser.yy"
    80338035    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    80348036    break;
     
    80378039
    80388040/* Line 1806 of yacc.c  */
    8039 #line 2216 "parser.yy"
     8041#line 2224 "parser.yy"
    80408042    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    80418043    break;
     
    80448046
    80458047/* Line 1806 of yacc.c  */
    8046 #line 2218 "parser.yy"
     8048#line 2226 "parser.yy"
    80478049    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80488050    break;
     
    80518053
    80528054/* Line 1806 of yacc.c  */
    8053 #line 2223 "parser.yy"
     8055#line 2231 "parser.yy"
    80548056    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    80558057    break;
     
    80588060
    80598061/* Line 1806 of yacc.c  */
    8060 #line 2225 "parser.yy"
     8062#line 2233 "parser.yy"
    80618063    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    80628064    break;
     
    80658067
    80668068/* Line 1806 of yacc.c  */
    8067 #line 2227 "parser.yy"
     8069#line 2235 "parser.yy"
    80688070    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    80698071    break;
     
    80728074
    80738075/* Line 1806 of yacc.c  */
    8074 #line 2229 "parser.yy"
     8076#line 2237 "parser.yy"
    80758077    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80768078    break;
     
    80798081
    80808082/* Line 1806 of yacc.c  */
    8081 #line 2234 "parser.yy"
     8083#line 2242 "parser.yy"
    80828084    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    80838085    break;
     
    80868088
    80878089/* Line 1806 of yacc.c  */
    8088 #line 2236 "parser.yy"
     8090#line 2244 "parser.yy"
    80898091    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80908092    break;
     
    80938095
    80948096/* Line 1806 of yacc.c  */
    8095 #line 2245 "parser.yy"
     8097#line 2253 "parser.yy"
    80968098    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80978099    break;
     
    81008102
    81018103/* Line 1806 of yacc.c  */
    8102 #line 2248 "parser.yy"
     8104#line 2256 "parser.yy"
    81038105    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81048106    break;
     
    81078109
    81088110/* Line 1806 of yacc.c  */
    8109 #line 2253 "parser.yy"
     8111#line 2261 "parser.yy"
    81108112    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    81118113    break;
     
    81148116
    81158117/* Line 1806 of yacc.c  */
    8116 #line 2255 "parser.yy"
     8118#line 2263 "parser.yy"
    81178119    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81188120    break;
     
    81218123
    81228124/* Line 1806 of yacc.c  */
    8123 #line 2257 "parser.yy"
     8125#line 2265 "parser.yy"
    81248126    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81258127    break;
     
    81288130
    81298131/* Line 1806 of yacc.c  */
    8130 #line 2262 "parser.yy"
     8132#line 2270 "parser.yy"
    81318133    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    81328134    break;
     
    81358137
    81368138/* Line 1806 of yacc.c  */
    8137 #line 2264 "parser.yy"
     8139#line 2272 "parser.yy"
    81388140    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    81398141    break;
     
    81428144
    81438145/* Line 1806 of yacc.c  */
    8144 #line 2266 "parser.yy"
     8146#line 2274 "parser.yy"
    81458147    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81468148    break;
     
    81498151
    81508152/* Line 1806 of yacc.c  */
    8151 #line 2271 "parser.yy"
     8153#line 2279 "parser.yy"
    81528154    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81538155    break;
     
    81568158
    81578159/* Line 1806 of yacc.c  */
    8158 #line 2273 "parser.yy"
     8160#line 2281 "parser.yy"
    81598161    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81608162    break;
     
    81638165
    81648166/* Line 1806 of yacc.c  */
    8165 #line 2275 "parser.yy"
     8167#line 2283 "parser.yy"
    81668168    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81678169    break;
     
    81708172
    81718173/* Line 1806 of yacc.c  */
    8172 #line 2290 "parser.yy"
     8174#line 2298 "parser.yy"
    81738175    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    81748176    break;
     
    81778179
    81788180/* Line 1806 of yacc.c  */
    8179 #line 2292 "parser.yy"
     8181#line 2300 "parser.yy"
    81808182    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    81818183    break;
     
    81848186
    81858187/* Line 1806 of yacc.c  */
    8186 #line 2294 "parser.yy"
     8188#line 2302 "parser.yy"
    81878189    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81888190    break;
     
    81918193
    81928194/* Line 1806 of yacc.c  */
    8193 #line 2299 "parser.yy"
     8195#line 2307 "parser.yy"
    81948196    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    81958197    break;
     
    81988200
    81998201/* Line 1806 of yacc.c  */
    8200 #line 2301 "parser.yy"
     8202#line 2309 "parser.yy"
    82018203    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    82028204    break;
     
    82058207
    82068208/* Line 1806 of yacc.c  */
    8207 #line 2303 "parser.yy"
     8209#line 2311 "parser.yy"
    82088210    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82098211    break;
     
    82128214
    82138215/* Line 1806 of yacc.c  */
    8214 #line 2308 "parser.yy"
     8216#line 2316 "parser.yy"
    82158217    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82168218    break;
     
    82198221
    82208222/* Line 1806 of yacc.c  */
    8221 #line 2310 "parser.yy"
     8223#line 2318 "parser.yy"
    82228224    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82238225    break;
     
    82268228
    82278229/* Line 1806 of yacc.c  */
    8228 #line 2312 "parser.yy"
     8230#line 2320 "parser.yy"
    82298231    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82308232    break;
     
    82338235
    82348236/* Line 1806 of yacc.c  */
    8235 #line 2327 "parser.yy"
     8237#line 2335 "parser.yy"
    82368238    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82378239    break;
     
    82408242
    82418243/* Line 1806 of yacc.c  */
    8242 #line 2330 "parser.yy"
     8244#line 2338 "parser.yy"
    82438245    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82448246    break;
     
    82478249
    82488250/* Line 1806 of yacc.c  */
    8249 #line 2332 "parser.yy"
     8251#line 2340 "parser.yy"
    82508252    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82518253    break;
     
    82548256
    82558257/* Line 1806 of yacc.c  */
    8256 #line 2338 "parser.yy"
     8258#line 2346 "parser.yy"
    82578259    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82588260    break;
     
    82618263
    82628264/* Line 1806 of yacc.c  */
    8263 #line 2343 "parser.yy"
     8265#line 2351 "parser.yy"
    82648266    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    82658267    break;
     
    82688270
    82698271/* Line 1806 of yacc.c  */
    8270 #line 2345 "parser.yy"
     8272#line 2353 "parser.yy"
    82718273    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    82728274    break;
     
    82758277
    82768278/* Line 1806 of yacc.c  */
    8277 #line 2347 "parser.yy"
     8279#line 2355 "parser.yy"
    82788280    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82798281    break;
     
    82828284
    82838285/* Line 1806 of yacc.c  */
    8284 #line 2352 "parser.yy"
     8286#line 2360 "parser.yy"
    82858287    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    82868288    break;
     
    82898291
    82908292/* Line 1806 of yacc.c  */
    8291 #line 2354 "parser.yy"
     8293#line 2362 "parser.yy"
    82928294    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82938295    break;
     
    82968298
    82978299/* Line 1806 of yacc.c  */
    8298 #line 2356 "parser.yy"
     8300#line 2364 "parser.yy"
    82998301    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83008302    break;
     
    83038305
    83048306/* Line 1806 of yacc.c  */
    8305 #line 2358 "parser.yy"
     8307#line 2366 "parser.yy"
    83068308    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83078309    break;
     
    83108312
    83118313/* Line 1806 of yacc.c  */
    8312 #line 2363 "parser.yy"
     8314#line 2371 "parser.yy"
    83138315    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    83148316    break;
     
    83178319
    83188320/* Line 1806 of yacc.c  */
    8319 #line 2365 "parser.yy"
     8321#line 2373 "parser.yy"
    83208322    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83218323    break;
     
    83248326
    83258327/* Line 1806 of yacc.c  */
    8326 #line 2367 "parser.yy"
     8328#line 2375 "parser.yy"
    83278329    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83288330    break;
     
    83318333
    83328334/* Line 1806 of yacc.c  */
    8333 #line 2377 "parser.yy"
     8335#line 2385 "parser.yy"
    83348336    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83358337    break;
     
    83388340
    83398341/* Line 1806 of yacc.c  */
    8340 #line 2380 "parser.yy"
     8342#line 2388 "parser.yy"
    83418343    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83428344    break;
     
    83458347
    83468348/* Line 1806 of yacc.c  */
    8347 #line 2382 "parser.yy"
     8349#line 2390 "parser.yy"
    83488350    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83498351    break;
     
    83528354
    83538355/* Line 1806 of yacc.c  */
    8354 #line 2387 "parser.yy"
     8356#line 2395 "parser.yy"
    83558357    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    83568358    break;
     
    83598361
    83608362/* Line 1806 of yacc.c  */
    8361 #line 2389 "parser.yy"
     8363#line 2397 "parser.yy"
    83628364    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    83638365    break;
     
    83668368
    83678369/* Line 1806 of yacc.c  */
    8368 #line 2391 "parser.yy"
     8370#line 2399 "parser.yy"
    83698371    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83708372    break;
     
    83738375
    83748376/* Line 1806 of yacc.c  */
    8375 #line 2396 "parser.yy"
     8377#line 2404 "parser.yy"
    83768378    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    83778379    break;
     
    83808382
    83818383/* Line 1806 of yacc.c  */
    8382 #line 2398 "parser.yy"
     8384#line 2406 "parser.yy"
    83838385    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83848386    break;
     
    83878389
    83888390/* Line 1806 of yacc.c  */
    8389 #line 2400 "parser.yy"
     8391#line 2408 "parser.yy"
    83908392    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83918393    break;
     
    83948396
    83958397/* Line 1806 of yacc.c  */
    8396 #line 2402 "parser.yy"
     8398#line 2410 "parser.yy"
    83978399    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83988400    break;
     
    84018403
    84028404/* Line 1806 of yacc.c  */
    8403 #line 2407 "parser.yy"
     8405#line 2415 "parser.yy"
    84048406    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    84058407    break;
     
    84088410
    84098411/* Line 1806 of yacc.c  */
    8410 #line 2409 "parser.yy"
     8412#line 2417 "parser.yy"
    84118413    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    84128414    break;
     
    84158417
    84168418/* Line 1806 of yacc.c  */
    8417 #line 2411 "parser.yy"
     8419#line 2419 "parser.yy"
    84188420    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84198421    break;
     
    84228424
    84238425/* Line 1806 of yacc.c  */
    8424 #line 2442 "parser.yy"
     8426#line 2450 "parser.yy"
    84258427    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84268428    break;
     
    84298431
    84308432/* Line 1806 of yacc.c  */
    8431 #line 2445 "parser.yy"
     8433#line 2453 "parser.yy"
    84328434    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84338435    break;
     
    84368438
    84378439/* Line 1806 of yacc.c  */
    8438 #line 2447 "parser.yy"
     8440#line 2455 "parser.yy"
    84398441    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84408442    break;
     
    84438445
    84448446/* Line 1806 of yacc.c  */
    8445 #line 2452 "parser.yy"
     8447#line 2460 "parser.yy"
    84468448    {
    84478449                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    84538455
    84548456/* Line 1806 of yacc.c  */
    8455 #line 2457 "parser.yy"
     8457#line 2465 "parser.yy"
    84568458    {
    84578459                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    84638465
    84648466/* Line 1806 of yacc.c  */
    8465 #line 2465 "parser.yy"
     8467#line 2473 "parser.yy"
    84668468    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    84678469    break;
     
    84708472
    84718473/* Line 1806 of yacc.c  */
    8472 #line 2467 "parser.yy"
     8474#line 2475 "parser.yy"
    84738475    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84748476    break;
     
    84778479
    84788480/* Line 1806 of yacc.c  */
    8479 #line 2469 "parser.yy"
     8481#line 2477 "parser.yy"
    84808482    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84818483    break;
     
    84848486
    84858487/* Line 1806 of yacc.c  */
    8486 #line 2474 "parser.yy"
     8488#line 2482 "parser.yy"
    84878489    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    84888490    break;
     
    84918493
    84928494/* Line 1806 of yacc.c  */
    8493 #line 2476 "parser.yy"
     8495#line 2484 "parser.yy"
    84948496    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84958497    break;
     
    84988500
    84998501/* Line 1806 of yacc.c  */
    8500 #line 2481 "parser.yy"
     8502#line 2489 "parser.yy"
    85018503    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    85028504    break;
     
    85058507
    85068508/* Line 1806 of yacc.c  */
    8507 #line 2483 "parser.yy"
     8509#line 2491 "parser.yy"
    85088510    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85098511    break;
     
    85128514
    85138515/* Line 1806 of yacc.c  */
    8514 #line 2498 "parser.yy"
     8516#line 2506 "parser.yy"
    85158517    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85168518    break;
     
    85198521
    85208522/* Line 1806 of yacc.c  */
    8521 #line 2500 "parser.yy"
     8523#line 2508 "parser.yy"
    85228524    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85238525    break;
     
    85268528
    85278529/* Line 1806 of yacc.c  */
    8528 #line 2505 "parser.yy"
     8530#line 2513 "parser.yy"
    85298531    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    85308532    break;
     
    85338535
    85348536/* Line 1806 of yacc.c  */
    8535 #line 2507 "parser.yy"
     8537#line 2515 "parser.yy"
    85368538    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    85378539    break;
     
    85408542
    85418543/* Line 1806 of yacc.c  */
    8542 #line 2509 "parser.yy"
     8544#line 2517 "parser.yy"
    85438545    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    85448546    break;
     
    85478549
    85488550/* Line 1806 of yacc.c  */
    8549 #line 2511 "parser.yy"
     8551#line 2519 "parser.yy"
    85508552    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    85518553    break;
     
    85548556
    85558557/* Line 1806 of yacc.c  */
    8556 #line 2513 "parser.yy"
     8558#line 2521 "parser.yy"
    85578559    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85588560    break;
     
    85618563
    85628564/* Line 1806 of yacc.c  */
    8563 #line 2519 "parser.yy"
     8565#line 2527 "parser.yy"
    85648566    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85658567    break;
     
    85688570
    85698571/* Line 1806 of yacc.c  */
    8570 #line 2521 "parser.yy"
     8572#line 2529 "parser.yy"
    85718573    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85728574    break;
     
    85758577
    85768578/* Line 1806 of yacc.c  */
    8577 #line 2523 "parser.yy"
     8579#line 2531 "parser.yy"
    85788580    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85798581    break;
     
    85828584
    85838585/* Line 1806 of yacc.c  */
    8584 #line 2528 "parser.yy"
     8586#line 2536 "parser.yy"
    85858587    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    85868588    break;
     
    85898591
    85908592/* Line 1806 of yacc.c  */
    8591 #line 2530 "parser.yy"
     8593#line 2538 "parser.yy"
    85928594    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85938595    break;
     
    85968598
    85978599/* Line 1806 of yacc.c  */
    8598 #line 2532 "parser.yy"
     8600#line 2540 "parser.yy"
    85998601    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86008602    break;
     
    86038605
    86048606/* Line 1806 of yacc.c  */
    8605 #line 2538 "parser.yy"
     8607#line 2546 "parser.yy"
    86068608    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    86078609    break;
     
    86108612
    86118613/* Line 1806 of yacc.c  */
    8612 #line 2540 "parser.yy"
     8614#line 2548 "parser.yy"
    86138615    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    86148616    break;
     
    86178619
    86188620/* Line 1806 of yacc.c  */
    8619 #line 2546 "parser.yy"
     8621#line 2554 "parser.yy"
    86208622    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    86218623    break;
     
    86248626
    86258627/* Line 1806 of yacc.c  */
    8626 #line 2548 "parser.yy"
     8628#line 2556 "parser.yy"
    86278629    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    86288630    break;
     
    86318633
    86328634/* Line 1806 of yacc.c  */
    8633 #line 2550 "parser.yy"
     8635#line 2558 "parser.yy"
    86348636    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    86358637    break;
     
    86388640
    86398641/* Line 1806 of yacc.c  */
    8640 #line 2552 "parser.yy"
     8642#line 2560 "parser.yy"
    86418643    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    86428644    break;
     
    86458647
    86468648/* Line 1806 of yacc.c  */
    8647 #line 2567 "parser.yy"
     8649#line 2575 "parser.yy"
    86488650    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86498651    break;
     
    86528654
    86538655/* Line 1806 of yacc.c  */
    8654 #line 2569 "parser.yy"
     8656#line 2577 "parser.yy"
    86558657    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86568658    break;
     
    86598661
    86608662/* Line 1806 of yacc.c  */
    8661 #line 2574 "parser.yy"
     8663#line 2582 "parser.yy"
    86628664    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    86638665    break;
     
    86668668
    86678669/* Line 1806 of yacc.c  */
    8668 #line 2576 "parser.yy"
     8670#line 2584 "parser.yy"
    86698671    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    86708672    break;
     
    86738675
    86748676/* Line 1806 of yacc.c  */
    8675 #line 2578 "parser.yy"
     8677#line 2586 "parser.yy"
    86768678    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    86778679    break;
     
    86808682
    86818683/* Line 1806 of yacc.c  */
    8682 #line 2580 "parser.yy"
     8684#line 2588 "parser.yy"
    86838685    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    86848686    break;
     
    86878689
    86888690/* Line 1806 of yacc.c  */
    8689 #line 2582 "parser.yy"
     8691#line 2590 "parser.yy"
    86908692    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86918693    break;
     
    86948696
    86958697/* Line 1806 of yacc.c  */
    8696 #line 2588 "parser.yy"
     8698#line 2596 "parser.yy"
    86978699    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86988700    break;
     
    87018703
    87028704/* Line 1806 of yacc.c  */
    8703 #line 2590 "parser.yy"
     8705#line 2598 "parser.yy"
    87048706    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87058707    break;
     
    87088710
    87098711/* Line 1806 of yacc.c  */
    8710 #line 2592 "parser.yy"
     8712#line 2600 "parser.yy"
    87118713    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87128714    break;
     
    87158717
    87168718/* Line 1806 of yacc.c  */
    8717 #line 2597 "parser.yy"
     8719#line 2605 "parser.yy"
    87188720    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    87198721    break;
     
    87228724
    87238725/* Line 1806 of yacc.c  */
    8724 #line 2599 "parser.yy"
     8726#line 2607 "parser.yy"
    87258727    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87268728    break;
     
    87298731
    87308732/* Line 1806 of yacc.c  */
    8731 #line 2601 "parser.yy"
     8733#line 2609 "parser.yy"
    87328734    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87338735    break;
     
    87368738
    87378739/* Line 1806 of yacc.c  */
    8738 #line 2608 "parser.yy"
     8740#line 2616 "parser.yy"
    87398741    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    87408742    break;
     
    87438745
    87448746/* Line 1806 of yacc.c  */
    8745 #line 2619 "parser.yy"
     8747#line 2627 "parser.yy"
    87468748    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    87478749    break;
     
    87508752
    87518753/* Line 1806 of yacc.c  */
    8752 #line 2622 "parser.yy"
     8754#line 2630 "parser.yy"
    87538755    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    87548756    break;
     
    87578759
    87588760/* Line 1806 of yacc.c  */
    8759 #line 2624 "parser.yy"
     8761#line 2632 "parser.yy"
    87608762    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    87618763    break;
     
    87648766
    87658767/* Line 1806 of yacc.c  */
    8766 #line 2627 "parser.yy"
     8768#line 2635 "parser.yy"
    87678769    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    87688770    break;
     
    87718773
    87728774/* Line 1806 of yacc.c  */
    8773 #line 2629 "parser.yy"
     8775#line 2637 "parser.yy"
    87748776    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    87758777    break;
     
    87788780
    87798781/* Line 1806 of yacc.c  */
    8780 #line 2631 "parser.yy"
     8782#line 2639 "parser.yy"
    87818783    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    87828784    break;
     
    87858787
    87868788/* Line 1806 of yacc.c  */
    8787 #line 2645 "parser.yy"
     8789#line 2653 "parser.yy"
    87888790    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87898791    break;
     
    87928794
    87938795/* Line 1806 of yacc.c  */
    8794 #line 2647 "parser.yy"
     8796#line 2655 "parser.yy"
    87958797    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87968798    break;
     
    87998801
    88008802/* Line 1806 of yacc.c  */
    8801 #line 2652 "parser.yy"
     8803#line 2660 "parser.yy"
    88028804    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    88038805    break;
     
    88068808
    88078809/* Line 1806 of yacc.c  */
    8808 #line 2654 "parser.yy"
     8810#line 2662 "parser.yy"
    88098811    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    88108812    break;
     
    88138815
    88148816/* Line 1806 of yacc.c  */
    8815 #line 2656 "parser.yy"
     8817#line 2664 "parser.yy"
    88168818    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    88178819    break;
     
    88208822
    88218823/* Line 1806 of yacc.c  */
    8822 #line 2658 "parser.yy"
     8824#line 2666 "parser.yy"
    88238825    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    88248826    break;
     
    88278829
    88288830/* Line 1806 of yacc.c  */
    8829 #line 2660 "parser.yy"
     8831#line 2668 "parser.yy"
    88308832    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88318833    break;
     
    88348836
    88358837/* Line 1806 of yacc.c  */
    8836 #line 2666 "parser.yy"
     8838#line 2674 "parser.yy"
    88378839    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    88388840    break;
     
    88418843
    88428844/* Line 1806 of yacc.c  */
    8843 #line 2668 "parser.yy"
     8845#line 2676 "parser.yy"
    88448846    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    88458847    break;
     
    88488850
    88498851/* Line 1806 of yacc.c  */
    8850 #line 2670 "parser.yy"
     8852#line 2678 "parser.yy"
    88518853    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88528854    break;
     
    88558857
    88568858/* Line 1806 of yacc.c  */
    8857 #line 2675 "parser.yy"
     8859#line 2683 "parser.yy"
    88588860    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    88598861    break;
     
    88628864
    88638865/* Line 1806 of yacc.c  */
    8864 #line 2677 "parser.yy"
     8866#line 2685 "parser.yy"
    88658867    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88668868    break;
     
    88698871
    88708872/* Line 1806 of yacc.c  */
    8871 #line 2687 "parser.yy"
     8873#line 2695 "parser.yy"
    88728874    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    88738875    break;
    88748876
    88758877  case 706:
    8876 
    8877 /* Line 1806 of yacc.c  */
    8878 #line 2697 "parser.yy"
    8879     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    8880     break;
    8881 
    8882   case 707:
    8883 
    8884 /* Line 1806 of yacc.c  */
    8885 #line 2699 "parser.yy"
    8886     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    8887     break;
    8888 
    8889   case 708:
    8890 
    8891 /* Line 1806 of yacc.c  */
    8892 #line 2701 "parser.yy"
    8893     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    8894     break;
    8895 
    8896   case 709:
    8897 
    8898 /* Line 1806 of yacc.c  */
    8899 #line 2703 "parser.yy"
    8900     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    8901     break;
    8902 
    8903   case 710:
    89048878
    89058879/* Line 1806 of yacc.c  */
     
    89088882    break;
    89098883
    8910   case 711:
     8884  case 707:
    89118885
    89128886/* Line 1806 of yacc.c  */
     
    89158889    break;
    89168890
     8891  case 708:
     8892
     8893/* Line 1806 of yacc.c  */
     8894#line 2709 "parser.yy"
     8895    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     8896    break;
     8897
     8898  case 709:
     8899
     8900/* Line 1806 of yacc.c  */
     8901#line 2711 "parser.yy"
     8902    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     8903    break;
     8904
     8905  case 710:
     8906
     8907/* Line 1806 of yacc.c  */
     8908#line 2713 "parser.yy"
     8909    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     8910    break;
     8911
     8912  case 711:
     8913
     8914/* Line 1806 of yacc.c  */
     8915#line 2715 "parser.yy"
     8916    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     8917    break;
     8918
    89178919  case 712:
    89188920
    89198921/* Line 1806 of yacc.c  */
    8920 #line 2714 "parser.yy"
     8922#line 2722 "parser.yy"
    89218923    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89228924    break;
     
    89258927
    89268928/* Line 1806 of yacc.c  */
    8927 #line 2716 "parser.yy"
     8929#line 2724 "parser.yy"
    89288930    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    89298931    break;
     
    89328934
    89338935/* Line 1806 of yacc.c  */
    8934 #line 2718 "parser.yy"
     8936#line 2726 "parser.yy"
    89358937    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89368938    break;
     
    89398941
    89408942/* Line 1806 of yacc.c  */
    8941 #line 2720 "parser.yy"
     8943#line 2728 "parser.yy"
    89428944    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    89438945    break;
     
    89468948
    89478949/* Line 1806 of yacc.c  */
    8948 #line 2722 "parser.yy"
     8950#line 2730 "parser.yy"
    89498951    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    89508952    break;
     
    89538955
    89548956/* Line 1806 of yacc.c  */
    8955 #line 2724 "parser.yy"
     8957#line 2732 "parser.yy"
    89568958    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89578959    break;
     
    89608962
    89618963/* Line 1806 of yacc.c  */
    8962 #line 2726 "parser.yy"
     8964#line 2734 "parser.yy"
    89638965    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    89648966    break;
     
    89678969
    89688970/* Line 1806 of yacc.c  */
    8969 #line 2728 "parser.yy"
     8971#line 2736 "parser.yy"
    89708972    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89718973    break;
     
    89748976
    89758977/* Line 1806 of yacc.c  */
    8976 #line 2730 "parser.yy"
     8978#line 2738 "parser.yy"
    89778979    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    89788980    break;
     
    89818983
    89828984/* Line 1806 of yacc.c  */
    8983 #line 2732 "parser.yy"
     8985#line 2740 "parser.yy"
    89848986    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    89858987    break;
     
    89888990
    89898991/* Line 1806 of yacc.c  */
    8990 #line 2737