Changes in / [1b0020a:4e2a1137]


Ignore:
Location:
src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

    r1b0020a r4e2a1137  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  4 13:35:30 2016
    13 // Update Count     : 352
     12// Last Modified On : Thu Aug  4 11:16:21 2016
     13// Update Count     : 351
    1414//
    1515
     
    494494        }
    495495
    496         void CodeGenerator::visit( RangeExpr * rangeExpr ) {
    497                 rangeExpr->get_low()->accept( *this );
    498                 output << " ... ";
    499                 rangeExpr->get_high()->accept( *this );
    500         }
    501 
    502496        void CodeGenerator::visit( NameExpr * nameExpr ) {
    503497                extension( nameExpr );
  • src/CodeGen/CodeGenerator.h

    r1b0020a r4e2a1137  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  4 13:37:07 2016
    13 // Update Count     : 38
     12// Last Modified On : Sat Jul 30 11:10:42 2016
     13// Update Count     : 37
    1414//
    1515
     
    5454                virtual void visit( ApplicationExpr *applicationExpr );
    5555                virtual void visit( UntypedExpr *untypedExpr );
    56                 virtual void visit( RangeExpr * rangeExpr );
    5756                virtual void visit( NameExpr *nameExpr );
    5857                virtual void visit( AddressExpr *addressExpr );
  • src/Parser/ExpressionNode.cc

    r1b0020a r4e2a1137  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 07:56:23 2016
    13 // Update Count     : 375
     12// Last Modified On : Tue Aug  2 15:10:23 2016
     13// Update Count     : 322
    1414//
    1515
     
    258258OperatorNode::~OperatorNode() {}
    259259
    260 OperatorNode::Type OperatorNode::get_type( void ) const {
     260OperatorNode::Type OperatorNode::get_type( void ) const{
    261261        return type;
    262262}
     
    311311}
    312312
    313 
    314 Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node ) {
    315         DeclarationNode *decl_node = arg->get_decl();
    316 
    317         Type *targetType = decl_node->buildType();
    318         if ( dynamic_cast< VoidType* >( targetType ) ) {
    319                 delete targetType;
    320                 return new CastExpr( maybeBuild<Expression>(expr_node) );
    321         } else {
    322                 return new CastExpr( maybeBuild<Expression>(expr_node), targetType );
    323         } // if
    324 }
    325 
    326 Expression *build_fieldSel( ExpressionNode *expr_node, VarRefNode *member ) {
    327         NameExpr* memberExpr = dynamic_cast<NameExpr*> ( maybeBuild<Expression>( member) );
    328         assert( memberExpr );
    329         UntypedMemberExpr *ret = new UntypedMemberExpr( memberExpr->get_name(), maybeBuild<Expression>(expr_node) );
    330         delete member;
    331         return ret;
    332 }
    333 
    334 Expression *build_pfieldSel( ExpressionNode *expr_node, VarRefNode *member ) {
    335         NameExpr* memberExpr = dynamic_cast<NameExpr*> ( maybeBuild<Expression>( member) );
    336         assert( memberExpr );
    337         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
    338         deref->get_args().push_back( maybeBuild<Expression>(expr_node) );
    339         UntypedMemberExpr *ret = new UntypedMemberExpr( memberExpr->get_name(), deref );
    340         delete member;
    341         return ret;
    342 }
    343 
    344 Expression *build_addressOf( ExpressionNode *expr_node ) {
    345                 return new AddressExpr( maybeBuild<Expression>(expr_node) );
    346 }
    347 Expression *build_sizeOf( ExpressionNode *expr_node ) {
    348         if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr_node ) ) {
    349                 return new SizeofExpr( arg->get_decl()->buildType() );
    350         } else {
    351                 return new SizeofExpr( maybeBuild<Expression>(expr_node) );
    352         } // if
    353 }
    354 Expression *build_alignOf( ExpressionNode *expr_node ) {
    355         if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( expr_node ) ) {
    356                 return new AlignofExpr( arg->get_decl()->buildType() );
    357         } else {
    358                 return new AlignofExpr( maybeBuild<Expression>(expr_node) );
    359         } // if
    360 }
    361 Expression *build_offsetOf( TypeValueNode * arg, VarRefNode *member ) {
    362         NameExpr *memberExpr = dynamic_cast<NameExpr *>( maybeBuild<Expression>( member ) );
    363         assert( memberExpr );
    364         return new UntypedOffsetofExpr( arg->get_decl()->buildType(), memberExpr->get_name() );
    365 }
    366 
    367 Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ) {
    368         return new LogicalExpr( notZeroExpr( maybeBuild<Expression>(expr_node1) ), notZeroExpr( maybeBuild<Expression>(expr_node2) ), kind );
    369 }
    370 
    371 Expression *build_opr1( OperatorNode::Type op, ExpressionNode *expr_node ) {
    372         std::list<Expression *> args;
    373         args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node) ) );
    374         return new UntypedExpr( new NameExpr( opName[ op ] ), args );
    375 }
    376 Expression *build_opr2( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
    377         std::list<Expression *> args;
    378         args.push_back( maybeBuild<Expression>(expr_node1) );
    379         args.push_back( maybeBuild<Expression>(expr_node2) );
    380         return new UntypedExpr( new NameExpr( opName[ op ] ), args );
    381 }
    382 
    383 Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) {
    384         return new ConditionalExpr( notZeroExpr( maybeBuild<Expression>(expr_node1) ), maybeBuild<Expression>(expr_node2), maybeBuild<Expression>(expr_node3) );
    385 }
    386 
    387 Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
    388         return new CommaExpr( maybeBuild<Expression>(expr_node1), maybeBuild<Expression>(expr_node2) );
    389 }
    390 
    391 CompositeExprNode2::CompositeExprNode2( Expression *expr ) : expr( expr ) {}
    392 CompositeExprNode2::CompositeExprNode2( const CompositeExprNode2 &other ) : expr( other.expr->clone() ) {}
    393 CompositeExprNode2::~CompositeExprNode2() { delete expr; }
    394 void CompositeExprNode2::print( std::ostream &, int indent ) const { assert( false ); }
    395 void CompositeExprNode2::printOneLine( std::ostream &, int indent ) const { assert( false ); }
    396 
     313#include "Common/utility.h"
    397314
    398315Expression *CompositeExprNode::build() const {
     
    406323        } // if
    407324
    408         switch ( op->get_type() ) {
     325        switch ( op->get_type()) {
     326          case OperatorNode::Incr:
     327          case OperatorNode::Decr:
     328          case OperatorNode::IncrPost:
     329          case OperatorNode::DecrPost:
    409330          case OperatorNode::Assign:
    410331          case OperatorNode::MulAssn:
     
    418339          case OperatorNode::ERAssn:
    419340          case OperatorNode::OrAssn:
     341                // the rewrite rules for these expressions specify that the first argument has its address taken
    420342                assert( ! args.empty() );
    421343                args.front() = new AddressExpr( args.front() );
     344                break;
     345          default:              // do nothing
     346                ;
     347        } // switch
     348
     349        switch ( op->get_type() ) {
     350          case OperatorNode::Incr:
     351          case OperatorNode::Decr:
     352          case OperatorNode::IncrPost:
     353          case OperatorNode::DecrPost:
     354          case OperatorNode::Assign:
     355          case OperatorNode::MulAssn:
     356          case OperatorNode::DivAssn:
     357          case OperatorNode::ModAssn:
     358          case OperatorNode::PlusAssn:
     359          case OperatorNode::MinusAssn:
     360          case OperatorNode::LSAssn:
     361          case OperatorNode::RSAssn:
     362          case OperatorNode::AndAssn:
     363          case OperatorNode::ERAssn:
     364          case OperatorNode::OrAssn:
     365          case OperatorNode::Plus:
     366          case OperatorNode::Minus:
     367          case OperatorNode::Mul:
     368          case OperatorNode::Div:
     369          case OperatorNode::Mod:
     370          case OperatorNode::BitOr:
     371          case OperatorNode::BitAnd:
     372          case OperatorNode::Xor:
     373          case OperatorNode::LShift:
     374          case OperatorNode::RShift:
     375          case OperatorNode::LThan:
     376          case OperatorNode::GThan:
     377          case OperatorNode::LEThan:
     378          case OperatorNode::GEThan:
     379          case OperatorNode::Eq:
     380          case OperatorNode::Neq:
     381          case OperatorNode::Index:
     382          case OperatorNode::Range:
    422383          case OperatorNode::UnPlus:
    423384          case OperatorNode::UnMinus:
     
    427388          case OperatorNode::LabelAddress:
    428389                return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args );
    429 
     390          case OperatorNode::AddressOf:
     391                assert( args.size() == 1 );
     392                assert( args.front() );
     393
     394                return new AddressExpr( args.front() );
     395          case OperatorNode::Cast:
     396                {
     397                        TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
     398                        assert( arg );
     399
     400                        DeclarationNode *decl_node = arg->get_decl();
     401                        ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
     402
     403                        Type *targetType = decl_node->buildType();
     404                        if ( dynamic_cast< VoidType* >( targetType ) ) {
     405                                delete targetType;
     406                                return new CastExpr( maybeBuild<Expression>(expr_node), maybeBuild< Expression >( get_argName() ) );
     407                        } else {
     408                                return new CastExpr( maybeBuild<Expression>(expr_node),targetType, maybeBuild< Expression >( get_argName() ) );
     409                        } // if
     410                }
     411          case OperatorNode::FieldSel:
     412                {
     413                        assert( args.size() == 2 );
     414
     415                        NameExpr *member = dynamic_cast<NameExpr *>( args.back());
     416                        // TupleExpr *memberTup = dynamic_cast<TupleExpr *>( args.back());
     417
     418                        if ( member != 0 ) {
     419                                UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front());
     420                                delete member;
     421                                return ret;
     422                                /* else if ( memberTup != 0 )
     423                                   {
     424                                   UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
     425                                   delete member;
     426                                   return ret;
     427                                   } */
     428                        } else
     429                                assert( false );
     430                }
     431          case OperatorNode::PFieldSel:
     432                {
     433                        assert( args.size() == 2 );
     434
     435                        NameExpr *member = dynamic_cast<NameExpr *>( args.back());  // modify for Tuples   xxx
     436                        assert( member != 0 );
     437
     438                        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
     439                        deref->get_args().push_back( args.front() );
     440
     441                        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
     442                        delete member;
     443                        return ret;
     444                }
     445          case OperatorNode::SizeOf:
     446                {
     447                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
     448                                return new SizeofExpr( arg->get_decl()->buildType());
     449                        } else {
     450                                return new SizeofExpr( args.front());
     451                        } // if
     452                }
     453          case OperatorNode::AlignOf:
     454                {
     455                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
     456                                return new AlignofExpr( arg->get_decl()->buildType());
     457                        } else {
     458                                return new AlignofExpr( args.front());
     459                        } // if
     460                }
     461          case OperatorNode::OffsetOf:
     462                {
     463                        assert( args.size() == 2 );
     464
     465                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args() ) ) {
     466                                NameExpr *member = dynamic_cast<NameExpr *>( args.back() );
     467                                assert( member != 0 );
     468
     469                                return new UntypedOffsetofExpr( arg->get_decl()->buildType(), member->get_name() );
     470                        } else assert( false );
     471                }
    430472          case OperatorNode::Attr:
    431473                {
    432                         VarRefNode *var = dynamic_cast<VarRefNode *>( get_args() );
     474                        VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
    433475                        assert( var );
    434476                        if ( ! get_args()->get_link() ) {
    435477                                return new AttrExpr( maybeBuild<Expression>(var), ( Expression*)0);
    436                         } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link() ) ) {
    437                                 return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() );
     478                        } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
     479                                return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType());
    438480                        } else {
    439                                 return new AttrExpr( maybeBuild<Expression>(var), args.back() );
     481                                return new AttrExpr( maybeBuild<Expression>(var), args.back());
    440482                        } // if
    441483                }
     484          case OperatorNode::Or:
     485          case OperatorNode::And:
     486                assert( args.size() == 2);
     487                return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) );
    442488          case OperatorNode::Cond:
    443489                {
     
    451497          case OperatorNode::NCond:
    452498                throw UnimplementedError( "GNU 2-argument conditional expression" );
     499          case OperatorNode::Comma:
     500                {
     501                        assert( args.size() == 2);
     502                        std::list< Expression * >::const_iterator i = args.begin();
     503                        Expression *ret = *i++;
     504                        while ( i != args.end() ) {
     505                                ret = new CommaExpr( ret, *i++ );
     506                        }
     507                        return ret;
     508                }
    453509                // Tuples
    454510          case OperatorNode::TupleC:
     
    459515                }
    460516          default:
    461                 assert( ((void)"CompositeExprNode::build", false) );
     517                // shouldn't happen
     518                assert( false );
    462519                return 0;
    463520        } // switch
     
    548605
    549606void LabelNode::printOneLine( std::ostream &os, int indent ) const {}
     607
     608//##############################################################################
     609
     610CommaExprNode::CommaExprNode(): CompositeExprNode( new OperatorNode( OperatorNode::Comma )) {}
     611
     612CommaExprNode::CommaExprNode( ExpressionNode *exp ) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp ) {
     613}
     614
     615CommaExprNode::CommaExprNode( ExpressionNode *exp1, ExpressionNode *exp2) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp1, exp2) {
     616}
     617
     618// CommaExprNode *CommaExprNode::add_to_list( ExpressionNode *exp ) {
     619//      add_arg( exp );
     620//
     621//      return this;
     622// }
     623
     624CommaExprNode::CommaExprNode( const CommaExprNode &other ) : CompositeExprNode( other ) {
     625}
    550626
    551627//##############################################################################
     
    698774}
    699775
     776
    700777ExpressionNode *flattenCommas( ExpressionNode *list ) {
    701778        if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {
  • src/Parser/ParseNode.h

    r1b0020a r4e2a1137  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 07:49:32 2016
    13 // Update Count     : 288
     12// Last Modified On : Sun Jul 24 02:17:00 2016
     13// Update Count     : 269
    1414//
    1515
     
    225225};
    226226
    227 Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node );
    228 Expression *build_fieldSel( ExpressionNode *expr_node, VarRefNode *member );
    229 Expression *build_pfieldSel( ExpressionNode *expr_node, VarRefNode *member );
    230 Expression *build_addressOf( ExpressionNode *expr_node );
    231 Expression *build_sizeOf( ExpressionNode *expr_node );
    232 Expression *build_alignOf( ExpressionNode *expr_node );
    233 Expression *build_offsetOf( TypeValueNode * arg, VarRefNode *member );
    234 Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
    235 Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
    236 Expression *build_opr1( OperatorNode::Type op, ExpressionNode *expr_node );
    237 Expression *build_opr2( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
    238 Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
    239 Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
    240 
    241 class CompositeExprNode2 : public ExpressionNode {
    242   public:
    243         CompositeExprNode2( Expression *expr );
    244         CompositeExprNode2( const CompositeExprNode2 &other );
    245         virtual ~CompositeExprNode2();
    246 
    247         virtual CompositeExprNode2 *clone() const { return new CompositeExprNode2( *this ); }
    248         virtual Expression *build() const { return expr->clone(); }
    249 
    250         virtual void print( std::ostream &, int indent = 0) const;
    251         virtual void printOneLine( std::ostream &, int indent = 0) const;
    252   private:
    253         Expression *expr;
    254 };
    255 
    256227class CompositeExprNode : public ExpressionNode {
    257228  public:
     
    319290  private:
    320291        std::list< Label > labels;
     292};
     293
     294class CommaExprNode : public CompositeExprNode {
     295  public:
     296        CommaExprNode();
     297        CommaExprNode( ExpressionNode * );
     298        CommaExprNode( ExpressionNode *, ExpressionNode * );
     299        CommaExprNode( const CommaExprNode &other );
     300
     301        // virtual CommaExprNode *add_to_list( ExpressionNode * );
     302        virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); }
    321303};
    322304
     
    551533};
    552534
     535class NullStmtNode : public CompoundStmtNode {
     536  public:
     537        Statement *build() const;
     538        void print( std::ostream &, int indent = 0 ) const;
     539};
     540
    553541class InitializerNode : public ParseNode {
    554542  public:
  • src/Parser/StatementNode.cc

    r1b0020a r4e2a1137  
    417417}
    418418
     419
     420void NullStmtNode::print( ostream &os, int indent ) const {
     421        os << string( indent, ' ' ) << "Null Statement:" << endl;
     422}
     423
     424Statement *NullStmtNode::build() const {
     425        return new NullStmt;
     426}
     427
    419428// Local Variables: //
    420429// tab-width: 4 //
  • src/Parser/parser.cc

    r1b0020a r4e2a1137  
    354354        LabelNode *label;
    355355        InitializerNode *in;
    356         OperatorNode::Type op;
    357356        bool flag;
    358357
     
    360359
    361360/* Line 293 of yacc.c  */
    362 #line 363 "Parser/parser.cc"
     361#line 362 "Parser/parser.cc"
    363362} YYSTYPE;
    364363# define YYSTYPE_IS_TRIVIAL 1
     
    372371
    373372/* Line 343 of yacc.c  */
    374 #line 375 "Parser/parser.cc"
     373#line 374 "Parser/parser.cc"
    375374
    376375#ifdef short
     
    10171016static const yytype_uint16 yyrline[] =
    10181017{
    1019        0,   292,   292,   298,   307,   308,   309,   313,   314,   315,
    1020      319,   320,   324,   325,   329,   330,   334,   335,   341,   343,
    1021      345,   347,   352,   353,   359,   363,   365,   366,   368,   369,
    1022      371,   373,   375,   383,   384,   390,   391,   392,   397,   399,
    1023      404,   405,   409,   413,   415,   417,   419,   424,   427,   429,
    1024      431,   436,   439,   441,   443,   445,   447,   449,   451,   453,
    1025      455,   457,   459,   466,   467,   469,   473,   474,   475,   476,
    1026      480,   481,   483,   488,   489,   491,   493,   498,   499,   501,
    1027      506,   507,   509,   514,   515,   517,   519,   521,   526,   527,
    1028      529,   534,   535,   540,   541,   546,   547,   552,   553,   558,
    1029      559,   564,   565,   568,   570,   575,   580,   581,   583,   585,
    1030      591,   592,   598,   600,   602,   604,   609,   610,   615,   616,
    1031      617,   618,   619,   620,   621,   622,   623,   624,   628,   629,
    1032      636,   637,   643,   644,   645,   646,   647,   648,   649,   650,
    1033      651,   661,   668,   670,   680,   681,   686,   688,   694,   696,
    1034      700,   701,   706,   711,   714,   716,   718,   728,   730,   741,
    1035      742,   744,   748,   750,   754,   755,   760,   761,   765,   770,
    1036      771,   775,   777,   783,   784,   788,   790,   792,   794,   800,
    1037      801,   805,   807,   812,   814,   816,   821,   823,   828,   830,
    1038      834,   837,   841,   844,   848,   850,   854,   856,   863,   865,
    1039      867,   876,   878,   880,   882,   884,   889,   891,   893,   895,
    1040      900,   913,   914,   919,   921,   926,   930,   932,   934,   936,
    1041      938,   944,   945,   951,   952,   956,   957,   962,   964,   970,
    1042      971,   973,   978,   980,   987,   989,   993,   994,   999,  1001,
    1043     1005,  1006,  1010,  1012,  1016,  1017,  1021,  1022,  1026,  1027,
    1044     1042,  1043,  1044,  1045,  1046,  1050,  1055,  1062,  1072,  1077,
    1045     1082,  1090,  1095,  1100,  1105,  1110,  1118,  1140,  1145,  1152,
    1046     1154,  1161,  1166,  1171,  1182,  1187,  1192,  1197,  1202,  1211,
    1047     1216,  1224,  1225,  1226,  1227,  1233,  1238,  1246,  1247,  1248,
    1048     1249,  1253,  1254,  1255,  1256,  1261,  1262,  1271,  1272,  1277,
    1049     1278,  1283,  1285,  1287,  1289,  1291,  1294,  1293,  1305,  1306,
    1050     1308,  1318,  1319,  1324,  1328,  1330,  1332,  1334,  1336,  1338,
    1051     1340,  1342,  1347,  1349,  1351,  1353,  1355,  1357,  1359,  1361,
    1052     1363,  1365,  1367,  1369,  1371,  1377,  1378,  1380,  1382,  1384,
    1053     1389,  1390,  1396,  1397,  1399,  1401,  1406,  1408,  1410,  1412,
    1054     1417,  1418,  1420,  1422,  1427,  1428,  1430,  1435,  1436,  1438,
    1055     1440,  1445,  1447,  1449,  1454,  1455,  1459,  1461,  1467,  1466,
    1056     1470,  1472,  1477,  1479,  1485,  1486,  1491,  1492,  1494,  1495,
    1057     1504,  1505,  1507,  1509,  1514,  1516,  1522,  1523,  1525,  1528,
    1058     1531,  1536,  1537,  1542,  1547,  1551,  1553,  1559,  1558,  1565,
    1059     1567,  1573,  1574,  1582,  1583,  1587,  1588,  1589,  1591,  1593,
    1060     1600,  1601,  1603,  1605,  1610,  1611,  1617,  1618,  1622,  1623,
    1061     1628,  1629,  1630,  1632,  1640,  1641,  1643,  1646,  1648,  1652,
    1062     1653,  1654,  1656,  1658,  1662,  1667,  1675,  1676,  1685,  1687,
    1063     1692,  1693,  1694,  1698,  1699,  1700,  1704,  1705,  1706,  1710,
    1064     1711,  1712,  1717,  1718,  1719,  1720,  1726,  1727,  1729,  1734,
    1065     1735,  1740,  1741,  1742,  1743,  1744,  1759,  1760,  1765,  1766,
    1066     1774,  1776,  1778,  1781,  1783,  1785,  1808,  1809,  1811,  1813,
    1067     1818,  1819,  1821,  1826,  1831,  1832,  1838,  1837,  1841,  1845,
    1068     1847,  1849,  1855,  1856,  1861,  1866,  1868,  1873,  1875,  1876,
    1069     1878,  1883,  1885,  1887,  1892,  1894,  1899,  1904,  1912,  1918,
    1070     1917,  1931,  1932,  1937,  1938,  1942,  1947,  1952,  1960,  1965,
    1071     1976,  1977,  1988,  1989,  1995,  1996,  2000,  2001,  2002,  2005,
    1072     2004,  2015,  2024,  2030,  2036,  2045,  2051,  2057,  2063,  2069,
    1073     2077,  2083,  2091,  2097,  2106,  2107,  2108,  2112,  2116,  2118,
    1074     2123,  2124,  2128,  2129,  2134,  2140,  2141,  2144,  2146,  2147,
    1075     2151,  2152,  2153,  2154,  2188,  2190,  2191,  2193,  2198,  2203,
    1076     2208,  2210,  2212,  2217,  2219,  2221,  2223,  2228,  2230,  2239,
    1077     2241,  2242,  2247,  2249,  2251,  2256,  2258,  2260,  2265,  2267,
    1078     2269,  2278,  2279,  2280,  2284,  2286,  2288,  2293,  2295,  2297,
    1079     2302,  2304,  2306,  2321,  2323,  2324,  2326,  2331,  2332,  2337,
    1080     2339,  2341,  2346,  2348,  2350,  2352,  2357,  2359,  2361,  2371,
    1081     2373,  2374,  2376,  2381,  2383,  2385,  2390,  2392,  2394,  2396,
    1082     2401,  2403,  2405,  2436,  2438,  2439,  2441,  2446,  2451,  2459,
    1083     2461,  2463,  2468,  2470,  2475,  2477,  2491,  2492,  2494,  2499,
    1084     2501,  2503,  2505,  2507,  2512,  2513,  2515,  2517,  2522,  2524,
    1085     2526,  2532,  2534,  2536,  2540,  2542,  2544,  2546,  2560,  2561,
    1086     2563,  2568,  2570,  2572,  2574,  2576,  2581,  2582,  2584,  2586,
    1087     2591,  2593,  2595,  2601,  2602,  2604,  2613,  2616,  2618,  2621,
    1088     2623,  2625,  2638,  2639,  2641,  2646,  2648,  2650,  2652,  2654,
    1089     2659,  2660,  2662,  2664,  2669,  2671,  2679,  2680,  2681,  2686,
    1090     2687,  2691,  2693,  2695,  2697,  2699,  2701,  2708,  2710,  2712,
    1091     2714,  2716,  2718,  2720,  2722,  2724,  2726,  2731,  2733,  2735,
    1092     2740,  2766,  2767,  2769,  2773,  2774,  2778,  2780,  2782,  2784,
    1093     2786,  2788,  2795,  2797,  2799,  2801,  2803,  2805,  2810,  2815,
    1094     2817,  2819,  2837,  2839,  2844,  2845
     1018       0,   290,   290,   296,   305,   306,   307,   311,   312,   313,
     1019     317,   318,   322,   323,   327,   328,   332,   333,   339,   341,
     1020     343,   345,   350,   351,   357,   361,   363,   364,   366,   367,
     1021     369,   371,   373,   381,   382,   388,   389,   390,   395,   397,
     1022     402,   403,   407,   411,   413,   415,   417,   422,   425,   427,
     1023     429,   431,   436,   438,   440,   442,   444,   446,   448,   450,
     1024     452,   454,   456,   463,   464,   466,   470,   471,   472,   473,
     1025     477,   478,   480,   485,   486,   488,   490,   495,   496,   498,
     1026     503,   504,   506,   511,   512,   514,   516,   518,   523,   524,
     1027     526,   531,   532,   537,   538,   543,   544,   549,   550,   555,
     1028     556,   561,   562,   564,   566,   571,   576,   577,   579,   581,
     1029     587,   588,   594,   596,   598,   600,   605,   606,   611,   612,
     1030     613,   614,   615,   616,   617,   618,   619,   620,   624,   625,
     1031     631,   632,   638,   639,   640,   641,   642,   643,   644,   645,
     1032     646,   656,   663,   665,   675,   676,   681,   683,   689,   691,
     1033     695,   696,   701,   706,   709,   711,   713,   723,   725,   736,
     1034     737,   739,   743,   744,   748,   749,   754,   755,   759,   764,
     1035     765,   769,   771,   777,   778,   782,   784,   786,   788,   794,
     1036     795,   799,   801,   806,   808,   810,   815,   817,   822,   824,
     1037     828,   831,   835,   838,   842,   844,   848,   850,   857,   859,
     1038     861,   870,   872,   874,   876,   878,   883,   885,   887,   889,
     1039     894,   907,   908,   913,   915,   920,   924,   926,   928,   930,
     1040     932,   938,   939,   945,   946,   950,   951,   956,   958,   964,
     1041     965,   967,   972,   974,   981,   983,   987,   988,   993,   995,
     1042     999,  1000,  1004,  1006,  1010,  1011,  1015,  1016,  1020,  1021,
     1043    1036,  1037,  1038,  1039,  1040,  1044,  1049,  1056,  1066,  1071,
     1044    1076,  1084,  1089,  1094,  1099,  1104,  1112,  1134,  1139,  1146,
     1045    1148,  1155,  1160,  1165,  1176,  1181,  1186,  1191,  1196,  1205,
     1046    1210,  1218,  1219,  1220,  1221,  1227,  1232,  1240,  1241,  1242,
     1047    1243,  1247,  1248,  1249,  1250,  1255,  1256,  1265,  1266,  1271,
     1048    1272,  1277,  1279,  1281,  1283,  1285,  1288,  1287,  1299,  1300,
     1049    1302,  1312,  1313,  1318,  1322,  1324,  1326,  1328,  1330,  1332,
     1050    1334,  1336,  1341,  1343,  1345,  1347,  1349,  1351,  1353,  1355,
     1051    1357,  1359,  1361,  1363,  1365,  1371,  1372,  1374,  1376,  1378,
     1052    1383,  1384,  1390,  1391,  1393,  1395,  1400,  1402,  1404,  1406,
     1053    1411,  1412,  1414,  1416,  1421,  1422,  1424,  1429,  1430,  1432,
     1054    1434,  1439,  1441,  1443,  1448,  1449,  1453,  1455,  1461,  1460,
     1055    1464,  1466,  1471,  1473,  1479,  1480,  1485,  1486,  1488,  1489,
     1056    1498,  1499,  1501,  1503,  1508,  1510,  1516,  1517,  1519,  1522,
     1057    1525,  1530,  1531,  1536,  1541,  1545,  1547,  1553,  1552,  1559,
     1058    1561,  1567,  1568,  1576,  1577,  1581,  1582,  1583,  1585,  1587,
     1059    1594,  1595,  1597,  1599,  1604,  1605,  1611,  1612,  1616,  1617,
     1060    1622,  1623,  1624,  1626,  1634,  1635,  1637,  1640,  1642,  1646,
     1061    1647,  1648,  1650,  1652,  1656,  1661,  1669,  1670,  1679,  1681,
     1062    1686,  1687,  1688,  1692,  1693,  1694,  1698,  1699,  1700,  1704,
     1063    1705,  1706,  1711,  1712,  1713,  1714,  1720,  1721,  1723,  1728,
     1064    1729,  1734,  1735,  1736,  1737,  1738,  1753,  1754,  1759,  1760,
     1065    1768,  1770,  1772,  1775,  1777,  1779,  1802,  1803,  1805,  1807,
     1066    1812,  1813,  1815,  1820,  1825,  1826,  1832,  1831,  1835,  1839,
     1067    1841,  1843,  1849,  1850,  1855,  1860,  1862,  1867,  1869,  1870,
     1068    1872,  1877,  1879,  1881,  1886,  1888,  1893,  1898,  1906,  1912,
     1069    1911,  1925,  1926,  1931,  1932,  1936,  1941,  1946,  1954,  1959,
     1070    1970,  1971,  1982,  1983,  1989,  1990,  1994,  1995,  1996,  1999,
     1071    1998,  2009,  2018,  2024,  2030,  2039,  2045,  2051,  2057,  2063,
     1072    2071,  2077,  2085,  2091,  2100,  2101,  2102,  2106,  2110,  2112,
     1073    2117,  2118,  2122,  2123,  2128,  2134,  2135,  2138,  2140,  2141,
     1074    2145,  2146,  2147,  2148,  2182,  2184,  2185,  2187,  2192,  2197,
     1075    2202,  2204,  2206,  2211,  2213,  2215,  2217,  2222,  2224,  2233,
     1076    2235,  2236,  2241,  2243,  2245,  2250,  2252,  2254,  2259,  2261,
     1077    2263,  2272,  2273,  2274,  2278,  2280,  2282,  2287,  2289,  2291,
     1078    2296,  2298,  2300,  2315,  2317,  2318,  2320,  2325,  2326,  2331,
     1079    2333,  2335,  2340,  2342,  2344,  2346,  2351,  2353,  2355,  2365,
     1080    2367,  2368,  2370,  2375,  2377,  2379,  2384,  2386,  2388,  2390,
     1081    2395,  2397,  2399,  2430,  2432,  2433,  2435,  2440,  2445,  2453,
     1082    2455,  2457,  2462,  2464,  2469,  2471,  2485,  2486,  2488,  2493,
     1083    2495,  2497,  2499,  2501,  2506,  2507,  2509,  2511,  2516,  2518,
     1084    2520,  2526,  2528,  2530,  2534,  2536,  2538,  2540,  2554,  2555,
     1085    2557,  2562,  2564,  2566,  2568,  2570,  2575,  2576,  2578,  2580,
     1086    2585,  2587,  2589,  2595,  2596,  2598,  2607,  2610,  2612,  2615,
     1087    2617,  2619,  2632,  2633,  2635,  2640,  2642,  2644,  2646,  2648,
     1088    2653,  2654,  2656,  2658,  2663,  2665,  2673,  2674,  2675,  2680,
     1089    2681,  2685,  2687,  2689,  2691,  2693,  2695,  2702,  2704,  2706,
     1090    2708,  2710,  2712,  2714,  2716,  2718,  2720,  2725,  2727,  2729,
     1091    2734,  2760,  2761,  2763,  2767,  2768,  2772,  2774,  2776,  2778,
     1092    2780,  2782,  2789,  2791,  2793,  2795,  2797,  2799,  2804,  2809,
     1093    2811,  2813,  2831,  2833,  2838,  2839
    10951094};
    10961095#endif
     
    52175216
    52185217/* Line 1806 of yacc.c  */
    5219 #line 292 "parser.yy"
     5218#line 290 "parser.yy"
    52205219    {
    52215220                        typedefTable.enterScope();
     
    52265225
    52275226/* Line 1806 of yacc.c  */
    5228 #line 298 "parser.yy"
     5227#line 296 "parser.yy"
    52295228    {
    52305229                        typedefTable.leaveScope();
     
    52355234
    52365235/* Line 1806 of yacc.c  */
     5236#line 305 "parser.yy"
     5237    { (yyval.constant) = makeConstantInteger( *(yyvsp[(1) - (1)].tok) ); }
     5238    break;
     5239
     5240  case 5:
     5241
     5242/* Line 1806 of yacc.c  */
     5243#line 306 "parser.yy"
     5244    { (yyval.constant) = makeConstantFloat( *(yyvsp[(1) - (1)].tok) ); }
     5245    break;
     5246
     5247  case 6:
     5248
     5249/* Line 1806 of yacc.c  */
    52375250#line 307 "parser.yy"
    5238     { (yyval.constant) = makeConstantInteger( *(yyvsp[(1) - (1)].tok) ); }
    5239     break;
    5240 
    5241   case 5:
    5242 
    5243 /* Line 1806 of yacc.c  */
    5244 #line 308 "parser.yy"
    5245     { (yyval.constant) = makeConstantFloat( *(yyvsp[(1) - (1)].tok) ); }
    5246     break;
    5247 
    5248   case 6:
    5249 
    5250 /* Line 1806 of yacc.c  */
    5251 #line 309 "parser.yy"
    52525251    { (yyval.constant) = makeConstantChar( *(yyvsp[(1) - (1)].tok) ); }
    52535252    break;
     
    52565255
    52575256/* Line 1806 of yacc.c  */
    5258 #line 334 "parser.yy"
     5257#line 332 "parser.yy"
    52595258    { (yyval.constant) = makeConstantStr( *(yyvsp[(1) - (1)].tok) ); }
    52605259    break;
     
    52635262
    52645263/* Line 1806 of yacc.c  */
    5265 #line 335 "parser.yy"
     5264#line 333 "parser.yy"
    52665265    { (yyval.constant) = (yyvsp[(1) - (2)].constant)->appendstr( (yyvsp[(2) - (2)].tok) ); }
    52675266    break;
    52685267
    52695268  case 18:
     5269
     5270/* Line 1806 of yacc.c  */
     5271#line 340 "parser.yy"
     5272    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
     5273    break;
     5274
     5275  case 19:
    52705276
    52715277/* Line 1806 of yacc.c  */
     
    52745280    break;
    52755281
    5276   case 19:
     5282  case 20:
    52775283
    52785284/* Line 1806 of yacc.c  */
    52795285#line 344 "parser.yy"
    5280     { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    5281     break;
    5282 
    5283   case 20:
     5286    { (yyval.en) = (yyvsp[(2) - (3)].en); }
     5287    break;
     5288
     5289  case 21:
    52845290
    52855291/* Line 1806 of yacc.c  */
    52865292#line 346 "parser.yy"
    5287     { (yyval.en) = (yyvsp[(2) - (3)].en); }
    5288     break;
    5289 
    5290   case 21:
    5291 
    5292 /* Line 1806 of yacc.c  */
    5293 #line 348 "parser.yy"
    52945293    { (yyval.en) = new ValofExprNode( (yyvsp[(2) - (3)].sn) ); }
    52955294    break;
     
    52985297
    52995298/* Line 1806 of yacc.c  */
     5299#line 356 "parser.yy"
     5300    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Index ), (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ); }
     5301    break;
     5302
     5303  case 24:
     5304
     5305/* Line 1806 of yacc.c  */
    53005306#line 358 "parser.yy"
    5301     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
    5302     break;
    5303 
    5304   case 24:
    5305 
    5306 /* Line 1806 of yacc.c  */
    5307 #line 360 "parser.yy"
    53085307    { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ); }
    53095308    break;
     
    53125311
    53135312/* Line 1806 of yacc.c  */
    5314 #line 364 "parser.yy"
    5315     { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
     5313#line 362 "parser.yy"
     5314    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) )); }
    53165315    break;
    53175316
     
    53195318
    53205319/* Line 1806 of yacc.c  */
    5321 #line 367 "parser.yy"
    5322     { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
     5320#line 365 "parser.yy"
     5321    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) )); }
    53235322    break;
    53245323
     
    53265325
    53275326/* Line 1806 of yacc.c  */
     5327#line 368 "parser.yy"
     5328    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::IncrPost ), (yyvsp[(1) - (2)].en) ); }
     5329    break;
     5330
     5331  case 30:
     5332
     5333/* Line 1806 of yacc.c  */
    53285334#line 370 "parser.yy"
    5329     { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
    5330     break;
    5331 
    5332   case 30:
     5335    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), (yyvsp[(1) - (2)].en) ); }
     5336    break;
     5337
     5338  case 31:
    53335339
    53345340/* Line 1806 of yacc.c  */
    53355341#line 372 "parser.yy"
    5336     { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
    5337     break;
    5338 
    5339   case 31:
     5342    { (yyval.en) = new CompoundLiteralNode( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ); }
     5343    break;
     5344
     5345  case 32:
    53405346
    53415347/* Line 1806 of yacc.c  */
    53425348#line 374 "parser.yy"
    5343     { (yyval.en) = new CompoundLiteralNode( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ); }
    5344     break;
    5345 
    5346   case 32:
    5347 
    5348 /* Line 1806 of yacc.c  */
    5349 #line 376 "parser.yy"
    53505349    {
    53515350                        Token fn; fn.str = new std::string( "?{}" ); // location undefined
     
    53575356
    53585357/* Line 1806 of yacc.c  */
    5359 #line 385 "parser.yy"
     5358#line 383 "parser.yy"
    53605359    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    53615360    break;
     
    53645363
    53655364/* Line 1806 of yacc.c  */
    5366 #line 390 "parser.yy"
     5365#line 388 "parser.yy"
    53675366    { (yyval.en) = 0; }
    53685367    break;
     
    53715370
    53725371/* Line 1806 of yacc.c  */
    5373 #line 393 "parser.yy"
     5372#line 391 "parser.yy"
    53745373    { (yyval.en) = (yyvsp[(3) - (3)].en)->set_argName( (yyvsp[(1) - (3)].tok) ); }
    53755374    break;
     
    53785377
    53795378/* Line 1806 of yacc.c  */
     5379#line 396 "parser.yy"
     5380    { (yyval.en) = (yyvsp[(7) - (7)].en)->set_argName( (yyvsp[(3) - (7)].en) ); }
     5381    break;
     5382
     5383  case 39:
     5384
     5385/* Line 1806 of yacc.c  */
    53805386#line 398 "parser.yy"
    5381     { (yyval.en) = (yyvsp[(7) - (7)].en)->set_argName( (yyvsp[(3) - (7)].en) ); }
    5382     break;
    5383 
    5384   case 39:
    5385 
    5386 /* Line 1806 of yacc.c  */
    5387 #line 400 "parser.yy"
    53885387    { (yyval.en) = (yyvsp[(9) - (9)].en)->set_argName( new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (9)].en)->set_link( flattenCommas( (yyvsp[(5) - (9)].en) )))); }
    53895388    break;
     
    53925391
    53935392/* Line 1806 of yacc.c  */
    5394 #line 405 "parser.yy"
     5393#line 403 "parser.yy"
    53955394    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    53965395    break;
     
    53995398
    54005399/* Line 1806 of yacc.c  */
    5401 #line 410 "parser.yy"
     5400#line 408 "parser.yy"
    54025401    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    54035402    break;
     
    54065405
    54075406/* Line 1806 of yacc.c  */
     5407#line 412 "parser.yy"
     5408    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( (yyvsp[(1) - (3)].tok) ), (yyvsp[(3) - (3)].en) ); }
     5409    break;
     5410
     5411  case 44:
     5412
     5413/* Line 1806 of yacc.c  */
    54085414#line 414 "parser.yy"
    5409     { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
    5410     break;
    5411 
    5412   case 44:
     5415    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( (yyvsp[(1) - (7)].tok) ), (yyvsp[(5) - (7)].en) ); }
     5416    break;
     5417
     5418  case 45:
    54135419
    54145420/* Line 1806 of yacc.c  */
    54155421#line 416 "parser.yy"
    5416     { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
    5417     break;
    5418 
    5419   case 45:
     5422    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( (yyvsp[(1) - (3)].tok) ), (yyvsp[(3) - (3)].en) ); }
     5423    break;
     5424
     5425  case 46:
    54205426
    54215427/* Line 1806 of yacc.c  */
    54225428#line 418 "parser.yy"
    5423     { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
    5424     break;
    5425 
    5426   case 46:
    5427 
    5428 /* Line 1806 of yacc.c  */
    5429 #line 420 "parser.yy"
    5430     { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
     5429    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( (yyvsp[(1) - (7)].tok) ), (yyvsp[(5) - (7)].en) ); }
    54315430    break;
    54325431
    54335432  case 48:
     5433
     5434/* Line 1806 of yacc.c  */
     5435#line 426 "parser.yy"
     5436    { (yyval.en) = (yyvsp[(1) - (1)].constant); }
     5437    break;
     5438
     5439  case 49:
    54345440
    54355441/* Line 1806 of yacc.c  */
     
    54385444    break;
    54395445
    5440   case 49:
     5446  case 50:
    54415447
    54425448/* Line 1806 of yacc.c  */
    54435449#line 430 "parser.yy"
    5444     { (yyval.en) = (yyvsp[(1) - (1)].constant); }
    5445     break;
    5446 
    5447   case 50:
     5450    { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
     5451    break;
     5452
     5453  case 51:
    54485454
    54495455/* Line 1806 of yacc.c  */
    54505456#line 432 "parser.yy"
    5451     { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
    5452     break;
    5453 
    5454   case 51:
     5457    { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); }
     5458    break;
     5459
     5460  case 52:
    54555461
    54565462/* Line 1806 of yacc.c  */
    54575463#line 437 "parser.yy"
    5458     { (yyval.en) = (yyvsp[(1) - (2)].op) == OperatorNode::AddressOf ? (ExpressionNode*) new CompositeExprNode2( build_addressOf( (yyvsp[(2) - (2)].en) ) )
    5459                                                                                         : (ExpressionNode*)new CompositeExprNode( new OperatorNode ( (yyvsp[(1) - (2)].op) ), (yyvsp[(2) - (2)].en) ); }
    5460     break;
    5461 
    5462   case 52:
    5463 
    5464 /* Line 1806 of yacc.c  */
    5465 #line 440 "parser.yy"
    54665464    { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); }
    54675465    break;
     
    54705468
    54715469/* Line 1806 of yacc.c  */
    5472 #line 442 "parser.yy"
    5473     { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::Incr, (yyvsp[(2) - (2)].en) ) ); }
     5470#line 439 "parser.yy"
     5471    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Incr ), (yyvsp[(2) - (2)].en) ); }
    54745472    break;
    54755473
     
    54775475
    54785476/* Line 1806 of yacc.c  */
    5479 #line 444 "parser.yy"
    5480     { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::Decr, (yyvsp[(2) - (2)].en) ) ); }
     5477#line 441 "parser.yy"
     5478    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Decr ), (yyvsp[(2) - (2)].en) ); }
    54815479    break;
    54825480
     
    54845482
    54855483/* Line 1806 of yacc.c  */
    5486 #line 446 "parser.yy"
    5487     { (yyval.en) = new CompositeExprNode2( build_sizeOf( (yyvsp[(2) - (2)].en) ) ); }
     5484#line 443 "parser.yy"
     5485    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), (yyvsp[(2) - (2)].en) ); }
    54885486    break;
    54895487
     
    54915489
    54925490/* Line 1806 of yacc.c  */
    5493 #line 448 "parser.yy"
    5494     { (yyval.en) = new CompositeExprNode2( build_sizeOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
     5491#line 445 "parser.yy"
     5492    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), new TypeValueNode( (yyvsp[(3) - (4)].decl) )); }
    54955493    break;
    54965494
     
    54985496
    54995497/* Line 1806 of yacc.c  */
    5500 #line 450 "parser.yy"
    5501     { (yyval.en) = new CompositeExprNode2( build_offsetOf( new TypeValueNode( (yyvsp[(3) - (6)].decl) ), new VarRefNode( (yyvsp[(5) - (6)].tok) ) ) ); }
     5498#line 447 "parser.yy"
     5499    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::OffsetOf ), new TypeValueNode( (yyvsp[(3) - (6)].decl) ), new VarRefNode( (yyvsp[(5) - (6)].tok) )); }
    55025500    break;
    55035501
     
    55055503
    55065504/* Line 1806 of yacc.c  */
    5507 #line 452 "parser.yy"
    5508     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); }
     5505#line 449 "parser.yy"
     5506    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (1)].tok) )); }
    55095507    break;
    55105508
     
    55125510
    55135511/* Line 1806 of yacc.c  */
    5514 #line 454 "parser.yy"
    5515     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ); }
     5512#line 451 "parser.yy"
     5513    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), new TypeValueNode( (yyvsp[(3) - (4)].decl) )); }
    55165514    break;
    55175515
     
    55195517
    55205518/* Line 1806 of yacc.c  */
    5521 #line 456 "parser.yy"
     5519#line 453 "parser.yy"
    55225520    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ); }
    55235521    break;
     
    55265524
    55275525/* Line 1806 of yacc.c  */
    5528 #line 458 "parser.yy"
    5529     { (yyval.en) = new CompositeExprNode2( build_alignOf( (yyvsp[(2) - (2)].en) ) ); }
     5526#line 455 "parser.yy"
     5527    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), (yyvsp[(2) - (2)].en) ); }
    55305528    break;
    55315529
     
    55335531
    55345532/* Line 1806 of yacc.c  */
    5535 #line 460 "parser.yy"
    5536     { (yyval.en) = new CompositeExprNode2( build_alignOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
     5533#line 457 "parser.yy"
     5534    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ); }
    55375535    break;
    55385536
     
    55405538
    55415539/* Line 1806 of yacc.c  */
     5540#line 463 "parser.yy"
     5541    { (yyval.en) = new OperatorNode( OperatorNode::PointTo ); }
     5542    break;
     5543
     5544  case 64:
     5545
     5546/* Line 1806 of yacc.c  */
     5547#line 464 "parser.yy"
     5548    { (yyval.en) = new OperatorNode( OperatorNode::AddressOf ); }
     5549    break;
     5550
     5551  case 65:
     5552
     5553/* Line 1806 of yacc.c  */
    55425554#line 466 "parser.yy"
    5543     { (yyval.op) = OperatorNode::PointTo; }
    5544     break;
    5545 
    5546   case 64:
    5547 
    5548 /* Line 1806 of yacc.c  */
    5549 #line 467 "parser.yy"
    5550     { (yyval.op) = OperatorNode::AddressOf; }
    5551     break;
    5552 
    5553   case 65:
    5554 
    5555 /* Line 1806 of yacc.c  */
    5556 #line 469 "parser.yy"
    5557     { (yyval.op) = OperatorNode::And; }
     5555    { (yyval.en) = new OperatorNode( OperatorNode::And ); }
    55585556    break;
    55595557
     
    55615559
    55625560/* Line 1806 of yacc.c  */
     5561#line 470 "parser.yy"
     5562    { (yyval.en) = new OperatorNode( OperatorNode::UnPlus ); }
     5563    break;
     5564
     5565  case 67:
     5566
     5567/* Line 1806 of yacc.c  */
     5568#line 471 "parser.yy"
     5569    { (yyval.en) = new OperatorNode( OperatorNode::UnMinus ); }
     5570    break;
     5571
     5572  case 68:
     5573
     5574/* Line 1806 of yacc.c  */
     5575#line 472 "parser.yy"
     5576    { (yyval.en) = new OperatorNode( OperatorNode::Neg ); }
     5577    break;
     5578
     5579  case 69:
     5580
     5581/* Line 1806 of yacc.c  */
    55635582#line 473 "parser.yy"
    5564     { (yyval.en) = new OperatorNode( OperatorNode::UnPlus ); }
    5565     break;
    5566 
    5567   case 67:
    5568 
    5569 /* Line 1806 of yacc.c  */
    5570 #line 474 "parser.yy"
    5571     { (yyval.en) = new OperatorNode( OperatorNode::UnMinus ); }
    5572     break;
    5573 
    5574   case 68:
    5575 
    5576 /* Line 1806 of yacc.c  */
    5577 #line 475 "parser.yy"
    5578     { (yyval.en) = new OperatorNode( OperatorNode::Neg ); }
    5579     break;
    5580 
    5581   case 69:
    5582 
    5583 /* Line 1806 of yacc.c  */
    5584 #line 476 "parser.yy"
    55855583    { (yyval.en) = new OperatorNode( OperatorNode::BitNeg ); }
    55865584    break;
     
    55895587
    55905588/* Line 1806 of yacc.c  */
    5591 #line 482 "parser.yy"
    5592     { (yyval.en) = new CompositeExprNode2( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
     5589#line 479 "parser.yy"
     5590    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ); }
    55935591    break;
    55945592
     
    55965594
    55975595/* Line 1806 of yacc.c  */
    5598 #line 484 "parser.yy"
    5599     { (yyval.en) = new CompositeExprNode2( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
     5596#line 481 "parser.yy"
     5597    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ); }
    56005598    break;
    56015599
     
    56035601
    56045602/* Line 1806 of yacc.c  */
    5605 #line 490 "parser.yy"
    5606     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5603#line 487 "parser.yy"
     5604    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Mul ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56075605    break;
    56085606
     
    56105608
    56115609/* Line 1806 of yacc.c  */
    5612 #line 492 "parser.yy"
    5613     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5610#line 489 "parser.yy"
     5611    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Div ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56145612    break;
    56155613
     
    56175615
    56185616/* Line 1806 of yacc.c  */
    5619 #line 494 "parser.yy"
    5620     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5617#line 491 "parser.yy"
     5618    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Mod ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56215619    break;
    56225620
     
    56245622
    56255623/* Line 1806 of yacc.c  */
    5626 #line 500 "parser.yy"
    5627     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5624#line 497 "parser.yy"
     5625    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Plus ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56285626    break;
    56295627
     
    56315629
    56325630/* Line 1806 of yacc.c  */
    5633 #line 502 "parser.yy"
    5634     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5631#line 499 "parser.yy"
     5632    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Minus ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56355633    break;
    56365634
     
    56385636
    56395637/* Line 1806 of yacc.c  */
    5640 #line 508 "parser.yy"
    5641     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5638#line 505 "parser.yy"
     5639    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LShift ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56425640    break;
    56435641
     
    56455643
    56465644/* Line 1806 of yacc.c  */
    5647 #line 510 "parser.yy"
    5648     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5645#line 507 "parser.yy"
     5646    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::RShift ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56495647    break;
    56505648
     
    56525650
    56535651/* Line 1806 of yacc.c  */
    5654 #line 516 "parser.yy"
    5655     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5652#line 513 "parser.yy"
     5653    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56565654    break;
    56575655
     
    56595657
    56605658/* Line 1806 of yacc.c  */
    5661 #line 518 "parser.yy"
    5662     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5659#line 515 "parser.yy"
     5660    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::GThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56635661    break;
    56645662
     
    56665664
    56675665/* Line 1806 of yacc.c  */
    5668 #line 520 "parser.yy"
    5669     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5666#line 517 "parser.yy"
     5667    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LEThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56705668    break;
    56715669
     
    56735671
    56745672/* Line 1806 of yacc.c  */
    5675 #line 522 "parser.yy"
    5676     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5673#line 519 "parser.yy"
     5674    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::GEThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56775675    break;
    56785676
     
    56805678
    56815679/* Line 1806 of yacc.c  */
    5682 #line 528 "parser.yy"
    5683     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5680#line 525 "parser.yy"
     5681    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Eq ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56845682    break;
    56855683
     
    56875685
    56885686/* Line 1806 of yacc.c  */
    5689 #line 530 "parser.yy"
    5690     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5687#line 527 "parser.yy"
     5688    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Neq ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56915689    break;
    56925690
     
    56945692
    56955693/* Line 1806 of yacc.c  */
    5696 #line 536 "parser.yy"
    5697     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5694#line 533 "parser.yy"
     5695    { (yyval.en) =new CompositeExprNode( new OperatorNode( OperatorNode::BitAnd ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    56985696    break;
    56995697
     
    57015699
    57025700/* Line 1806 of yacc.c  */
    5703 #line 542 "parser.yy"
    5704     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5701#line 539 "parser.yy"
     5702    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Xor ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    57055703    break;
    57065704
     
    57085706
    57095707/* Line 1806 of yacc.c  */
    5710 #line 548 "parser.yy"
    5711     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5708#line 545 "parser.yy"
     5709    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::BitOr ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    57125710    break;
    57135711
     
    57155713
    57165714/* Line 1806 of yacc.c  */
    5717 #line 554 "parser.yy"
    5718     { (yyval.en) = new CompositeExprNode2( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
     5715#line 551 "parser.yy"
     5716    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::And ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    57195717    break;
    57205718
     
    57225720
    57235721/* Line 1806 of yacc.c  */
    5724 #line 560 "parser.yy"
    5725     { (yyval.en) = new CompositeExprNode2( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
     5722#line 557 "parser.yy"
     5723    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Or ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    57265724    break;
    57275725
     
    57295727
    57305728/* Line 1806 of yacc.c  */
     5729#line 563 "parser.yy"
     5730    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*(yyvsp[(1) - (5)].en), *(yyvsp[(3) - (5)].en), *(yyvsp[(5) - (5)].en) ) ) ); }
     5731    break;
     5732
     5733  case 103:
     5734
     5735/* Line 1806 of yacc.c  */
     5736#line 565 "parser.yy"
     5737    { (yyval.en)=new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ); }
     5738    break;
     5739
     5740  case 104:
     5741
     5742/* Line 1806 of yacc.c  */
    57315743#line 567 "parser.yy"
    5732     { (yyval.en) = new CompositeExprNode2( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    5733     break;
    5734 
    5735   case 103:
    5736 
    5737 /* Line 1806 of yacc.c  */
    5738 #line 569 "parser.yy"
    5739     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    5740     break;
    5741 
    5742   case 104:
    5743 
    5744 /* Line 1806 of yacc.c  */
    5745 #line 571 "parser.yy"
    5746     { (yyval.en) = new CompositeExprNode2( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     5744    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*(yyvsp[(1) - (5)].en), *(yyvsp[(3) - (5)].en), *(yyvsp[(5) - (5)].en) ) ) ); }
    57475745    break;
    57485746
     
    57505748
    57515749/* Line 1806 of yacc.c  */
     5750#line 578 "parser.yy"
     5751    { (yyval.en) =new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5752    break;
     5753
     5754  case 108:
     5755
     5756/* Line 1806 of yacc.c  */
     5757#line 580 "parser.yy"
     5758    { (yyval.en) =new CompositeExprNode( (yyvsp[(2) - (3)].en), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5759    break;
     5760
     5761  case 109:
     5762
     5763/* Line 1806 of yacc.c  */
    57525764#line 582 "parser.yy"
    5753     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    5754     break;
    5755 
    5756   case 108:
    5757 
    5758 /* Line 1806 of yacc.c  */
    5759 #line 584 "parser.yy"
    5760     { (yyval.en) = new CompositeExprNode( (yyvsp[(2) - (3)].en), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    5761     break;
    5762 
    5763   case 109:
    5764 
    5765 /* Line 1806 of yacc.c  */
    5766 #line 586 "parser.yy"
    57675765    { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); }
    57685766    break;
     
    57715769
    57725770/* Line 1806 of yacc.c  */
    5773 #line 591 "parser.yy"
     5771#line 587 "parser.yy"
    57745772    { (yyval.en) = new NullExprNode; }
    57755773    break;
     
    57785776
    57795777/* Line 1806 of yacc.c  */
     5778#line 595 "parser.yy"
     5779    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
     5780    break;
     5781
     5782  case 113:
     5783
     5784/* Line 1806 of yacc.c  */
     5785#line 597 "parser.yy"
     5786    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (yyvsp[(3) - (5)].en) ); }
     5787    break;
     5788
     5789  case 114:
     5790
     5791/* Line 1806 of yacc.c  */
    57805792#line 599 "parser.yy"
    5781     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
    5782     break;
    5783 
    5784   case 113:
     5793    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ); }
     5794    break;
     5795
     5796  case 115:
    57855797
    57865798/* Line 1806 of yacc.c  */
    57875799#line 601 "parser.yy"
    5788     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (yyvsp[(3) - (5)].en) ); }
    5789     break;
    5790 
    5791   case 114:
    5792 
    5793 /* Line 1806 of yacc.c  */
    5794 #line 603 "parser.yy"
    5795     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ); }
    5796     break;
    5797 
    5798   case 115:
    5799 
    5800 /* Line 1806 of yacc.c  */
    5801 #line 605 "parser.yy"
    58025800    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( flattenCommas( (yyvsp[(5) - (7)].en) ) ) ); }
    58035801    break;
     
    58065804
    58075805/* Line 1806 of yacc.c  */
     5806#line 607 "parser.yy"
     5807    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
     5808    break;
     5809
     5810  case 118:
     5811
     5812/* Line 1806 of yacc.c  */
    58085813#line 611 "parser.yy"
    5809     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    5810     break;
    5811 
    5812   case 118:
     5814    { (yyval.en) = new OperatorNode( OperatorNode::MulAssn ); }
     5815    break;
     5816
     5817  case 119:
     5818
     5819/* Line 1806 of yacc.c  */
     5820#line 612 "parser.yy"
     5821    { (yyval.en) = new OperatorNode( OperatorNode::DivAssn ); }
     5822    break;
     5823
     5824  case 120:
     5825
     5826/* Line 1806 of yacc.c  */
     5827#line 613 "parser.yy"
     5828    { (yyval.en) = new OperatorNode( OperatorNode::ModAssn ); }
     5829    break;
     5830
     5831  case 121:
     5832
     5833/* Line 1806 of yacc.c  */
     5834#line 614 "parser.yy"
     5835    { (yyval.en) = new OperatorNode( OperatorNode::PlusAssn ); }
     5836    break;
     5837
     5838  case 122:
    58135839
    58145840/* Line 1806 of yacc.c  */
    58155841#line 615 "parser.yy"
    5816     { (yyval.en) = new OperatorNode( OperatorNode::MulAssn ); }
    5817     break;
    5818 
    5819   case 119:
     5842    { (yyval.en) = new OperatorNode( OperatorNode::MinusAssn ); }
     5843    break;
     5844
     5845  case 123:
    58205846
    58215847/* Line 1806 of yacc.c  */
    58225848#line 616 "parser.yy"
    5823     { (yyval.en) = new OperatorNode( OperatorNode::DivAssn ); }
    5824     break;
    5825 
    5826   case 120:
     5849    { (yyval.en) = new OperatorNode( OperatorNode::LSAssn ); }
     5850    break;
     5851
     5852  case 124:
    58275853
    58285854/* Line 1806 of yacc.c  */
    58295855#line 617 "parser.yy"
    5830     { (yyval.en) = new OperatorNode( OperatorNode::ModAssn ); }
    5831     break;
    5832 
    5833   case 121:
     5856    { (yyval.en) = new OperatorNode( OperatorNode::RSAssn ); }
     5857    break;
     5858
     5859  case 125:
    58345860
    58355861/* Line 1806 of yacc.c  */
    58365862#line 618 "parser.yy"
    5837     { (yyval.en) = new OperatorNode( OperatorNode::PlusAssn ); }
    5838     break;
    5839 
    5840   case 122:
     5863    { (yyval.en) = new OperatorNode( OperatorNode::AndAssn ); }
     5864    break;
     5865
     5866  case 126:
    58415867
    58425868/* Line 1806 of yacc.c  */
    58435869#line 619 "parser.yy"
    5844     { (yyval.en) = new OperatorNode( OperatorNode::MinusAssn ); }
    5845     break;
    5846 
    5847   case 123:
     5870    { (yyval.en) = new OperatorNode( OperatorNode::ERAssn ); }
     5871    break;
     5872
     5873  case 127:
    58485874
    58495875/* Line 1806 of yacc.c  */
    58505876#line 620 "parser.yy"
    5851     { (yyval.en) = new OperatorNode( OperatorNode::LSAssn ); }
    5852     break;
    5853 
    5854   case 124:
    5855 
    5856 /* Line 1806 of yacc.c  */
    5857 #line 621 "parser.yy"
    5858     { (yyval.en) = new OperatorNode( OperatorNode::RSAssn ); }
    5859     break;
    5860 
    5861   case 125:
    5862 
    5863 /* Line 1806 of yacc.c  */
    5864 #line 622 "parser.yy"
    5865     { (yyval.en) = new OperatorNode( OperatorNode::AndAssn ); }
    5866     break;
    5867 
    5868   case 126:
    5869 
    5870 /* Line 1806 of yacc.c  */
    5871 #line 623 "parser.yy"
    5872     { (yyval.en) = new OperatorNode( OperatorNode::ERAssn ); }
    5873     break;
    5874 
    5875   case 127:
    5876 
    5877 /* Line 1806 of yacc.c  */
    5878 #line 624 "parser.yy"
    58795877    { (yyval.en) = new OperatorNode( OperatorNode::OrAssn ); }
    58805878    break;
     
    58835881
    58845882/* Line 1806 of yacc.c  */
     5883#line 626 "parser.yy"
     5884    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Comma ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5885    break;
     5886
     5887  case 130:
     5888
     5889/* Line 1806 of yacc.c  */
    58855890#line 631 "parser.yy"
    5886     { (yyval.en) = new CompositeExprNode2( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5887     break;
    5888 
    5889   case 130:
    5890 
    5891 /* Line 1806 of yacc.c  */
    5892 #line 636 "parser.yy"
    58935891    { (yyval.en) = 0; }
    58945892    break;
     
    58975895
    58985896/* Line 1806 of yacc.c  */
    5899 #line 645 "parser.yy"
     5897#line 640 "parser.yy"
    59005898    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    59015899    break;
     
    59045902
    59055903/* Line 1806 of yacc.c  */
    5906 #line 652 "parser.yy"
     5904#line 647 "parser.yy"
    59075905    {
    59085906                        Token fn; fn.str = new std::string( "^?{}" ); // location undefined
     
    59155913
    59165914/* Line 1806 of yacc.c  */
    5917 #line 662 "parser.yy"
     5915#line 657 "parser.yy"
    59185916    {
    59195917                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
     
    59245922
    59255923/* Line 1806 of yacc.c  */
    5926 #line 669 "parser.yy"
     5924#line 664 "parser.yy"
    59275925    { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
    59285926    break;
     
    59315929
    59325930/* Line 1806 of yacc.c  */
    5933 #line 676 "parser.yy"
     5931#line 671 "parser.yy"
    59345932    { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); }
    59355933    break;
     
    59385936
    59395937/* Line 1806 of yacc.c  */
     5938#line 677 "parser.yy"
     5939    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
     5940    break;
     5941
     5942  case 146:
     5943
     5944/* Line 1806 of yacc.c  */
    59405945#line 682 "parser.yy"
    5941     { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    5942     break;
    5943 
    5944   case 146:
    5945 
    5946 /* Line 1806 of yacc.c  */
    5947 #line 687 "parser.yy"
    59485946    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    59495947    break;
     
    59525950
    59535951/* Line 1806 of yacc.c  */
    5954 #line 689 "parser.yy"
     5952#line 684 "parser.yy"
    59555953    {   // mark all fields in list
    59565954                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    59635961
    59645962/* Line 1806 of yacc.c  */
    5965 #line 695 "parser.yy"
     5963#line 690 "parser.yy"
    59665964    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    59675965    break;
     
    59705968
    59715969/* Line 1806 of yacc.c  */
     5970#line 697 "parser.yy"
     5971    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
     5972    break;
     5973
     5974  case 152:
     5975
     5976/* Line 1806 of yacc.c  */
    59725977#line 702 "parser.yy"
    5973     { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    5974     break;
    5975 
    5976   case 152:
    5977 
    5978 /* Line 1806 of yacc.c  */
    5979 #line 707 "parser.yy"
    59805978    { (yyval.sn) = new StatementNode( StatementNode::Exp, (yyvsp[(1) - (2)].en), 0 ); }
    59815979    break;
     
    59845982
    59855983/* Line 1806 of yacc.c  */
    5986 #line 713 "parser.yy"
     5984#line 708 "parser.yy"
    59875985    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    59885986    break;
     
    59915989
    59925990/* Line 1806 of yacc.c  */
    5993 #line 715 "parser.yy"
     5991#line 710 "parser.yy"
    59945992    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn) )) ); }
    59955993    break;
     
    59985996
    59995997/* Line 1806 of yacc.c  */
    6000 #line 717 "parser.yy"
     5998#line 712 "parser.yy"
    60015999    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    60026000    break;
     
    60056003
    60066004/* Line 1806 of yacc.c  */
    6007 #line 719 "parser.yy"
     6005#line 714 "parser.yy"
    60086006    {
    60096007                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     
    60206018
    60216019/* Line 1806 of yacc.c  */
    6022 #line 729 "parser.yy"
     6020#line 724 "parser.yy"
    60236021    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    60246022    break;
     
    60276025
    60286026/* Line 1806 of yacc.c  */
    6029 #line 731 "parser.yy"
     6027#line 726 "parser.yy"
    60306028    {
    60316029                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     
    60376035
    60386036/* Line 1806 of yacc.c  */
    6039 #line 741 "parser.yy"
     6037#line 736 "parser.yy"
    60406038    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    60416039    break;
     
    60446042
    60456043/* Line 1806 of yacc.c  */
     6044#line 738 "parser.yy"
     6045    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     6046    break;
     6047
     6048  case 162:
     6049
     6050/* Line 1806 of yacc.c  */
    60466051#line 743 "parser.yy"
    6047     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Range, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    6048     break;
    6049 
    6050   case 162:
     6052    { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(1) - (1)].en), 0 ); }
     6053    break;
     6054
     6055  case 163:
     6056
     6057/* Line 1806 of yacc.c  */
     6058#line 744 "parser.yy"
     6059    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode( StatementNode::Case, (yyvsp[(3) - (3)].en), 0 ) ) ); }
     6060    break;
     6061
     6062  case 164:
    60516063
    60526064/* Line 1806 of yacc.c  */
    60536065#line 748 "parser.yy"
    6054     { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(1) - (1)].en), 0 ); }
    6055     break;
    6056 
    6057   case 163:
    6058 
    6059 /* Line 1806 of yacc.c  */
    6060 #line 750 "parser.yy"
    6061     { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode( StatementNode::Case, (yyvsp[(3) - (3)].en), 0 ) ) ); }
    6062     break;
    6063 
    6064   case 164:
    6065 
    6066 /* Line 1806 of yacc.c  */
    6067 #line 754 "parser.yy"
    60686066    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    60696067    break;
     
    60726070
    60736071/* Line 1806 of yacc.c  */
     6072#line 749 "parser.yy"
     6073    { (yyval.sn) = new StatementNode( StatementNode::Default ); }
     6074    break;
     6075
     6076  case 167:
     6077
     6078/* Line 1806 of yacc.c  */
    60746079#line 755 "parser.yy"
    6075     { (yyval.sn) = new StatementNode( StatementNode::Default ); }
    6076     break;
    6077 
    6078   case 167:
    6079 
    6080 /* Line 1806 of yacc.c  */
    6081 #line 761 "parser.yy"
    60826080    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
    60836081    break;
     
    60866084
    60876085/* Line 1806 of yacc.c  */
    6088 #line 765 "parser.yy"
     6086#line 759 "parser.yy"
    60896087    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    60906088    break;
     
    60936091
    60946092/* Line 1806 of yacc.c  */
     6093#line 764 "parser.yy"
     6094    { (yyval.sn) = 0; }
     6095    break;
     6096
     6097  case 171:
     6098
     6099/* Line 1806 of yacc.c  */
    60956100#line 770 "parser.yy"
     6101    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
     6102    break;
     6103
     6104  case 172:
     6105
     6106/* Line 1806 of yacc.c  */
     6107#line 772 "parser.yy"
     6108    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
     6109    break;
     6110
     6111  case 173:
     6112
     6113/* Line 1806 of yacc.c  */
     6114#line 777 "parser.yy"
    60966115    { (yyval.sn) = 0; }
    60976116    break;
    60986117
    6099   case 171:
    6100 
    6101 /* Line 1806 of yacc.c  */
    6102 #line 776 "parser.yy"
    6103     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    6104     break;
    6105 
    6106   case 172:
    6107 
    6108 /* Line 1806 of yacc.c  */
    6109 #line 778 "parser.yy"
    6110     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    6111     break;
    6112 
    6113   case 173:
     6118  case 175:
    61146119
    61156120/* Line 1806 of yacc.c  */
    61166121#line 783 "parser.yy"
     6122    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
     6123    break;
     6124
     6125  case 176:
     6126
     6127/* Line 1806 of yacc.c  */
     6128#line 785 "parser.yy"
     6129    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
     6130    break;
     6131
     6132  case 177:
     6133
     6134/* Line 1806 of yacc.c  */
     6135#line 787 "parser.yy"
     6136    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
     6137    break;
     6138
     6139  case 178:
     6140
     6141/* Line 1806 of yacc.c  */
     6142#line 789 "parser.yy"
     6143    { (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) ) ) ) ) ) ); }
     6144    break;
     6145
     6146  case 179:
     6147
     6148/* Line 1806 of yacc.c  */
     6149#line 794 "parser.yy"
     6150    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
     6151    break;
     6152
     6153  case 181:
     6154
     6155/* Line 1806 of yacc.c  */
     6156#line 800 "parser.yy"
    61176157    { (yyval.sn) = 0; }
    61186158    break;
    61196159
    6120   case 175:
    6121 
    6122 /* Line 1806 of yacc.c  */
    6123 #line 789 "parser.yy"
    6124     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    6125     break;
    6126 
    6127   case 176:
    6128 
    6129 /* Line 1806 of yacc.c  */
    6130 #line 791 "parser.yy"
    6131     { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
    6132     break;
    6133 
    6134   case 177:
    6135 
    6136 /* Line 1806 of yacc.c  */
    6137 #line 793 "parser.yy"
    6138     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    6139     break;
    6140 
    6141   case 178:
    6142 
    6143 /* Line 1806 of yacc.c  */
    6144 #line 795 "parser.yy"
    6145     { (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) ) ) ) ) ) ); }
    6146     break;
    6147 
    6148   case 179:
    6149 
    6150 /* Line 1806 of yacc.c  */
    6151 #line 800 "parser.yy"
     6160  case 182:
     6161
     6162/* Line 1806 of yacc.c  */
     6163#line 802 "parser.yy"
     6164    { (yyval.sn) = 0; }
     6165    break;
     6166
     6167  case 183:
     6168
     6169/* Line 1806 of yacc.c  */
     6170#line 807 "parser.yy"
     6171    { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
     6172    break;
     6173
     6174  case 184:
     6175
     6176/* Line 1806 of yacc.c  */
     6177#line 809 "parser.yy"
     6178    { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); }
     6179    break;
     6180
     6181  case 185:
     6182
     6183/* Line 1806 of yacc.c  */
     6184#line 811 "parser.yy"
     6185    { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); }
     6186    break;
     6187
     6188  case 186:
     6189
     6190/* Line 1806 of yacc.c  */
     6191#line 816 "parser.yy"
     6192    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
     6193    break;
     6194
     6195  case 187:
     6196
     6197/* Line 1806 of yacc.c  */
     6198#line 818 "parser.yy"
     6199    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
     6200    break;
     6201
     6202  case 188:
     6203
     6204/* Line 1806 of yacc.c  */
     6205#line 823 "parser.yy"
     6206    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
     6207    break;
     6208
     6209  case 189:
     6210
     6211/* Line 1806 of yacc.c  */
     6212#line 827 "parser.yy"
     6213    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
     6214    break;
     6215
     6216  case 190:
     6217
     6218/* Line 1806 of yacc.c  */
     6219#line 830 "parser.yy"
     6220    { (yyval.sn) = new StatementNode( StatementNode::Continue ); }
     6221    break;
     6222
     6223  case 191:
     6224
     6225/* Line 1806 of yacc.c  */
     6226#line 834 "parser.yy"
     6227    { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
     6228    break;
     6229
     6230  case 192:
     6231
     6232/* Line 1806 of yacc.c  */
     6233#line 837 "parser.yy"
    61526234    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    61536235    break;
    61546236
    6155   case 181:
    6156 
    6157 /* Line 1806 of yacc.c  */
    6158 #line 806 "parser.yy"
    6159     { (yyval.sn) = 0; }
    6160     break;
    6161 
    6162   case 182:
    6163 
    6164 /* Line 1806 of yacc.c  */
    6165 #line 808 "parser.yy"
    6166     { (yyval.sn) = 0; }
    6167     break;
    6168 
    6169   case 183:
    6170 
    6171 /* Line 1806 of yacc.c  */
    6172 #line 813 "parser.yy"
    6173     { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    6174     break;
    6175 
    6176   case 184:
    6177 
    6178 /* Line 1806 of yacc.c  */
    6179 #line 815 "parser.yy"
    6180     { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); }
    6181     break;
    6182 
    6183   case 185:
    6184 
    6185 /* Line 1806 of yacc.c  */
    6186 #line 817 "parser.yy"
    6187     { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); }
    6188     break;
    6189 
    6190   case 186:
    6191 
    6192 /* Line 1806 of yacc.c  */
    6193 #line 822 "parser.yy"
    6194     { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    6195     break;
    6196 
    6197   case 187:
    6198 
    6199 /* Line 1806 of yacc.c  */
    6200 #line 824 "parser.yy"
    6201     { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    6202     break;
    6203 
    6204   case 188:
    6205 
    6206 /* Line 1806 of yacc.c  */
    6207 #line 829 "parser.yy"
    6208     { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
    6209     break;
    6210 
    6211   case 189:
    6212 
    6213 /* Line 1806 of yacc.c  */
    6214 #line 833 "parser.yy"
    6215     { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
    6216     break;
    6217 
    6218   case 190:
    6219 
    6220 /* Line 1806 of yacc.c  */
    6221 #line 836 "parser.yy"
    6222     { (yyval.sn) = new StatementNode( StatementNode::Continue ); }
    6223     break;
    6224 
    6225   case 191:
    6226 
    6227 /* Line 1806 of yacc.c  */
    6228 #line 840 "parser.yy"
    6229     { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
    6230     break;
    6231 
    6232   case 192:
     6237  case 193:
     6238
     6239/* Line 1806 of yacc.c  */
     6240#line 841 "parser.yy"
     6241    { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
     6242    break;
     6243
     6244  case 194:
    62336245
    62346246/* Line 1806 of yacc.c  */
    62356247#line 843 "parser.yy"
    6236     { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    6237     break;
    6238 
    6239   case 193:
    6240 
    6241 /* Line 1806 of yacc.c  */
    6242 #line 847 "parser.yy"
    6243     { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
    6244     break;
    6245 
    6246   case 194:
     6248    { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); }
     6249    break;
     6250
     6251  case 195:
     6252
     6253/* Line 1806 of yacc.c  */
     6254#line 845 "parser.yy"
     6255    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
     6256    break;
     6257
     6258  case 196:
    62476259
    62486260/* Line 1806 of yacc.c  */
    62496261#line 849 "parser.yy"
    6250     { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); }
    6251     break;
    6252 
    6253   case 195:
     6262    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
     6263    break;
     6264
     6265  case 197:
    62546266
    62556267/* Line 1806 of yacc.c  */
    62566268#line 851 "parser.yy"
    6257     { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    6258     break;
    6259 
    6260   case 196:
    6261 
    6262 /* Line 1806 of yacc.c  */
    6263 #line 855 "parser.yy"
    6264     { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    6265     break;
    6266 
    6267   case 197:
    6268 
    6269 /* Line 1806 of yacc.c  */
    6270 #line 857 "parser.yy"
    62716269    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (5)].en), 0 ); }
    62726270    break;
     
    62756273
    62766274/* Line 1806 of yacc.c  */
    6277 #line 864 "parser.yy"
     6275#line 858 "parser.yy"
    62786276    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    62796277    break;
     
    62826280
    62836281/* Line 1806 of yacc.c  */
    6284 #line 866 "parser.yy"
     6282#line 860 "parser.yy"
    62856283    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    62866284    break;
     
    62896287
    62906288/* Line 1806 of yacc.c  */
    6291 #line 868 "parser.yy"
     6289#line 862 "parser.yy"
    62926290    {
    62936291                        (yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) );
     
    62996297
    63006298/* Line 1806 of yacc.c  */
     6299#line 873 "parser.yy"
     6300    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
     6301    break;
     6302
     6303  case 203:
     6304
     6305/* Line 1806 of yacc.c  */
     6306#line 875 "parser.yy"
     6307    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
     6308    break;
     6309
     6310  case 204:
     6311
     6312/* Line 1806 of yacc.c  */
     6313#line 877 "parser.yy"
     6314    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
     6315    break;
     6316
     6317  case 205:
     6318
     6319/* Line 1806 of yacc.c  */
    63016320#line 879 "parser.yy"
    6302     { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    6303     break;
    6304 
    6305   case 203:
    6306 
    6307 /* Line 1806 of yacc.c  */
    6308 #line 881 "parser.yy"
    63096321    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    63106322    break;
    63116323
    6312   case 204:
    6313 
    6314 /* Line 1806 of yacc.c  */
    6315 #line 883 "parser.yy"
    6316     { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    6317     break;
    6318 
    6319   case 205:
    6320 
    6321 /* Line 1806 of yacc.c  */
    6322 #line 885 "parser.yy"
    6323     { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    6324     break;
    6325 
    63266324  case 206:
    63276325
    63286326/* Line 1806 of yacc.c  */
     6327#line 884 "parser.yy"
     6328    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
     6329    break;
     6330
     6331  case 207:
     6332
     6333/* Line 1806 of yacc.c  */
     6334#line 886 "parser.yy"
     6335    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
     6336    break;
     6337
     6338  case 208:
     6339
     6340/* Line 1806 of yacc.c  */
     6341#line 888 "parser.yy"
     6342    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
     6343    break;
     6344
     6345  case 209:
     6346
     6347/* Line 1806 of yacc.c  */
    63296348#line 890 "parser.yy"
    6330     { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    6331     break;
    6332 
    6333   case 207:
    6334 
    6335 /* Line 1806 of yacc.c  */
    6336 #line 892 "parser.yy"
    63376349    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    63386350    break;
    63396351
    6340   case 208:
    6341 
    6342 /* Line 1806 of yacc.c  */
    6343 #line 894 "parser.yy"
    6344     { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    6345     break;
    6346 
    6347   case 209:
    6348 
    6349 /* Line 1806 of yacc.c  */
    6350 #line 896 "parser.yy"
    6351     { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    6352     break;
    6353 
    63546352  case 210:
    63556353
    63566354/* Line 1806 of yacc.c  */
    6357 #line 901 "parser.yy"
     6355#line 895 "parser.yy"
    63586356    {
    63596357                        (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
     
    63656363
    63666364/* Line 1806 of yacc.c  */
    6367 #line 915 "parser.yy"
     6365#line 909 "parser.yy"
    63686366    {
    63696367                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63756373
    63766374/* Line 1806 of yacc.c  */
    6377 #line 920 "parser.yy"
     6375#line 914 "parser.yy"
    63786376    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    63796377    break;
     
    63826380
    63836381/* Line 1806 of yacc.c  */
    6384 #line 922 "parser.yy"
     6382#line 916 "parser.yy"
    63856383    {
    63866384                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63926390
    63936391/* Line 1806 of yacc.c  */
     6392#line 925 "parser.yy"
     6393    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
     6394    break;
     6395
     6396  case 217:
     6397
     6398/* Line 1806 of yacc.c  */
     6399#line 927 "parser.yy"
     6400    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
     6401    break;
     6402
     6403  case 218:
     6404
     6405/* Line 1806 of yacc.c  */
     6406#line 929 "parser.yy"
     6407    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
     6408    break;
     6409
     6410  case 219:
     6411
     6412/* Line 1806 of yacc.c  */
    63946413#line 931 "parser.yy"
    6395     { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
    6396     break;
    6397 
    6398   case 217:
     6414    { (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)].constant) ); }
     6415    break;
     6416
     6417  case 220:
    63996418
    64006419/* Line 1806 of yacc.c  */
    64016420#line 933 "parser.yy"
    6402     { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
    6403     break;
    6404 
    6405   case 218:
    6406 
    6407 /* Line 1806 of yacc.c  */
    6408 #line 935 "parser.yy"
    6409     { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
    6410     break;
    6411 
    6412   case 219:
    6413 
    6414 /* Line 1806 of yacc.c  */
    6415 #line 937 "parser.yy"
    6416     { (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)].constant) ); }
    6417     break;
    6418 
    6419   case 220:
    6420 
    6421 /* Line 1806 of yacc.c  */
    6422 #line 939 "parser.yy"
    64236421    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].constant), (yyvsp[(12) - (14)].label) ); }
    64246422    break;
     
    64276425
    64286426/* Line 1806 of yacc.c  */
    6429 #line 944 "parser.yy"
     6427#line 938 "parser.yy"
    64306428    { (yyval.flag) = false; }
    64316429    break;
     
    64346432
    64356433/* Line 1806 of yacc.c  */
    6436 #line 946 "parser.yy"
     6434#line 940 "parser.yy"
    64376435    { (yyval.flag) = true; }
    64386436    break;
     
    64416439
    64426440/* Line 1806 of yacc.c  */
    6443 #line 951 "parser.yy"
     6441#line 945 "parser.yy"
    64446442    { (yyval.en) = 0; }
    64456443    break;
     
    64486446
    64496447/* Line 1806 of yacc.c  */
    6450 #line 958 "parser.yy"
     6448#line 952 "parser.yy"
    64516449    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    64526450    break;
     
    64556453
    64566454/* Line 1806 of yacc.c  */
    6457 #line 963 "parser.yy"
     6455#line 957 "parser.yy"
    64586456    { (yyval.en) = new AsmExprNode( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ); }
    64596457    break;
     
    64626460
    64636461/* Line 1806 of yacc.c  */
    6464 #line 965 "parser.yy"
     6462#line 959 "parser.yy"
    64656463    { (yyval.en) = new AsmExprNode( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ); }
    64666464    break;
     
    64696467
    64706468/* Line 1806 of yacc.c  */
    6471 #line 970 "parser.yy"
     6469#line 964 "parser.yy"
    64726470    { (yyval.constant) = 0; }
    64736471    break;
     
    64766474
    64776475/* Line 1806 of yacc.c  */
    6478 #line 972 "parser.yy"
     6476#line 966 "parser.yy"
    64796477    { (yyval.constant) = (yyvsp[(1) - (1)].constant); }
    64806478    break;
     
    64836481
    64846482/* Line 1806 of yacc.c  */
    6485 #line 974 "parser.yy"
     6483#line 968 "parser.yy"
    64866484    { (yyval.constant) = (ConstantNode *)(yyvsp[(1) - (3)].constant)->set_link( (yyvsp[(3) - (3)].constant) ); }
    64876485    break;
     
    64906488
    64916489/* Line 1806 of yacc.c  */
    6492 #line 979 "parser.yy"
     6490#line 973 "parser.yy"
    64936491    { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
    64946492    break;
     
    64976495
    64986496/* Line 1806 of yacc.c  */
    6499 #line 981 "parser.yy"
     6497#line 975 "parser.yy"
    65006498    { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
    65016499    break;
     
    65046502
    65056503/* Line 1806 of yacc.c  */
    6506 #line 988 "parser.yy"
     6504#line 982 "parser.yy"
    65076505    { (yyval.decl) = 0; }
    65086506    break;
     
    65116509
    65126510/* Line 1806 of yacc.c  */
    6513 #line 995 "parser.yy"
     6511#line 989 "parser.yy"
    65146512    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    65156513    break;
     
    65186516
    65196517/* Line 1806 of yacc.c  */
    6520 #line 1000 "parser.yy"
     6518#line 994 "parser.yy"
    65216519    { (yyval.decl) = 0; }
    65226520    break;
     
    65256523
    65266524/* Line 1806 of yacc.c  */
    6527 #line 1007 "parser.yy"
     6525#line 1001 "parser.yy"
    65286526    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    65296527    break;
     
    65326530
    65336531/* Line 1806 of yacc.c  */
    6534 #line 1021 "parser.yy"
     6532#line 1015 "parser.yy"
    65356533    {}
    65366534    break;
     
    65396537
    65406538/* Line 1806 of yacc.c  */
    6541 #line 1022 "parser.yy"
     6539#line 1016 "parser.yy"
    65426540    {}
    65436541    break;
     
    65466544
    65476545/* Line 1806 of yacc.c  */
    6548 #line 1051 "parser.yy"
     6546#line 1045 "parser.yy"
    65496547    {
    65506548                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65566554
    65576555/* Line 1806 of yacc.c  */
    6558 #line 1058 "parser.yy"
     6556#line 1052 "parser.yy"
    65596557    {
    65606558                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65666564
    65676565/* Line 1806 of yacc.c  */
    6568 #line 1063 "parser.yy"
     6566#line 1057 "parser.yy"
    65696567    {
    65706568                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
     
    65766574
    65776575/* Line 1806 of yacc.c  */
    6578 #line 1073 "parser.yy"
     6576#line 1067 "parser.yy"
    65796577    {
    65806578                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    65866584
    65876585/* Line 1806 of yacc.c  */
    6588 #line 1078 "parser.yy"
     6586#line 1072 "parser.yy"
    65896587    {
    65906588                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    65966594
    65976595/* Line 1806 of yacc.c  */
    6598 #line 1083 "parser.yy"
     6596#line 1077 "parser.yy"
    65996597    {
    66006598                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
     
    66066604
    66076605/* Line 1806 of yacc.c  */
    6608 #line 1091 "parser.yy"
     6606#line 1085 "parser.yy"
    66096607    {
    66106608                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66166614
    66176615/* Line 1806 of yacc.c  */
    6618 #line 1096 "parser.yy"
     6616#line 1090 "parser.yy"
    66196617    {
    66206618                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66266624
    66276625/* Line 1806 of yacc.c  */
    6628 #line 1101 "parser.yy"
     6626#line 1095 "parser.yy"
    66296627    {
    66306628                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66366634
    66376635/* Line 1806 of yacc.c  */
    6638 #line 1106 "parser.yy"
     6636#line 1100 "parser.yy"
    66396637    {
    66406638                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66466644
    66476645/* Line 1806 of yacc.c  */
    6648 #line 1111 "parser.yy"
     6646#line 1105 "parser.yy"
    66496647    {
    66506648                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    66566654
    66576655/* Line 1806 of yacc.c  */
    6658 #line 1119 "parser.yy"
     6656#line 1113 "parser.yy"
    66596657    {
    66606658                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
     
    66656663
    66666664/* Line 1806 of yacc.c  */
    6667 #line 1142 "parser.yy"
     6665#line 1136 "parser.yy"
    66686666    {
    66696667                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    66746672
    66756673/* Line 1806 of yacc.c  */
    6676 #line 1146 "parser.yy"
     6674#line 1140 "parser.yy"
    66776675    {
    66786676                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    66836681
    66846682/* Line 1806 of yacc.c  */
    6685 #line 1153 "parser.yy"
     6683#line 1147 "parser.yy"
    66866684    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    66876685    break;
     
    66906688
    66916689/* Line 1806 of yacc.c  */
    6692 #line 1157 "parser.yy"
     6690#line 1151 "parser.yy"
    66936691    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    66946692    break;
     
    66976695
    66986696/* Line 1806 of yacc.c  */
    6699 #line 1162 "parser.yy"
     6697#line 1156 "parser.yy"
    67006698    {
    67016699                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67076705
    67086706/* Line 1806 of yacc.c  */
    6709 #line 1167 "parser.yy"
     6707#line 1161 "parser.yy"
    67106708    {
    67116709                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67176715
    67186716/* Line 1806 of yacc.c  */
    6719 #line 1172 "parser.yy"
     6717#line 1166 "parser.yy"
    67206718    {
    67216719                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
     
    67276725
    67286726/* Line 1806 of yacc.c  */
    6729 #line 1183 "parser.yy"
     6727#line 1177 "parser.yy"
    67306728    {
    67316729                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67376735
    67386736/* Line 1806 of yacc.c  */
    6739 #line 1188 "parser.yy"
     6737#line 1182 "parser.yy"
    67406738    {
    67416739                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67476745
    67486746/* Line 1806 of yacc.c  */
    6749 #line 1193 "parser.yy"
     6747#line 1187 "parser.yy"
    67506748    {
    67516749                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67576755
    67586756/* Line 1806 of yacc.c  */
    6759 #line 1198 "parser.yy"
     6757#line 1192 "parser.yy"
    67606758    {
    67616759                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67676765
    67686766/* Line 1806 of yacc.c  */
    6769 #line 1203 "parser.yy"
     6767#line 1197 "parser.yy"
    67706768    {
    67716769                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67776775
    67786776/* Line 1806 of yacc.c  */
    6779 #line 1212 "parser.yy"
     6777#line 1206 "parser.yy"
    67806778    {
    67816779                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
     
    67876785
    67886786/* Line 1806 of yacc.c  */
    6789 #line 1217 "parser.yy"
     6787#line 1211 "parser.yy"
    67906788    {
    67916789                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
     
    67976795
    67986796/* Line 1806 of yacc.c  */
    6799 #line 1234 "parser.yy"
     6797#line 1228 "parser.yy"
    68006798    {
    68016799                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    68076805
    68086806/* Line 1806 of yacc.c  */
    6809 #line 1239 "parser.yy"
     6807#line 1233 "parser.yy"
    68106808    {
    68116809                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    68176815
    68186816/* Line 1806 of yacc.c  */
    6819 #line 1261 "parser.yy"
     6817#line 1255 "parser.yy"
    68206818    { (yyval.decl) = 0; }
    68216819    break;
     
    68246822
    68256823/* Line 1806 of yacc.c  */
    6826 #line 1273 "parser.yy"
     6824#line 1267 "parser.yy"
    68276825    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68286826    break;
     
    68316829
    68326830/* Line 1806 of yacc.c  */
     6831#line 1278 "parser.yy"
     6832    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
     6833    break;
     6834
     6835  case 302:
     6836
     6837/* Line 1806 of yacc.c  */
     6838#line 1280 "parser.yy"
     6839    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
     6840    break;
     6841
     6842  case 303:
     6843
     6844/* Line 1806 of yacc.c  */
     6845#line 1282 "parser.yy"
     6846    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
     6847    break;
     6848
     6849  case 304:
     6850
     6851/* Line 1806 of yacc.c  */
    68336852#line 1284 "parser.yy"
    6834     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    6835     break;
    6836 
    6837   case 302:
     6853    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
     6854    break;
     6855
     6856  case 305:
    68386857
    68396858/* Line 1806 of yacc.c  */
    68406859#line 1286 "parser.yy"
    6841     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    6842     break;
    6843 
    6844   case 303:
     6860    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
     6861    break;
     6862
     6863  case 306:
    68456864
    68466865/* Line 1806 of yacc.c  */
    68476866#line 1288 "parser.yy"
    6848     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    6849     break;
    6850 
    6851   case 304:
    6852 
    6853 /* Line 1806 of yacc.c  */
    6854 #line 1290 "parser.yy"
    6855     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    6856     break;
    6857 
    6858   case 305:
    6859 
    6860 /* Line 1806 of yacc.c  */
    6861 #line 1292 "parser.yy"
    6862     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    6863     break;
    6864 
    6865   case 306:
    6866 
    6867 /* Line 1806 of yacc.c  */
    6868 #line 1294 "parser.yy"
    68696867    {
    68706868                        typedefTable.enterScope();
     
    68756873
    68766874/* Line 1806 of yacc.c  */
    6877 #line 1298 "parser.yy"
     6875#line 1292 "parser.yy"
    68786876    {
    68796877                        typedefTable.leaveScope();
     
    68856883
    68866884/* Line 1806 of yacc.c  */
    6887 #line 1307 "parser.yy"
     6885#line 1301 "parser.yy"
    68886886    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68896887    break;
     
    68926890
    68936891/* Line 1806 of yacc.c  */
    6894 #line 1309 "parser.yy"
     6892#line 1303 "parser.yy"
    68956893    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68966894    break;
     
    68996897
    69006898/* Line 1806 of yacc.c  */
    6901 #line 1320 "parser.yy"
     6899#line 1314 "parser.yy"
    69026900    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69036901    break;
     
    69066904
    69076905/* Line 1806 of yacc.c  */
     6906#line 1323 "parser.yy"
     6907    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
     6908    break;
     6909
     6910  case 315:
     6911
     6912/* Line 1806 of yacc.c  */
     6913#line 1325 "parser.yy"
     6914    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
     6915    break;
     6916
     6917  case 316:
     6918
     6919/* Line 1806 of yacc.c  */
     6920#line 1327 "parser.yy"
     6921    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
     6922    break;
     6923
     6924  case 317:
     6925
     6926/* Line 1806 of yacc.c  */
    69086927#line 1329 "parser.yy"
    6909     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    6910     break;
    6911 
    6912   case 315:
     6928    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     6929    break;
     6930
     6931  case 318:
    69136932
    69146933/* Line 1806 of yacc.c  */
    69156934#line 1331 "parser.yy"
    6916     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    6917     break;
    6918 
    6919   case 316:
     6935    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
     6936    break;
     6937
     6938  case 319:
    69206939
    69216940/* Line 1806 of yacc.c  */
    69226941#line 1333 "parser.yy"
    6923     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    6924     break;
    6925 
    6926   case 317:
     6942    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
     6943    break;
     6944
     6945  case 320:
    69276946
    69286947/* Line 1806 of yacc.c  */
    69296948#line 1335 "parser.yy"
    6930     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    6931     break;
    6932 
    6933   case 318:
     6949    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
     6950    break;
     6951
     6952  case 321:
    69346953
    69356954/* Line 1806 of yacc.c  */
    69366955#line 1337 "parser.yy"
    6937     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    6938     break;
    6939 
    6940   case 319:
    6941 
    6942 /* Line 1806 of yacc.c  */
    6943 #line 1339 "parser.yy"
    6944     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    6945     break;
    6946 
    6947   case 320:
    6948 
    6949 /* Line 1806 of yacc.c  */
    6950 #line 1341 "parser.yy"
    6951     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
    6952     break;
    6953 
    6954   case 321:
    6955 
    6956 /* Line 1806 of yacc.c  */
    6957 #line 1343 "parser.yy"
    69586956    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    69596957    break;
     
    69626960
    69636961/* Line 1806 of yacc.c  */
     6962#line 1342 "parser.yy"
     6963    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
     6964    break;
     6965
     6966  case 323:
     6967
     6968/* Line 1806 of yacc.c  */
     6969#line 1344 "parser.yy"
     6970    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
     6971    break;
     6972
     6973  case 324:
     6974
     6975/* Line 1806 of yacc.c  */
     6976#line 1346 "parser.yy"
     6977    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
     6978    break;
     6979
     6980  case 325:
     6981
     6982/* Line 1806 of yacc.c  */
    69646983#line 1348 "parser.yy"
    6965     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    6966     break;
    6967 
    6968   case 323:
     6984    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
     6985    break;
     6986
     6987  case 326:
    69696988
    69706989/* Line 1806 of yacc.c  */
    69716990#line 1350 "parser.yy"
    6972     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    6973     break;
    6974 
    6975   case 324:
     6991    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
     6992    break;
     6993
     6994  case 327:
    69766995
    69776996/* Line 1806 of yacc.c  */
    69786997#line 1352 "parser.yy"
    6979     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    6980     break;
    6981 
    6982   case 325:
     6998    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
     6999    break;
     7000
     7001  case 328:
    69837002
    69847003/* Line 1806 of yacc.c  */
    69857004#line 1354 "parser.yy"
    6986     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    6987     break;
    6988 
    6989   case 326:
     7005    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
     7006    break;
     7007
     7008  case 329:
    69907009
    69917010/* Line 1806 of yacc.c  */
    69927011#line 1356 "parser.yy"
    6993     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
    6994     break;
    6995 
    6996   case 327:
     7012    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
     7013    break;
     7014
     7015  case 330:
    69977016
    69987017/* Line 1806 of yacc.c  */
    69997018#line 1358 "parser.yy"
    7000     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
    7001     break;
    7002 
    7003   case 328:
     7019    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     7020    break;
     7021
     7022  case 331:
    70047023
    70057024/* Line 1806 of yacc.c  */
    70067025#line 1360 "parser.yy"
    7007     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
    7008     break;
    7009 
    7010   case 329:
     7026    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
     7027    break;
     7028
     7029  case 332:
    70117030
    70127031/* Line 1806 of yacc.c  */
    70137032#line 1362 "parser.yy"
    7014     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
    7015     break;
    7016 
    7017   case 330:
     7033    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
     7034    break;
     7035
     7036  case 333:
    70187037
    70197038/* Line 1806 of yacc.c  */
    70207039#line 1364 "parser.yy"
    7021     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    7022     break;
    7023 
    7024   case 331:
     7040    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
     7041    break;
     7042
     7043  case 334:
    70257044
    70267045/* Line 1806 of yacc.c  */
    70277046#line 1366 "parser.yy"
    7028     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    7029     break;
    7030 
    7031   case 332:
    7032 
    7033 /* Line 1806 of yacc.c  */
    7034 #line 1368 "parser.yy"
    7035     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
    7036     break;
    7037 
    7038   case 333:
    7039 
    7040 /* Line 1806 of yacc.c  */
    7041 #line 1370 "parser.yy"
    7042     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
    7043     break;
    7044 
    7045   case 334:
    7046 
    7047 /* Line 1806 of yacc.c  */
    7048 #line 1372 "parser.yy"
    70497047    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    70507048    break;
     
    70537051
    70547052/* Line 1806 of yacc.c  */
     7053#line 1373 "parser.yy"
     7054    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     7055    break;
     7056
     7057  case 337:
     7058
     7059/* Line 1806 of yacc.c  */
     7060#line 1375 "parser.yy"
     7061    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     7062    break;
     7063
     7064  case 338:
     7065
     7066/* Line 1806 of yacc.c  */
     7067#line 1377 "parser.yy"
     7068    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     7069    break;
     7070
     7071  case 339:
     7072
     7073/* Line 1806 of yacc.c  */
    70557074#line 1379 "parser.yy"
     7075    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
     7076    break;
     7077
     7078  case 341:
     7079
     7080/* Line 1806 of yacc.c  */
     7081#line 1385 "parser.yy"
     7082    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     7083    break;
     7084
     7085  case 343:
     7086
     7087/* Line 1806 of yacc.c  */
     7088#line 1392 "parser.yy"
    70567089    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    70577090    break;
    70587091
    7059   case 337:
    7060 
    7061 /* Line 1806 of yacc.c  */
    7062 #line 1381 "parser.yy"
     7092  case 344:
     7093
     7094/* Line 1806 of yacc.c  */
     7095#line 1394 "parser.yy"
    70637096    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    70647097    break;
    70657098
    7066   case 338:
    7067 
    7068 /* Line 1806 of yacc.c  */
    7069 #line 1383 "parser.yy"
     7099  case 345:
     7100
     7101/* Line 1806 of yacc.c  */
     7102#line 1396 "parser.yy"
     7103    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
     7104    break;
     7105
     7106  case 346:
     7107
     7108/* Line 1806 of yacc.c  */
     7109#line 1401 "parser.yy"
     7110    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
     7111    break;
     7112
     7113  case 347:
     7114
     7115/* Line 1806 of yacc.c  */
     7116#line 1403 "parser.yy"
     7117    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
     7118    break;
     7119
     7120  case 348:
     7121
     7122/* Line 1806 of yacc.c  */
     7123#line 1405 "parser.yy"
     7124    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
     7125    break;
     7126
     7127  case 349:
     7128
     7129/* Line 1806 of yacc.c  */
     7130#line 1407 "parser.yy"
     7131    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
     7132    break;
     7133
     7134  case 351:
     7135
     7136/* Line 1806 of yacc.c  */
     7137#line 1413 "parser.yy"
     7138    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     7139    break;
     7140
     7141  case 352:
     7142
     7143/* Line 1806 of yacc.c  */
     7144#line 1415 "parser.yy"
     7145    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     7146    break;
     7147
     7148  case 353:
     7149
     7150/* Line 1806 of yacc.c  */
     7151#line 1417 "parser.yy"
    70707152    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    70717153    break;
    70727154
    7073   case 339:
    7074 
    7075 /* Line 1806 of yacc.c  */
    7076 #line 1385 "parser.yy"
    7077     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    7078     break;
    7079 
    7080   case 341:
    7081 
    7082 /* Line 1806 of yacc.c  */
    7083 #line 1391 "parser.yy"
    7084     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    7085     break;
    7086 
    7087   case 343:
    7088 
    7089 /* Line 1806 of yacc.c  */
    7090 #line 1398 "parser.yy"
     7155  case 355:
     7156
     7157/* Line 1806 of yacc.c  */
     7158#line 1423 "parser.yy"
    70917159    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    70927160    break;
    70937161
    7094   case 344:
    7095 
    7096 /* Line 1806 of yacc.c  */
    7097 #line 1400 "parser.yy"
     7162  case 356:
     7163
     7164/* Line 1806 of yacc.c  */
     7165#line 1425 "parser.yy"
    70987166    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    70997167    break;
    71007168
    7101   case 345:
    7102 
    7103 /* Line 1806 of yacc.c  */
    7104 #line 1402 "parser.yy"
    7105     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    7106     break;
    7107 
    7108   case 346:
    7109 
    7110 /* Line 1806 of yacc.c  */
    7111 #line 1407 "parser.yy"
    7112     { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    7113     break;
    7114 
    7115   case 347:
    7116 
    7117 /* Line 1806 of yacc.c  */
    7118 #line 1409 "parser.yy"
    7119     { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    7120     break;
    7121 
    7122   case 348:
    7123 
    7124 /* Line 1806 of yacc.c  */
    7125 #line 1411 "parser.yy"
    7126     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    7127     break;
    7128 
    7129   case 349:
    7130 
    7131 /* Line 1806 of yacc.c  */
    7132 #line 1413 "parser.yy"
    7133     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    7134     break;
    7135 
    7136   case 351:
    7137 
    7138 /* Line 1806 of yacc.c  */
    7139 #line 1419 "parser.yy"
     7169  case 358:
     7170
     7171/* Line 1806 of yacc.c  */
     7172#line 1431 "parser.yy"
    71407173    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    71417174    break;
    71427175
    7143   case 352:
    7144 
    7145 /* Line 1806 of yacc.c  */
    7146 #line 1421 "parser.yy"
     7176  case 359:
     7177
     7178/* Line 1806 of yacc.c  */
     7179#line 1433 "parser.yy"
    71477180    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    71487181    break;
    71497182
    7150   case 353:
    7151 
    7152 /* Line 1806 of yacc.c  */
    7153 #line 1423 "parser.yy"
     7183  case 360:
     7184
     7185/* Line 1806 of yacc.c  */
     7186#line 1435 "parser.yy"
    71547187    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    71557188    break;
    71567189
    7157   case 355:
    7158 
    7159 /* Line 1806 of yacc.c  */
    7160 #line 1429 "parser.yy"
    7161     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7162     break;
    7163 
    7164   case 356:
    7165 
    7166 /* Line 1806 of yacc.c  */
    7167 #line 1431 "parser.yy"
     7190  case 361:
     7191
     7192/* Line 1806 of yacc.c  */
     7193#line 1440 "parser.yy"
     7194    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
     7195    break;
     7196
     7197  case 362:
     7198
     7199/* Line 1806 of yacc.c  */
     7200#line 1442 "parser.yy"
     7201    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     7202    break;
     7203
     7204  case 363:
     7205
     7206/* Line 1806 of yacc.c  */
     7207#line 1444 "parser.yy"
    71687208    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    71697209    break;
    71707210
    7171   case 358:
    7172 
    7173 /* Line 1806 of yacc.c  */
    7174 #line 1437 "parser.yy"
    7175     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7176     break;
    7177 
    7178   case 359:
    7179 
    7180 /* Line 1806 of yacc.c  */
    7181 #line 1439 "parser.yy"
    7182     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    7183     break;
    7184 
    7185   case 360:
    7186 
    7187 /* Line 1806 of yacc.c  */
    7188 #line 1441 "parser.yy"
    7189     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    7190     break;
    7191 
    7192   case 361:
    7193 
    7194 /* Line 1806 of yacc.c  */
    7195 #line 1446 "parser.yy"
    7196     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    7197     break;
    7198 
    7199   case 362:
    7200 
    7201 /* Line 1806 of yacc.c  */
    7202 #line 1448 "parser.yy"
    7203     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7204     break;
    7205 
    7206   case 363:
    7207 
    7208 /* Line 1806 of yacc.c  */
    7209 #line 1450 "parser.yy"
    7210     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    7211     break;
    7212 
    72137211  case 366:
    72147212
    72157213/* Line 1806 of yacc.c  */
    7216 #line 1460 "parser.yy"
     7214#line 1454 "parser.yy"
    72177215    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
    72187216    break;
     
    72217219
    72227220/* Line 1806 of yacc.c  */
    7223 #line 1462 "parser.yy"
     7221#line 1456 "parser.yy"
    72247222    {
    72257223                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    72317229
    72327230/* Line 1806 of yacc.c  */
     7231#line 1461 "parser.yy"
     7232    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     7233    break;
     7234
     7235  case 369:
     7236
     7237/* Line 1806 of yacc.c  */
     7238#line 1463 "parser.yy"
     7239    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
     7240    break;
     7241
     7242  case 370:
     7243
     7244/* Line 1806 of yacc.c  */
     7245#line 1465 "parser.yy"
     7246    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
     7247    break;
     7248
     7249  case 371:
     7250
     7251/* Line 1806 of yacc.c  */
    72337252#line 1467 "parser.yy"
    7234     { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    7235     break;
    7236 
    7237   case 369:
    7238 
    7239 /* Line 1806 of yacc.c  */
    7240 #line 1469 "parser.yy"
    7241     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
    7242     break;
    7243 
    7244   case 370:
    7245 
    7246 /* Line 1806 of yacc.c  */
    7247 #line 1471 "parser.yy"
    7248     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    7249     break;
    7250 
    7251   case 371:
    7252 
    7253 /* Line 1806 of yacc.c  */
    7254 #line 1473 "parser.yy"
    72557253    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    72567254    break;
     
    72597257
    72607258/* Line 1806 of yacc.c  */
    7261 #line 1478 "parser.yy"
     7259#line 1472 "parser.yy"
    72627260    { (yyval.aggKey) = DeclarationNode::Struct; }
    72637261    break;
     
    72667264
    72677265/* Line 1806 of yacc.c  */
    7268 #line 1480 "parser.yy"
     7266#line 1474 "parser.yy"
    72697267    { (yyval.aggKey) = DeclarationNode::Union; }
    72707268    break;
     
    72737271
    72747272/* Line 1806 of yacc.c  */
    7275 #line 1485 "parser.yy"
     7273#line 1479 "parser.yy"
    72767274    { (yyval.decl) = 0; }
    72777275    break;
     
    72807278
    72817279/* Line 1806 of yacc.c  */
     7280#line 1481 "parser.yy"
     7281    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
     7282    break;
     7283
     7284  case 377:
     7285
     7286/* Line 1806 of yacc.c  */
    72827287#line 1487 "parser.yy"
    7283     { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    7284     break;
    7285 
    7286   case 377:
    7287 
    7288 /* Line 1806 of yacc.c  */
    7289 #line 1493 "parser.yy"
    72907288    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    72917289    break;
     
    72947292
    72957293/* Line 1806 of yacc.c  */
    7296 #line 1496 "parser.yy"
     7294#line 1490 "parser.yy"
    72977295    {   // mark all fields in list
    72987296                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    73057303
    73067304/* Line 1806 of yacc.c  */
    7307 #line 1506 "parser.yy"
     7305#line 1500 "parser.yy"
    73087306    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    73097307    break;
     
    73127310
    73137311/* Line 1806 of yacc.c  */
    7314 #line 1508 "parser.yy"
     7312#line 1502 "parser.yy"
    73157313    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    73167314    break;
     
    73197317
    73207318/* Line 1806 of yacc.c  */
    7321 #line 1510 "parser.yy"
     7319#line 1504 "parser.yy"
    73227320    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    73237321    break;
     
    73267324
    73277325/* Line 1806 of yacc.c  */
    7328 #line 1515 "parser.yy"
     7326#line 1509 "parser.yy"
    73297327    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73307328    break;
     
    73337331
    73347332/* Line 1806 of yacc.c  */
    7335 #line 1517 "parser.yy"
     7333#line 1511 "parser.yy"
    73367334    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    73377335    break;
     
    73407338
    73417339/* Line 1806 of yacc.c  */
    7342 #line 1522 "parser.yy"
     7340#line 1516 "parser.yy"
    73437341    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    73447342    break;
     
    73477345
    73487346/* Line 1806 of yacc.c  */
     7347#line 1518 "parser.yy"
     7348    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
     7349    break;
     7350
     7351  case 388:
     7352
     7353/* Line 1806 of yacc.c  */
     7354#line 1521 "parser.yy"
     7355    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     7356    break;
     7357
     7358  case 389:
     7359
     7360/* Line 1806 of yacc.c  */
    73497361#line 1524 "parser.yy"
    7350     { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    7351     break;
    7352 
    7353   case 388:
    7354 
    7355 /* Line 1806 of yacc.c  */
    7356 #line 1527 "parser.yy"
    73577362    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    73587363    break;
    73597364
    7360   case 389:
     7365  case 391:
    73617366
    73627367/* Line 1806 of yacc.c  */
    73637368#line 1530 "parser.yy"
    7364     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    7365     break;
    7366 
    7367   case 391:
    7368 
    7369 /* Line 1806 of yacc.c  */
    7370 #line 1536 "parser.yy"
    73717369    { (yyval.en) = 0; }
    73727370    break;
     
    73757373
    73767374/* Line 1806 of yacc.c  */
    7377 #line 1538 "parser.yy"
     7375#line 1532 "parser.yy"
    73787376    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    73797377    break;
     
    73827380
    73837381/* Line 1806 of yacc.c  */
    7384 #line 1543 "parser.yy"
     7382#line 1537 "parser.yy"
    73857383    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    73867384    break;
     
    73897387
    73907388/* Line 1806 of yacc.c  */
    7391 #line 1552 "parser.yy"
     7389#line 1546 "parser.yy"
    73927390    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
    73937391    break;
     
    73967394
    73977395/* Line 1806 of yacc.c  */
    7398 #line 1554 "parser.yy"
     7396#line 1548 "parser.yy"
    73997397    {
    74007398                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    74067404
    74077405/* Line 1806 of yacc.c  */
    7408 #line 1559 "parser.yy"
     7406#line 1553 "parser.yy"
    74097407    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    74107408    break;
     
    74137411
    74147412/* Line 1806 of yacc.c  */
    7415 #line 1561 "parser.yy"
     7413#line 1555 "parser.yy"
    74167414    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    74177415    break;
     
    74207418
    74217419/* Line 1806 of yacc.c  */
    7422 #line 1566 "parser.yy"
     7420#line 1560 "parser.yy"
    74237421    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    74247422    break;
     
    74277425
    74287426/* Line 1806 of yacc.c  */
    7429 #line 1568 "parser.yy"
     7427#line 1562 "parser.yy"
    74307428    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    74317429    break;
     
    74347432
    74357433/* Line 1806 of yacc.c  */
    7436 #line 1573 "parser.yy"
     7434#line 1567 "parser.yy"
    74377435    { (yyval.en) = 0; }
    74387436    break;
     
    74417439
    74427440/* Line 1806 of yacc.c  */
    7443 #line 1575 "parser.yy"
     7441#line 1569 "parser.yy"
    74447442    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    74457443    break;
     
    74487446
    74497447/* Line 1806 of yacc.c  */
    7450 #line 1582 "parser.yy"
     7448#line 1576 "parser.yy"
    74517449    { (yyval.decl) = 0; }
    74527450    break;
     
    74557453
    74567454/* Line 1806 of yacc.c  */
    7457 #line 1590 "parser.yy"
     7455#line 1584 "parser.yy"
    74587456    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74597457    break;
     
    74627460
    74637461/* Line 1806 of yacc.c  */
    7464 #line 1592 "parser.yy"
     7462#line 1586 "parser.yy"
    74657463    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    74667464    break;
     
    74697467
    74707468/* Line 1806 of yacc.c  */
    7471 #line 1594 "parser.yy"
     7469#line 1588 "parser.yy"
    74727470    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    74737471    break;
     
    74767474
    74777475/* Line 1806 of yacc.c  */
    7478 #line 1602 "parser.yy"
     7476#line 1596 "parser.yy"
    74797477    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74807478    break;
     
    74837481
    74847482/* Line 1806 of yacc.c  */
    7485 #line 1604 "parser.yy"
     7483#line 1598 "parser.yy"
    74867484    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74877485    break;
     
    74907488
    74917489/* Line 1806 of yacc.c  */
     7490#line 1600 "parser.yy"
     7491    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
     7492    break;
     7493
     7494  case 415:
     7495
     7496/* Line 1806 of yacc.c  */
    74927497#line 1606 "parser.yy"
    7493     { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    7494     break;
    7495 
    7496   case 415:
    7497 
    7498 /* Line 1806 of yacc.c  */
    7499 #line 1612 "parser.yy"
    75007498    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    75017499    break;
     
    75047502
    75057503/* Line 1806 of yacc.c  */
    7506 #line 1617 "parser.yy"
     7504#line 1611 "parser.yy"
    75077505    { (yyval.decl) = 0; }
    75087506    break;
     
    75117509
    75127510/* Line 1806 of yacc.c  */
    7513 #line 1624 "parser.yy"
     7511#line 1618 "parser.yy"
    75147512    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    75157513    break;
     
    75187516
    75197517/* Line 1806 of yacc.c  */
    7520 #line 1631 "parser.yy"
     7518#line 1625 "parser.yy"
    75217519    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    75227520    break;
     
    75257523
    75267524/* Line 1806 of yacc.c  */
    7527 #line 1633 "parser.yy"
     7525#line 1627 "parser.yy"
    75287526    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    75297527    break;
     
    75327530
    75337531/* Line 1806 of yacc.c  */
    7534 #line 1642 "parser.yy"
     7532#line 1636 "parser.yy"
    75357533    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    75367534    break;
     
    75397537
    75407538/* Line 1806 of yacc.c  */
    7541 #line 1645 "parser.yy"
     7539#line 1639 "parser.yy"
    75427540    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    75437541    break;
     
    75467544
    75477545/* Line 1806 of yacc.c  */
    7548 #line 1647 "parser.yy"
     7546#line 1641 "parser.yy"
    75497547    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    75507548    break;
     
    75537551
    75547552/* Line 1806 of yacc.c  */
     7553#line 1651 "parser.yy"
     7554    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     7555    break;
     7556
     7557  case 434:
     7558
     7559/* Line 1806 of yacc.c  */
    75557560#line 1657 "parser.yy"
    7556     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7557     break;
    7558 
    7559   case 434:
    7560 
    7561 /* Line 1806 of yacc.c  */
    7562 #line 1663 "parser.yy"
    75637561    {
    75647562                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    75707568
    75717569/* Line 1806 of yacc.c  */
    7572 #line 1668 "parser.yy"
     7570#line 1662 "parser.yy"
    75737571    {
    75747572                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    75807578
    75817579/* Line 1806 of yacc.c  */
    7582 #line 1677 "parser.yy"
     7580#line 1671 "parser.yy"
    75837581    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    75847582    break;
     
    75877585
    75887586/* Line 1806 of yacc.c  */
    7589 #line 1686 "parser.yy"
     7587#line 1680 "parser.yy"
    75907588    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    75917589    break;
     
    75947592
    75957593/* Line 1806 of yacc.c  */
    7596 #line 1688 "parser.yy"
     7594#line 1682 "parser.yy"
    75977595    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    75987596    break;
     
    76017599
    76027600/* Line 1806 of yacc.c  */
    7603 #line 1713 "parser.yy"
     7601#line 1707 "parser.yy"
    76047602    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    76057603    break;
     
    76087606
    76097607/* Line 1806 of yacc.c  */
    7610 #line 1721 "parser.yy"
     7608#line 1715 "parser.yy"
    76117609    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    76127610    break;
     
    76157613
    76167614/* Line 1806 of yacc.c  */
    7617 #line 1726 "parser.yy"
     7615#line 1720 "parser.yy"
    76187616    { (yyval.in) = 0; }
    76197617    break;
     
    76227620
    76237621/* Line 1806 of yacc.c  */
     7622#line 1722 "parser.yy"
     7623    { (yyval.in) = (yyvsp[(2) - (2)].in); }
     7624    break;
     7625
     7626  case 458:
     7627
     7628/* Line 1806 of yacc.c  */
     7629#line 1724 "parser.yy"
     7630    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
     7631    break;
     7632
     7633  case 459:
     7634
     7635/* Line 1806 of yacc.c  */
    76247636#line 1728 "parser.yy"
    7625     { (yyval.in) = (yyvsp[(2) - (2)].in); }
    7626     break;
    7627 
    7628   case 458:
    7629 
    7630 /* Line 1806 of yacc.c  */
    7631 #line 1730 "parser.yy"
    7632     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    7633     break;
    7634 
    7635   case 459:
     7637    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
     7638    break;
     7639
     7640  case 460:
     7641
     7642/* Line 1806 of yacc.c  */
     7643#line 1729 "parser.yy"
     7644    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
     7645    break;
     7646
     7647  case 461:
    76367648
    76377649/* Line 1806 of yacc.c  */
    76387650#line 1734 "parser.yy"
    7639     { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    7640     break;
    7641 
    7642   case 460:
    7643 
    7644 /* Line 1806 of yacc.c  */
    7645 #line 1735 "parser.yy"
    7646     { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    7647     break;
    7648 
    7649   case 461:
    7650 
    7651 /* Line 1806 of yacc.c  */
    7652 #line 1740 "parser.yy"
    76537651    { (yyval.in) = 0; }
    76547652    break;
     
    76577655
    76587656/* Line 1806 of yacc.c  */
    7659 #line 1742 "parser.yy"
     7657#line 1736 "parser.yy"
    76607658    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    76617659    break;
     
    76647662
    76657663/* Line 1806 of yacc.c  */
    7666 #line 1743 "parser.yy"
     7664#line 1737 "parser.yy"
    76677665    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
    76687666    break;
     
    76717669
    76727670/* Line 1806 of yacc.c  */
    7673 #line 1745 "parser.yy"
     7671#line 1739 "parser.yy"
    76747672    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    76757673    break;
     
    76787676
    76797677/* Line 1806 of yacc.c  */
     7678#line 1755 "parser.yy"
     7679    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (2)].tok) ); }
     7680    break;
     7681
     7682  case 469:
     7683
     7684/* Line 1806 of yacc.c  */
    76807685#line 1761 "parser.yy"
    7681     { (yyval.en) = new VarRefNode( (yyvsp[(1) - (2)].tok) ); }
    7682     break;
    7683 
    7684   case 469:
    7685 
    7686 /* Line 1806 of yacc.c  */
    7687 #line 1767 "parser.yy"
    76887686    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) )); }
    76897687    break;
     
    76927690
    76937691/* Line 1806 of yacc.c  */
    7694 #line 1775 "parser.yy"
     7692#line 1769 "parser.yy"
    76957693    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); }
    76967694    break;
     
    76997697
    77007698/* Line 1806 of yacc.c  */
    7701 #line 1777 "parser.yy"
     7699#line 1771 "parser.yy"
    77027700    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(2) - (2)].tok) ) ); }
    77037701    break;
     
    77067704
    77077705/* Line 1806 of yacc.c  */
     7706#line 1774 "parser.yy"
     7707    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
     7708    break;
     7709
     7710  case 473:
     7711
     7712/* Line 1806 of yacc.c  */
     7713#line 1776 "parser.yy"
     7714    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
     7715    break;
     7716
     7717  case 474:
     7718
     7719/* Line 1806 of yacc.c  */
     7720#line 1778 "parser.yy"
     7721    { (yyval.en) = new DesignatorNode( new CompositeExprNode( new OperatorNode( OperatorNode::Range ), (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ), true ); }
     7722    break;
     7723
     7724  case 475:
     7725
     7726/* Line 1806 of yacc.c  */
    77087727#line 1780 "parser.yy"
    7709     { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    7710     break;
    7711 
    7712   case 473:
    7713 
    7714 /* Line 1806 of yacc.c  */
    7715 #line 1782 "parser.yy"
    7716     { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    7717     break;
    7718 
    7719   case 474:
    7720 
    7721 /* Line 1806 of yacc.c  */
    7722 #line 1784 "parser.yy"
    7723     { (yyval.en) = new DesignatorNode( new CompositeExprNode2( build_opr2( OperatorNode::Range, (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ), true ); }
    7724     break;
    7725 
    7726   case 475:
    7727 
    7728 /* Line 1806 of yacc.c  */
    7729 #line 1786 "parser.yy"
    77307728    { (yyval.en) = new DesignatorNode( (yyvsp[(4) - (6)].en) ); }
    77317729    break;
     
    77347732
    77357733/* Line 1806 of yacc.c  */
    7736 #line 1810 "parser.yy"
     7734#line 1804 "parser.yy"
    77377735    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    77387736    break;
     
    77417739
    77427740/* Line 1806 of yacc.c  */
    7743 #line 1812 "parser.yy"
     7741#line 1806 "parser.yy"
    77447742    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    77457743    break;
     
    77487746
    77497747/* Line 1806 of yacc.c  */
     7748#line 1808 "parser.yy"
     7749    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     7750    break;
     7751
     7752  case 481:
     7753
     7754/* Line 1806 of yacc.c  */
    77507755#line 1814 "parser.yy"
    7751     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    7752     break;
    7753 
    7754   case 481:
    7755 
    7756 /* Line 1806 of yacc.c  */
    7757 #line 1820 "parser.yy"
    77587756    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    77597757    break;
     
    77627760
    77637761/* Line 1806 of yacc.c  */
    7764 #line 1822 "parser.yy"
     7762#line 1816 "parser.yy"
    77657763    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    77667764    break;
     
    77697767
    77707768/* Line 1806 of yacc.c  */
     7769#line 1821 "parser.yy"
     7770    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
     7771    break;
     7772
     7773  case 485:
     7774
     7775/* Line 1806 of yacc.c  */
    77717776#line 1827 "parser.yy"
    7772     { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    7773     break;
    7774 
    7775   case 485:
    7776 
    7777 /* Line 1806 of yacc.c  */
    7778 #line 1833 "parser.yy"
    77797777    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    77807778    break;
     
    77837781
    77847782/* Line 1806 of yacc.c  */
    7785 #line 1838 "parser.yy"
     7783#line 1832 "parser.yy"
    77867784    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    77877785    break;
     
    77907788
    77917789/* Line 1806 of yacc.c  */
     7790#line 1834 "parser.yy"
     7791    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
     7792    break;
     7793
     7794  case 489:
     7795
     7796/* Line 1806 of yacc.c  */
    77927797#line 1840 "parser.yy"
    7793     { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    7794     break;
    7795 
    7796   case 489:
    7797 
    7798 /* Line 1806 of yacc.c  */
    7799 #line 1846 "parser.yy"
    78007798    { (yyval.tclass) = DeclarationNode::Type; }
    78017799    break;
     
    78047802
    78057803/* Line 1806 of yacc.c  */
    7806 #line 1848 "parser.yy"
     7804#line 1842 "parser.yy"
    78077805    { (yyval.tclass) = DeclarationNode::Ftype; }
    78087806    break;
     
    78117809
    78127810/* Line 1806 of yacc.c  */
    7813 #line 1850 "parser.yy"
     7811#line 1844 "parser.yy"
    78147812    { (yyval.tclass) = DeclarationNode::Dtype; }
    78157813    break;
     
    78187816
    78197817/* Line 1806 of yacc.c  */
    7820 #line 1855 "parser.yy"
     7818#line 1849 "parser.yy"
    78217819    { (yyval.decl) = 0; }
    78227820    break;
     
    78257823
    78267824/* Line 1806 of yacc.c  */
    7827 #line 1857 "parser.yy"
     7825#line 1851 "parser.yy"
    78287826    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    78297827    break;
     
    78327830
    78337831/* Line 1806 of yacc.c  */
    7834 #line 1862 "parser.yy"
     7832#line 1856 "parser.yy"
    78357833    {
    78367834                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
     
    78427840
    78437841/* Line 1806 of yacc.c  */
    7844 #line 1867 "parser.yy"
     7842#line 1861 "parser.yy"
    78457843    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    78467844    break;
     
    78497847
    78507848/* Line 1806 of yacc.c  */
    7851 #line 1869 "parser.yy"
     7849#line 1863 "parser.yy"
    78527850    { (yyval.decl) = 0; }
    78537851    break;
     
    78567854
    78577855/* Line 1806 of yacc.c  */
    7858 #line 1874 "parser.yy"
     7856#line 1868 "parser.yy"
    78597857    { (yyval.en) = new TypeValueNode( (yyvsp[(1) - (1)].decl) ); }
    78607858    break;
     
    78637861
    78647862/* Line 1806 of yacc.c  */
    7865 #line 1877 "parser.yy"
     7863#line 1871 "parser.yy"
    78667864    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new TypeValueNode( (yyvsp[(3) - (3)].decl) ))); }
    78677865    break;
     
    78707868
    78717869/* Line 1806 of yacc.c  */
    7872 #line 1879 "parser.yy"
     7870#line 1873 "parser.yy"
    78737871    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    78747872    break;
     
    78777875
    78787876/* Line 1806 of yacc.c  */
    7879 #line 1884 "parser.yy"
     7877#line 1878 "parser.yy"
    78807878    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    78817879    break;
     
    78847882
    78857883/* Line 1806 of yacc.c  */
    7886 #line 1886 "parser.yy"
     7884#line 1880 "parser.yy"
    78877885    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    78887886    break;
     
    78917889
    78927890/* Line 1806 of yacc.c  */
    7893 #line 1888 "parser.yy"
     7891#line 1882 "parser.yy"
    78947892    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    78957893    break;
     
    78987896
    78997897/* Line 1806 of yacc.c  */
    7900 #line 1893 "parser.yy"
     7898#line 1887 "parser.yy"
    79017899    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    79027900    break;
     
    79057903
    79067904/* Line 1806 of yacc.c  */
    7907 #line 1895 "parser.yy"
     7905#line 1889 "parser.yy"
    79087906    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    79097907    break;
     
    79127910
    79137911/* Line 1806 of yacc.c  */
    7914 #line 1900 "parser.yy"
     7912#line 1894 "parser.yy"
    79157913    {
    79167914                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
     
    79227920
    79237921/* Line 1806 of yacc.c  */
    7924 #line 1905 "parser.yy"
     7922#line 1899 "parser.yy"
    79257923    {
    79267924                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
     
    79327930
    79337931/* Line 1806 of yacc.c  */
    7934 #line 1913 "parser.yy"
     7932#line 1907 "parser.yy"
    79357933    {
    79367934                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
     
    79427940
    79437941/* Line 1806 of yacc.c  */
    7944 #line 1918 "parser.yy"
     7942#line 1912 "parser.yy"
    79457943    {
    79467944                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
     
    79527950
    79537951/* Line 1806 of yacc.c  */
    7954 #line 1923 "parser.yy"
     7952#line 1917 "parser.yy"
    79557953    {
    79567954                        typedefTable.leaveTrait();
     
    79637961
    79647962/* Line 1806 of yacc.c  */
    7965 #line 1933 "parser.yy"
     7963#line 1927 "parser.yy"
    79667964    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    79677965    break;
     
    79707968
    79717969/* Line 1806 of yacc.c  */
    7972 #line 1943 "parser.yy"
     7970#line 1937 "parser.yy"
    79737971    {
    79747972                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    79807978
    79817979/* Line 1806 of yacc.c  */
    7982 #line 1948 "parser.yy"
     7980#line 1942 "parser.yy"
    79837981    {
    79847982                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    79907988
    79917989/* Line 1806 of yacc.c  */
    7992 #line 1953 "parser.yy"
     7990#line 1947 "parser.yy"
    79937991    {
    79947992                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    80007998
    80017999/* Line 1806 of yacc.c  */
    8002 #line 1961 "parser.yy"
     8000#line 1955 "parser.yy"
    80038001    {
    80048002                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    80108008
    80118009/* Line 1806 of yacc.c  */
    8012 #line 1966 "parser.yy"
     8010#line 1960 "parser.yy"
    80138011    {
    80148012                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    80208018
    80218019/* Line 1806 of yacc.c  */
    8022 #line 1976 "parser.yy"
     8020#line 1970 "parser.yy"
    80238021    {}
    80248022    break;
     
    80278025
    80288026/* Line 1806 of yacc.c  */
    8029 #line 1978 "parser.yy"
     8027#line 1972 "parser.yy"
    80308028    {
    80318029                        if ( theTree ) {
     
    80408038
    80418039/* Line 1806 of yacc.c  */
    8042 #line 1990 "parser.yy"
     8040#line 1984 "parser.yy"
    80438041    { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    80448042    break;
     
    80478045
    80488046/* Line 1806 of yacc.c  */
    8049 #line 1995 "parser.yy"
     8047#line 1989 "parser.yy"
    80508048    { (yyval.decl) = 0; }
    80518049    break;
     
    80548052
    80558053/* Line 1806 of yacc.c  */
    8056 #line 2003 "parser.yy"
     8054#line 1997 "parser.yy"
    80578055    {}
    80588056    break;
     
    80618059
    80628060/* Line 1806 of yacc.c  */
    8063 #line 2005 "parser.yy"
     8061#line 1999 "parser.yy"
    80648062    {
    80658063                        linkageStack.push( linkage );
     
    80718069
    80728070/* Line 1806 of yacc.c  */
    8073 #line 2010 "parser.yy"
     8071#line 2004 "parser.yy"
    80748072    {
    80758073                        linkage = linkageStack.top();
     
    80828080
    80838081/* Line 1806 of yacc.c  */
    8084 #line 2016 "parser.yy"
     8082#line 2010 "parser.yy"
    80858083    {   // mark all fields in list
    80868084                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    80938091
    80948092/* Line 1806 of yacc.c  */
    8095 #line 2031 "parser.yy"
     8093#line 2025 "parser.yy"
    80968094    {
    80978095                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81048102
    81058103/* Line 1806 of yacc.c  */
    8106 #line 2037 "parser.yy"
     8104#line 2031 "parser.yy"
    81078105    {
    81088106                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81158113
    81168114/* Line 1806 of yacc.c  */
    8117 #line 2046 "parser.yy"
     8115#line 2040 "parser.yy"
    81188116    {
    81198117                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81268124
    81278125/* Line 1806 of yacc.c  */
    8128 #line 2052 "parser.yy"
     8126#line 2046 "parser.yy"
    81298127    {
    81308128                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81358133
    81368134  case 537:
     8135
     8136/* Line 1806 of yacc.c  */
     8137#line 2052 "parser.yy"
     8138    {
     8139                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     8140                        typedefTable.leaveScope();
     8141                        (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) );
     8142                }
     8143    break;
     8144
     8145  case 538:
    81378146
    81388147/* Line 1806 of yacc.c  */
     
    81458154    break;
    81468155
    8147   case 538:
     8156  case 539:
    81488157
    81498158/* Line 1806 of yacc.c  */
    81508159#line 2064 "parser.yy"
    8151     {
    8152                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    8153                         typedefTable.leaveScope();
    8154                         (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) );
    8155                 }
    8156     break;
    8157 
    8158   case 539:
    8159 
    8160 /* Line 1806 of yacc.c  */
    8161 #line 2070 "parser.yy"
    81628160    {
    81638161                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81708168
    81718169/* Line 1806 of yacc.c  */
    8172 #line 2078 "parser.yy"
     8170#line 2072 "parser.yy"
    81738171    {
    81748172                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81818179
    81828180/* Line 1806 of yacc.c  */
    8183 #line 2084 "parser.yy"
     8181#line 2078 "parser.yy"
    81848182    {
    81858183                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81928190
    81938191/* Line 1806 of yacc.c  */
    8194 #line 2092 "parser.yy"
     8192#line 2086 "parser.yy"
    81958193    {
    81968194                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    82038201
    82048202/* Line 1806 of yacc.c  */
    8205 #line 2098 "parser.yy"
     8203#line 2092 "parser.yy"
    82068204    {
    82078205                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    82148212
    82158213/* Line 1806 of yacc.c  */
    8216 #line 2113 "parser.yy"
    8217     { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Range, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     8214#line 2107 "parser.yy"
     8215    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    82188216    break;
    82198217
     
    82218219
    82228220/* Line 1806 of yacc.c  */
    8223 #line 2123 "parser.yy"
     8221#line 2117 "parser.yy"
    82248222    { (yyval.decl) = 0; }
    82258223    break;
     
    82288226
    82298227/* Line 1806 of yacc.c  */
     8228#line 2124 "parser.yy"
     8229    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     8230    break;
     8231
     8232  case 554:
     8233
     8234/* Line 1806 of yacc.c  */
    82308235#line 2130 "parser.yy"
    8231     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    8232     break;
    8233 
    8234   case 554:
    8235 
    8236 /* Line 1806 of yacc.c  */
    8237 #line 2136 "parser.yy"
    82388236    { (yyval.decl) = 0; }
    82398237    break;
     
    82428240
    82438241/* Line 1806 of yacc.c  */
    8244 #line 2151 "parser.yy"
     8242#line 2145 "parser.yy"
    82458243    {}
    82468244    break;
     
    82498247
    82508248/* Line 1806 of yacc.c  */
    8251 #line 2152 "parser.yy"
     8249#line 2146 "parser.yy"
    82528250    {}
    82538251    break;
     
    82568254
    82578255/* Line 1806 of yacc.c  */
    8258 #line 2153 "parser.yy"
     8256#line 2147 "parser.yy"
    82598257    {}
    82608258    break;
     
    82638261
    82648262/* Line 1806 of yacc.c  */
    8265 #line 2154 "parser.yy"
     8263#line 2148 "parser.yy"
    82668264    {}
    82678265    break;
     
    82708268
    82718269/* Line 1806 of yacc.c  */
    8272 #line 2189 "parser.yy"
     8270#line 2183 "parser.yy"
    82738271    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82748272    break;
     
    82778275
    82788276/* Line 1806 of yacc.c  */
    8279 #line 2192 "parser.yy"
     8277#line 2186 "parser.yy"
    82808278    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82818279    break;
     
    82848282
    82858283/* Line 1806 of yacc.c  */
    8286 #line 2194 "parser.yy"
     8284#line 2188 "parser.yy"
    82878285    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82888286    break;
     
    82918289
    82928290/* Line 1806 of yacc.c  */
    8293 #line 2199 "parser.yy"
     8291#line 2193 "parser.yy"
    82948292    {
    82958293                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    83018299
    83028300/* Line 1806 of yacc.c  */
    8303 #line 2204 "parser.yy"
     8301#line 2198 "parser.yy"
    83048302    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83058303    break;
     
    83088306
    83098307/* Line 1806 of yacc.c  */
    8310 #line 2209 "parser.yy"
     8308#line 2203 "parser.yy"
    83118309    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    83128310    break;
     
    83158313
    83168314/* Line 1806 of yacc.c  */
    8317 #line 2211 "parser.yy"
     8315#line 2205 "parser.yy"
    83188316    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    83198317    break;
     
    83228320
    83238321/* Line 1806 of yacc.c  */
    8324 #line 2213 "parser.yy"
     8322#line 2207 "parser.yy"
    83258323    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83268324    break;
     
    83298327
    83308328/* Line 1806 of yacc.c  */
     8329#line 2212 "parser.yy"
     8330    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8331    break;
     8332
     8333  case 574:
     8334
     8335/* Line 1806 of yacc.c  */
     8336#line 2214 "parser.yy"
     8337    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8338    break;
     8339
     8340  case 575:
     8341
     8342/* Line 1806 of yacc.c  */
     8343#line 2216 "parser.yy"
     8344    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8345    break;
     8346
     8347  case 576:
     8348
     8349/* Line 1806 of yacc.c  */
    83318350#line 2218 "parser.yy"
     8351    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8352    break;
     8353
     8354  case 577:
     8355
     8356/* Line 1806 of yacc.c  */
     8357#line 2223 "parser.yy"
     8358    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8359    break;
     8360
     8361  case 578:
     8362
     8363/* Line 1806 of yacc.c  */
     8364#line 2225 "parser.yy"
     8365    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8366    break;
     8367
     8368  case 579:
     8369
     8370/* Line 1806 of yacc.c  */
     8371#line 2234 "parser.yy"
     8372    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8373    break;
     8374
     8375  case 581:
     8376
     8377/* Line 1806 of yacc.c  */
     8378#line 2237 "parser.yy"
     8379    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8380    break;
     8381
     8382  case 582:
     8383
     8384/* Line 1806 of yacc.c  */
     8385#line 2242 "parser.yy"
     8386    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8387    break;
     8388
     8389  case 583:
     8390
     8391/* Line 1806 of yacc.c  */
     8392#line 2244 "parser.yy"
     8393    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8394    break;
     8395
     8396  case 584:
     8397
     8398/* Line 1806 of yacc.c  */
     8399#line 2246 "parser.yy"
     8400    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8401    break;
     8402
     8403  case 585:
     8404
     8405/* Line 1806 of yacc.c  */
     8406#line 2251 "parser.yy"
     8407    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8408    break;
     8409
     8410  case 586:
     8411
     8412/* Line 1806 of yacc.c  */
     8413#line 2253 "parser.yy"
     8414    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8415    break;
     8416
     8417  case 587:
     8418
     8419/* Line 1806 of yacc.c  */
     8420#line 2255 "parser.yy"
     8421    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8422    break;
     8423
     8424  case 588:
     8425
     8426/* Line 1806 of yacc.c  */
     8427#line 2260 "parser.yy"
     8428    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8429    break;
     8430
     8431  case 589:
     8432
     8433/* Line 1806 of yacc.c  */
     8434#line 2262 "parser.yy"
     8435    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8436    break;
     8437
     8438  case 590:
     8439
     8440/* Line 1806 of yacc.c  */
     8441#line 2264 "parser.yy"
     8442    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8443    break;
     8444
     8445  case 594:
     8446
     8447/* Line 1806 of yacc.c  */
     8448#line 2279 "parser.yy"
     8449    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
     8450    break;
     8451
     8452  case 595:
     8453
     8454/* Line 1806 of yacc.c  */
     8455#line 2281 "parser.yy"
     8456    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
     8457    break;
     8458
     8459  case 596:
     8460
     8461/* Line 1806 of yacc.c  */
     8462#line 2283 "parser.yy"
     8463    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8464    break;
     8465
     8466  case 597:
     8467
     8468/* Line 1806 of yacc.c  */
     8469#line 2288 "parser.yy"
     8470    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8471    break;
     8472
     8473  case 598:
     8474
     8475/* Line 1806 of yacc.c  */
     8476#line 2290 "parser.yy"
     8477    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8478    break;
     8479
     8480  case 599:
     8481
     8482/* Line 1806 of yacc.c  */
     8483#line 2292 "parser.yy"
     8484    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8485    break;
     8486
     8487  case 600:
     8488
     8489/* Line 1806 of yacc.c  */
     8490#line 2297 "parser.yy"
     8491    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8492    break;
     8493
     8494  case 601:
     8495
     8496/* Line 1806 of yacc.c  */
     8497#line 2299 "parser.yy"
     8498    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8499    break;
     8500
     8501  case 602:
     8502
     8503/* Line 1806 of yacc.c  */
     8504#line 2301 "parser.yy"
     8505    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8506    break;
     8507
     8508  case 603:
     8509
     8510/* Line 1806 of yacc.c  */
     8511#line 2316 "parser.yy"
     8512    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8513    break;
     8514
     8515  case 605:
     8516
     8517/* Line 1806 of yacc.c  */
     8518#line 2319 "parser.yy"
     8519    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8520    break;
     8521
     8522  case 606:
     8523
     8524/* Line 1806 of yacc.c  */
     8525#line 2321 "parser.yy"
     8526    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8527    break;
     8528
     8529  case 608:
     8530
     8531/* Line 1806 of yacc.c  */
     8532#line 2327 "parser.yy"
     8533    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8534    break;
     8535
     8536  case 609:
     8537
     8538/* Line 1806 of yacc.c  */
     8539#line 2332 "parser.yy"
     8540    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8541    break;
     8542
     8543  case 610:
     8544
     8545/* Line 1806 of yacc.c  */
     8546#line 2334 "parser.yy"
     8547    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8548    break;
     8549
     8550  case 611:
     8551
     8552/* Line 1806 of yacc.c  */
     8553#line 2336 "parser.yy"
     8554    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8555    break;
     8556
     8557  case 612:
     8558
     8559/* Line 1806 of yacc.c  */
     8560#line 2341 "parser.yy"
    83328561    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    83338562    break;
    83348563
    8335   case 574:
    8336 
    8337 /* Line 1806 of yacc.c  */
    8338 #line 2220 "parser.yy"
     8564  case 613:
     8565
     8566/* Line 1806 of yacc.c  */
     8567#line 2343 "parser.yy"
    83398568    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83408569    break;
    83418570
    8342   case 575:
    8343 
    8344 /* Line 1806 of yacc.c  */
    8345 #line 2222 "parser.yy"
     8571  case 614:
     8572
     8573/* Line 1806 of yacc.c  */
     8574#line 2345 "parser.yy"
    83468575    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83478576    break;
    83488577
    8349   case 576:
    8350 
    8351 /* Line 1806 of yacc.c  */
    8352 #line 2224 "parser.yy"
     8578  case 615:
     8579
     8580/* Line 1806 of yacc.c  */
     8581#line 2347 "parser.yy"
    83538582    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83548583    break;
    83558584
    8356   case 577:
    8357 
    8358 /* Line 1806 of yacc.c  */
    8359 #line 2229 "parser.yy"
     8585  case 616:
     8586
     8587/* Line 1806 of yacc.c  */
     8588#line 2352 "parser.yy"
     8589    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8590    break;
     8591
     8592  case 617:
     8593
     8594/* Line 1806 of yacc.c  */
     8595#line 2354 "parser.yy"
    83608596    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83618597    break;
    83628598
    8363   case 578:
    8364 
    8365 /* Line 1806 of yacc.c  */
    8366 #line 2231 "parser.yy"
     8599  case 618:
     8600
     8601/* Line 1806 of yacc.c  */
     8602#line 2356 "parser.yy"
    83678603    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83688604    break;
    83698605
    8370   case 579:
    8371 
    8372 /* Line 1806 of yacc.c  */
    8373 #line 2240 "parser.yy"
     8606  case 619:
     8607
     8608/* Line 1806 of yacc.c  */
     8609#line 2366 "parser.yy"
    83748610    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83758611    break;
    83768612
    8377   case 581:
    8378 
    8379 /* Line 1806 of yacc.c  */
    8380 #line 2243 "parser.yy"
     8613  case 621:
     8614
     8615/* Line 1806 of yacc.c  */
     8616#line 2369 "parser.yy"
    83818617    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83828618    break;
    83838619
    8384   case 582:
    8385 
    8386 /* Line 1806 of yacc.c  */
    8387 #line 2248 "parser.yy"
     8620  case 622:
     8621
     8622/* Line 1806 of yacc.c  */
     8623#line 2371 "parser.yy"
     8624    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8625    break;
     8626
     8627  case 623:
     8628
     8629/* Line 1806 of yacc.c  */
     8630#line 2376 "parser.yy"
     8631    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8632    break;
     8633
     8634  case 624:
     8635
     8636/* Line 1806 of yacc.c  */
     8637#line 2378 "parser.yy"
     8638    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8639    break;
     8640
     8641  case 625:
     8642
     8643/* Line 1806 of yacc.c  */
     8644#line 2380 "parser.yy"
     8645    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8646    break;
     8647
     8648  case 626:
     8649
     8650/* Line 1806 of yacc.c  */
     8651#line 2385 "parser.yy"
     8652    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8653    break;
     8654
     8655  case 627:
     8656
     8657/* Line 1806 of yacc.c  */
     8658#line 2387 "parser.yy"
     8659    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8660    break;
     8661
     8662  case 628:
     8663
     8664/* Line 1806 of yacc.c  */
     8665#line 2389 "parser.yy"
     8666    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8667    break;
     8668
     8669  case 629:
     8670
     8671/* Line 1806 of yacc.c  */
     8672#line 2391 "parser.yy"
     8673    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8674    break;
     8675
     8676  case 630:
     8677
     8678/* Line 1806 of yacc.c  */
     8679#line 2396 "parser.yy"
    83888680    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    83898681    break;
    83908682
    8391   case 583:
    8392 
    8393 /* Line 1806 of yacc.c  */
    8394 #line 2250 "parser.yy"
     8683  case 631:
     8684
     8685/* Line 1806 of yacc.c  */
     8686#line 2398 "parser.yy"
    83958687    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83968688    break;
    83978689
    8398   case 584:
    8399 
    8400 /* Line 1806 of yacc.c  */
    8401 #line 2252 "parser.yy"
     8690  case 632:
     8691
     8692/* Line 1806 of yacc.c  */
     8693#line 2400 "parser.yy"
    84028694    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84038695    break;
    84048696
    8405   case 585:
    8406 
    8407 /* Line 1806 of yacc.c  */
    8408 #line 2257 "parser.yy"
    8409     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8410     break;
    8411 
    8412   case 586:
    8413 
    8414 /* Line 1806 of yacc.c  */
    8415 #line 2259 "parser.yy"
    8416     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8417     break;
    8418 
    8419   case 587:
    8420 
    8421 /* Line 1806 of yacc.c  */
    8422 #line 2261 "parser.yy"
    8423     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8424     break;
    8425 
    8426   case 588:
    8427 
    8428 /* Line 1806 of yacc.c  */
    8429 #line 2266 "parser.yy"
    8430     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8431     break;
    8432 
    8433   case 589:
    8434 
    8435 /* Line 1806 of yacc.c  */
    8436 #line 2268 "parser.yy"
    8437     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8438     break;
    8439 
    8440   case 590:
    8441 
    8442 /* Line 1806 of yacc.c  */
    8443 #line 2270 "parser.yy"
    8444     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8445     break;
    8446 
    8447   case 594:
    8448 
    8449 /* Line 1806 of yacc.c  */
    8450 #line 2285 "parser.yy"
    8451     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    8452     break;
    8453 
    8454   case 595:
    8455 
    8456 /* Line 1806 of yacc.c  */
    8457 #line 2287 "parser.yy"
    8458     { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    8459     break;
    8460 
    8461   case 596:
    8462 
    8463 /* Line 1806 of yacc.c  */
    8464 #line 2289 "parser.yy"
    8465     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8466     break;
    8467 
    8468   case 597:
    8469 
    8470 /* Line 1806 of yacc.c  */
    8471 #line 2294 "parser.yy"
    8472     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8473     break;
    8474 
    8475   case 598:
    8476 
    8477 /* Line 1806 of yacc.c  */
    8478 #line 2296 "parser.yy"
    8479     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8480     break;
    8481 
    8482   case 599:
    8483 
    8484 /* Line 1806 of yacc.c  */
    8485 #line 2298 "parser.yy"
    8486     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8487     break;
    8488 
    8489   case 600:
    8490 
    8491 /* Line 1806 of yacc.c  */
    8492 #line 2303 "parser.yy"
    8493     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8494     break;
    8495 
    8496   case 601:
    8497 
    8498 /* Line 1806 of yacc.c  */
    8499 #line 2305 "parser.yy"
    8500     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8501     break;
    8502 
    8503   case 602:
    8504 
    8505 /* Line 1806 of yacc.c  */
    8506 #line 2307 "parser.yy"
    8507     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8508     break;
    8509 
    8510   case 603:
    8511 
    8512 /* Line 1806 of yacc.c  */
    8513 #line 2322 "parser.yy"
     8697  case 633:
     8698
     8699/* Line 1806 of yacc.c  */
     8700#line 2431 "parser.yy"
    85148701    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85158702    break;
    85168703
    8517   case 605:
    8518 
    8519 /* Line 1806 of yacc.c  */
    8520 #line 2325 "parser.yy"
     8704  case 635:
     8705
     8706/* Line 1806 of yacc.c  */
     8707#line 2434 "parser.yy"
    85218708    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85228709    break;
    85238710
    8524   case 606:
    8525 
    8526 /* Line 1806 of yacc.c  */
    8527 #line 2327 "parser.yy"
     8711  case 636:
     8712
     8713/* Line 1806 of yacc.c  */
     8714#line 2436 "parser.yy"
    85288715    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85298716    break;
    85308717
    8531   case 608:
    8532 
    8533 /* Line 1806 of yacc.c  */
    8534 #line 2333 "parser.yy"
    8535     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8536     break;
    8537 
    8538   case 609:
    8539 
    8540 /* Line 1806 of yacc.c  */
    8541 #line 2338 "parser.yy"
    8542     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8543     break;
    8544 
    8545   case 610:
    8546 
    8547 /* Line 1806 of yacc.c  */
    8548 #line 2340 "parser.yy"
    8549     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8550     break;
    8551 
    8552   case 611:
    8553 
    8554 /* Line 1806 of yacc.c  */
    8555 #line 2342 "parser.yy"
    8556     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8557     break;
    8558 
    8559   case 612:
    8560 
    8561 /* Line 1806 of yacc.c  */
    8562 #line 2347 "parser.yy"
    8563     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8564     break;
    8565 
    8566   case 613:
    8567 
    8568 /* Line 1806 of yacc.c  */
    8569 #line 2349 "parser.yy"
    8570     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8571     break;
    8572 
    8573   case 614:
    8574 
    8575 /* Line 1806 of yacc.c  */
    8576 #line 2351 "parser.yy"
    8577     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8578     break;
    8579 
    8580   case 615:
    8581 
    8582 /* Line 1806 of yacc.c  */
    8583 #line 2353 "parser.yy"
    8584     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8585     break;
    8586 
    8587   case 616:
    8588 
    8589 /* Line 1806 of yacc.c  */
    8590 #line 2358 "parser.yy"
    8591     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8592     break;
    8593 
    8594   case 617:
    8595 
    8596 /* Line 1806 of yacc.c  */
    8597 #line 2360 "parser.yy"
    8598     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8599     break;
    8600 
    8601   case 618:
    8602 
    8603 /* Line 1806 of yacc.c  */
    8604 #line 2362 "parser.yy"
    8605     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8606     break;
    8607 
    8608   case 619:
    8609 
    8610 /* Line 1806 of yacc.c  */
    8611 #line 2372 "parser.yy"
    8612     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8613     break;
    8614 
    8615   case 621:
    8616 
    8617 /* Line 1806 of yacc.c  */
    8618 #line 2375 "parser.yy"
    8619     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8620     break;
    8621 
    8622   case 622:
    8623 
    8624 /* Line 1806 of yacc.c  */
    8625 #line 2377 "parser.yy"
    8626     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8627     break;
    8628 
    8629   case 623:
    8630 
    8631 /* Line 1806 of yacc.c  */
    8632 #line 2382 "parser.yy"
    8633     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8634     break;
    8635 
    8636   case 624:
    8637 
    8638 /* Line 1806 of yacc.c  */
    8639 #line 2384 "parser.yy"
    8640     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8641     break;
    8642 
    8643   case 625:
    8644 
    8645 /* Line 1806 of yacc.c  */
    8646 #line 2386 "parser.yy"
    8647     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8648     break;
    8649 
    8650   case 626:
    8651 
    8652 /* Line 1806 of yacc.c  */
    8653 #line 2391 "parser.yy"
    8654     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8655     break;
    8656 
    8657   case 627:
    8658 
    8659 /* Line 1806 of yacc.c  */
    8660 #line 2393 "parser.yy"
    8661     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8662     break;
    8663 
    8664   case 628:
    8665 
    8666 /* Line 1806 of yacc.c  */
    8667 #line 2395 "parser.yy"
    8668     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8669     break;
    8670 
    8671   case 629:
    8672 
    8673 /* Line 1806 of yacc.c  */
    8674 #line 2397 "parser.yy"
    8675     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8676     break;
    8677 
    8678   case 630:
    8679 
    8680 /* Line 1806 of yacc.c  */
    8681 #line 2402 "parser.yy"
    8682     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8683     break;
    8684 
    8685   case 631:
    8686 
    8687 /* Line 1806 of yacc.c  */
    8688 #line 2404 "parser.yy"
    8689     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8690     break;
    8691 
    8692   case 632:
    8693 
    8694 /* Line 1806 of yacc.c  */
    8695 #line 2406 "parser.yy"
    8696     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8697     break;
    8698 
    8699   case 633:
    8700 
    8701 /* Line 1806 of yacc.c  */
    8702 #line 2437 "parser.yy"
    8703     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8704     break;
    8705 
    8706   case 635:
    8707 
    8708 /* Line 1806 of yacc.c  */
    8709 #line 2440 "parser.yy"
    8710     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8711     break;
    8712 
    8713   case 636:
    8714 
    8715 /* Line 1806 of yacc.c  */
    8716 #line 2442 "parser.yy"
    8717     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8718     break;
    8719 
    87208718  case 637:
    87218719
    87228720/* Line 1806 of yacc.c  */
    8723 #line 2447 "parser.yy"
     8721#line 2441 "parser.yy"
    87248722    {
    87258723                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    87318729
    87328730/* Line 1806 of yacc.c  */
    8733 #line 2452 "parser.yy"
     8731#line 2446 "parser.yy"
    87348732    {
    87358733                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    87418739
    87428740/* Line 1806 of yacc.c  */
    8743 #line 2460 "parser.yy"
     8741#line 2454 "parser.yy"
    87448742    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    87458743    break;
     
    87488746
    87498747/* Line 1806 of yacc.c  */
    8750 #line 2462 "parser.yy"
     8748#line 2456 "parser.yy"
    87518749    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    87528750    break;
     
    87558753
    87568754/* Line 1806 of yacc.c  */
    8757 #line 2464 "parser.yy"
     8755#line 2458 "parser.yy"
    87588756    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87598757    break;
     
    87628760
    87638761/* Line 1806 of yacc.c  */
    8764 #line 2469 "parser.yy"
     8762#line 2463 "parser.yy"
    87658763    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    87668764    break;
     
    87698767
    87708768/* Line 1806 of yacc.c  */
    8771 #line 2471 "parser.yy"
     8769#line 2465 "parser.yy"
    87728770    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87738771    break;
     
    87768774
    87778775/* Line 1806 of yacc.c  */
    8778 #line 2476 "parser.yy"
     8776#line 2470 "parser.yy"
    87798777    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    87808778    break;
     
    87838781
    87848782/* Line 1806 of yacc.c  */
    8785 #line 2478 "parser.yy"
     8783#line 2472 "parser.yy"
    87868784    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87878785    break;
     
    87908788
    87918789/* Line 1806 of yacc.c  */
    8792 #line 2493 "parser.yy"
     8790#line 2487 "parser.yy"
    87938791    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87948792    break;
     
    87978795
    87988796/* Line 1806 of yacc.c  */
    8799 #line 2495 "parser.yy"
     8797#line 2489 "parser.yy"
    88008798    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    88018799    break;
     
    88048802
    88058803/* Line 1806 of yacc.c  */
     8804#line 2494 "parser.yy"
     8805    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     8806    break;
     8807
     8808  case 650:
     8809
     8810/* Line 1806 of yacc.c  */
     8811#line 2496 "parser.yy"
     8812    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     8813    break;
     8814
     8815  case 651:
     8816
     8817/* Line 1806 of yacc.c  */
     8818#line 2498 "parser.yy"
     8819    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8820    break;
     8821
     8822  case 652:
     8823
     8824/* Line 1806 of yacc.c  */
    88068825#line 2500 "parser.yy"
     8826    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8827    break;
     8828
     8829  case 653:
     8830
     8831/* Line 1806 of yacc.c  */
     8832#line 2502 "parser.yy"
     8833    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8834    break;
     8835
     8836  case 655:
     8837
     8838/* Line 1806 of yacc.c  */
     8839#line 2508 "parser.yy"
     8840    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8841    break;
     8842
     8843  case 656:
     8844
     8845/* Line 1806 of yacc.c  */
     8846#line 2510 "parser.yy"
     8847    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8848    break;
     8849
     8850  case 657:
     8851
     8852/* Line 1806 of yacc.c  */
     8853#line 2512 "parser.yy"
     8854    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8855    break;
     8856
     8857  case 658:
     8858
     8859/* Line 1806 of yacc.c  */
     8860#line 2517 "parser.yy"
     8861    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
     8862    break;
     8863
     8864  case 659:
     8865
     8866/* Line 1806 of yacc.c  */
     8867#line 2519 "parser.yy"
     8868    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8869    break;
     8870
     8871  case 660:
     8872
     8873/* Line 1806 of yacc.c  */
     8874#line 2521 "parser.yy"
     8875    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8876    break;
     8877
     8878  case 661:
     8879
     8880/* Line 1806 of yacc.c  */
     8881#line 2527 "parser.yy"
     8882    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     8883    break;
     8884
     8885  case 662:
     8886
     8887/* Line 1806 of yacc.c  */
     8888#line 2529 "parser.yy"
     8889    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
     8890    break;
     8891
     8892  case 664:
     8893
     8894/* Line 1806 of yacc.c  */
     8895#line 2535 "parser.yy"
     8896    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
     8897    break;
     8898
     8899  case 665:
     8900
     8901/* Line 1806 of yacc.c  */
     8902#line 2537 "parser.yy"
     8903    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
     8904    break;
     8905
     8906  case 666:
     8907
     8908/* Line 1806 of yacc.c  */
     8909#line 2539 "parser.yy"
     8910    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
     8911    break;
     8912
     8913  case 667:
     8914
     8915/* Line 1806 of yacc.c  */
     8916#line 2541 "parser.yy"
     8917    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
     8918    break;
     8919
     8920  case 669:
     8921
     8922/* Line 1806 of yacc.c  */
     8923#line 2556 "parser.yy"
     8924    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8925    break;
     8926
     8927  case 670:
     8928
     8929/* Line 1806 of yacc.c  */
     8930#line 2558 "parser.yy"
     8931    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8932    break;
     8933
     8934  case 671:
     8935
     8936/* Line 1806 of yacc.c  */
     8937#line 2563 "parser.yy"
    88078938    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    88088939    break;
    88098940
    8810   case 650:
    8811 
    8812 /* Line 1806 of yacc.c  */
    8813 #line 2502 "parser.yy"
     8941  case 672:
     8942
     8943/* Line 1806 of yacc.c  */
     8944#line 2565 "parser.yy"
    88148945    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    88158946    break;
    88168947
    8817   case 651:
    8818 
    8819 /* Line 1806 of yacc.c  */
    8820 #line 2504 "parser.yy"
     8948  case 673:
     8949
     8950/* Line 1806 of yacc.c  */
     8951#line 2567 "parser.yy"
    88218952    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    88228953    break;
    88238954
    8824   case 652:
    8825 
    8826 /* Line 1806 of yacc.c  */
    8827 #line 2506 "parser.yy"
     8955  case 674:
     8956
     8957/* Line 1806 of yacc.c  */
     8958#line 2569 "parser.yy"
    88288959    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    88298960    break;
    88308961
    8831   case 653:
    8832 
    8833 /* Line 1806 of yacc.c  */
    8834 #line 2508 "parser.yy"
     8962  case 675:
     8963
     8964/* Line 1806 of yacc.c  */
     8965#line 2571 "parser.yy"
    88358966    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88368967    break;
    88378968
    8838   case 655:
    8839 
    8840 /* Line 1806 of yacc.c  */
    8841 #line 2514 "parser.yy"
     8969  case 677:
     8970
     8971/* Line 1806 of yacc.c  */
     8972#line 2577 "parser.yy"
    88428973    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    88438974    break;
    88448975
    8845   case 656:
    8846 
    8847 /* Line 1806 of yacc.c  */
    8848 #line 2516 "parser.yy"
     8976  case 678:
     8977
     8978/* Line 1806 of yacc.c  */
     8979#line 2579 "parser.yy"
    88498980    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    88508981    break;
    88518982
    8852   case 657:
    8853 
    8854 /* Line 1806 of yacc.c  */
    8855 #line 2518 "parser.yy"
     8983  case 679:
     8984
     8985/* Line 1806 of yacc.c  */
     8986#line 2581 "parser.yy"
    88568987    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88578988    break;
    88588989
    8859   case 658:
    8860 
    8861 /* Line 1806 of yacc.c  */
    8862 #line 2523 "parser.yy"
     8990  case 680:
     8991
     8992/* Line 1806 of yacc.c  */
     8993#line 2586 "parser.yy"
    88638994    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    88648995    break;
    88658996
    8866   case 659:
    8867 
    8868 /* Line 1806 of yacc.c  */
    8869 #line 2525 "parser.yy"
     8997  case 681:
     8998
     8999/* Line 1806 of yacc.c  */
     9000#line 2588 "parser.yy"
    88709001    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    88719002    break;
    88729003
    8873   case 660:
    8874 
    8875 /* Line 1806 of yacc.c  */
    8876 #line 2527 "parser.yy"
     9004  case 682:
     9005
     9006/* Line 1806 of yacc.c  */
     9007#line 2590 "parser.yy"
    88779008    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88789009    break;
    88799010
    8880   case 661:
    8881 
    8882 /* Line 1806 of yacc.c  */
    8883 #line 2533 "parser.yy"
     9011  case 684:
     9012
     9013/* Line 1806 of yacc.c  */
     9014#line 2597 "parser.yy"
     9015    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     9016    break;
     9017
     9018  case 686:
     9019
     9020/* Line 1806 of yacc.c  */
     9021#line 2608 "parser.yy"
    88849022    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    88859023    break;
    88869024
    8887   case 662:
    8888 
    8889 /* Line 1806 of yacc.c  */
    8890 #line 2535 "parser.yy"
    8891     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    8892     break;
    8893 
    8894   case 664:
    8895 
    8896 /* Line 1806 of yacc.c  */
    8897 #line 2541 "parser.yy"
    8898     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    8899     break;
    8900 
    8901   case 665:
    8902 
    8903 /* Line 1806 of yacc.c  */
    8904 #line 2543 "parser.yy"
    8905     { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    8906     break;
    8907 
    8908   case 666:
    8909 
    8910 /* Line 1806 of yacc.c  */
    8911 #line 2545 "parser.yy"
    8912     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    8913     break;
    8914 
    8915   case 667:
    8916 
    8917 /* Line 1806 of yacc.c  */
    8918 #line 2547 "parser.yy"
    8919     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    8920     break;
    8921 
    8922   case 669:
    8923 
    8924 /* Line 1806 of yacc.c  */
    8925 #line 2562 "parser.yy"
     9025  case 687:
     9026
     9027/* Line 1806 of yacc.c  */
     9028#line 2611 "parser.yy"
     9029    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     9030    break;
     9031
     9032  case 688:
     9033
     9034/* Line 1806 of yacc.c  */
     9035#line 2613 "parser.yy"
     9036    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
     9037    break;
     9038
     9039  case 689:
     9040
     9041/* Line 1806 of yacc.c  */
     9042#line 2616 "parser.yy"
     9043    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
     9044    break;
     9045
     9046  case 690:
     9047
     9048/* Line 1806 of yacc.c  */
     9049#line 2618 "parser.yy"
     9050    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
     9051    break;
     9052
     9053  case 691:
     9054
     9055/* Line 1806 of yacc.c  */
     9056#line 2620 "parser.yy"
     9057    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
     9058    break;
     9059
     9060  case 693:
     9061
     9062/* Line 1806 of yacc.c  */
     9063#line 2634 "parser.yy"
    89269064    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    89279065    break;
    89289066
    8929   case 670:
    8930 
    8931 /* Line 1806 of yacc.c  */
    8932 #line 2564 "parser.yy"
     9067  case 694:
     9068
     9069/* Line 1806 of yacc.c  */
     9070#line 2636 "parser.yy"
    89339071    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    89349072    break;
    89359073
    8936   case 671:
    8937 
    8938 /* Line 1806 of yacc.c  */
    8939 #line 2569 "parser.yy"
     9074  case 695:
     9075
     9076/* Line 1806 of yacc.c  */
     9077#line 2641 "parser.yy"
    89409078    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    89419079    break;
    89429080
    8943   case 672:
    8944 
    8945 /* Line 1806 of yacc.c  */
    8946 #line 2571 "parser.yy"
     9081  case 696:
     9082
     9083/* Line 1806 of yacc.c  */
     9084#line 2643 "parser.yy"
    89479085    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    89489086    break;
    89499087
    8950   case 673:
    8951 
    8952 /* Line 1806 of yacc.c  */
    8953 #line 2573 "parser.yy"
     9088  case 697:
     9089
     9090/* Line 1806 of yacc.c  */
     9091#line 2645 "parser.yy"
    89549092    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    89559093    break;
    89569094
    8957   case 674:
    8958 
    8959 /* Line 1806 of yacc.c  */
    8960 #line 2575 "parser.yy"
     9095  case 698:
     9096
     9097/* Line 1806 of yacc.c  */
     9098#line 2647 "parser.yy"
    89619099    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    89629100    break;
    89639101
    8964   case 675:
    8965 
    8966 /* Line 1806 of yacc.c  */
    8967 #line 2577 "parser.yy"
     9102  case 699:
     9103
     9104/* Line 1806 of yacc.c  */
     9105#line 2649 "parser.yy"
    89689106    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89699107    break;
    89709108
    8971   case 677:
    8972 
    8973 /* Line 1806 of yacc.c  */
    8974 #line 2583 "parser.yy"
     9109  case 701:
     9110
     9111/* Line 1806 of yacc.c  */
     9112#line 2655 "parser.yy"
    89759113    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    89769114    break;
    89779115
    8978   case 678:
    8979 
    8980 /* Line 1806 of yacc.c  */
    8981 #line 2585 "parser.yy"
     9116  case 702:
     9117
     9118/* Line 1806 of yacc.c  */
     9119#line 2657 "parser.yy"
    89829120    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    89839121    break;
    89849122
    8985   case 679:
    8986 
    8987 /* Line 1806 of yacc.c  */
    8988 #line 2587 "parser.yy"
     9123  case 703:
     9124
     9125/* Line 1806 of yacc.c  */
     9126#line 2659 "parser.yy"
    89899127    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89909128    break;
    89919129
    8992   case 680:
    8993 
    8994 /* Line 1806 of yacc.c  */
    8995 #line 2592 "parser.yy"
    8996     { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    8997     break;
    8998 
    8999   case 681:
    9000 
    9001 /* Line 1806 of yacc.c  */
    9002 #line 2594 "parser.yy"
     9130  case 704:
     9131
     9132/* Line 1806 of yacc.c  */
     9133#line 2664 "parser.yy"
    90039134    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    90049135    break;
    90059136
    9006   case 682:
    9007 
    9008 /* Line 1806 of yacc.c  */
    9009 #line 2596 "parser.yy"
     9137  case 705:
     9138
     9139/* Line 1806 of yacc.c  */
     9140#line 2666 "parser.yy"
    90109141    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    90119142    break;
    90129143
    9013   case 684:
    9014 
    9015 /* Line 1806 of yacc.c  */
    9016 #line 2603 "parser.yy"
    9017     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    9018     break;
    9019 
    9020   case 686:
    9021 
    9022 /* Line 1806 of yacc.c  */
    9023 #line 2614 "parser.yy"
    9024     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    9025     break;
    9026 
    9027   case 687:
    9028 
    9029 /* Line 1806 of yacc.c  */
    9030 #line 2617 "parser.yy"
    9031     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    9032     break;
    9033 
    9034   case 688:
    9035 
    9036 /* Line 1806 of yacc.c  */
    9037 #line 2619 "parser.yy"
    9038     { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    9039     break;
    9040 
    9041   case 689:
    9042 
    9043 /* Line 1806 of yacc.c  */
    9044 #line 2622 "parser.yy"
    9045     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    9046     break;
    9047 
    9048   case 690:
    9049 
    9050 /* Line 1806 of yacc.c  */
    9051 #line 2624 "parser.yy"
    9052     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    9053     break;
    9054 
    9055   case 691:
    9056 
    9057 /* Line 1806 of yacc.c  */
    9058 #line 2626 "parser.yy"
    9059     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    9060     break;
    9061 
    9062   case 693:
    9063 
    9064 /* Line 1806 of yacc.c  */
    9065 #line 2640 "parser.yy"
    9066     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    9067     break;
    9068 
    9069   case 694:
    9070 
    9071 /* Line 1806 of yacc.c  */
    9072 #line 2642 "parser.yy"
    9073     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    9074     break;
    9075 
    9076   case 695:
    9077 
    9078 /* Line 1806 of yacc.c  */
    9079 #line 2647 "parser.yy"
    9080     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    9081     break;
    9082 
    9083   case 696:
    9084 
    9085 /* Line 1806 of yacc.c  */
    9086 #line 2649 "parser.yy"
    9087     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    9088     break;
    9089 
    9090   case 697:
    9091 
    9092 /* Line 1806 of yacc.c  */
    9093 #line 2651 "parser.yy"
    9094     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    9095     break;
    9096 
    9097   case 698:
    9098 
    9099 /* Line 1806 of yacc.c  */
    9100 #line 2653 "parser.yy"
    9101     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    9102     break;
    9103 
    9104   case 699:
    9105 
    9106 /* Line 1806 of yacc.c  */
    9107 #line 2655 "parser.yy"
    9108     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    9109     break;
    9110 
    9111   case 701:
    9112 
    9113 /* Line 1806 of yacc.c  */
    9114 #line 2661 "parser.yy"
    9115     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    9116     break;
    9117 
    9118   case 702:
    9119 
    9120 /* Line 1806 of yacc.c  */
    9121 #line 2663 "parser.yy"
    9122     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    9123     break;
    9124 
    9125   case 703:
    9126 
    9127 /* Line 1806 of yacc.c  */
    9128 #line 2665 "parser.yy"
    9129     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    9130     break;
    9131 
    9132   case 704:
    9133 
    9134 /* Line 1806 of yacc.c  */
    9135 #line 2670 "parser.yy"
    9136     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    9137     break;
    9138 
    9139   case 705:
    9140 
    9141 /* Line 1806 of yacc.c  */
    9142 #line 2672 "parser.yy"
    9143     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    9144     break;
    9145 
    91469144  case 708:
    91479145
    91489146/* Line 1806 of yacc.c  */
    9149 #line 2682 "parser.yy"
     9147#line 2676 "parser.yy"
    91509148    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    91519149    break;
     
    91549152
    91559153/* Line 1806 of yacc.c  */
     9154#line 2686 "parser.yy"
     9155    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9156    break;
     9157
     9158  case 712:
     9159
     9160/* Line 1806 of yacc.c  */
     9161#line 2688 "parser.yy"
     9162    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9163    break;
     9164
     9165  case 713:
     9166
     9167/* Line 1806 of yacc.c  */
     9168#line 2690 "parser.yy"
     9169    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9170    break;
     9171
     9172  case 714:
     9173
     9174/* Line 1806 of yacc.c  */
    91569175#line 2692 "parser.yy"
     9176    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9177    break;
     9178
     9179  case 715:
     9180
     9181/* Line 1806 of yacc.c  */
     9182#line 2694 "parser.yy"
    91579183    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91589184    break;
    91599185
    9160   case 712:
    9161 
    9162 /* Line 1806 of yacc.c  */
    9163 #line 2694 "parser.yy"
     9186  case 716:
     9187
     9188/* Line 1806 of yacc.c  */
     9189#line 2696 "parser.yy"
    91649190    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91659191    break;
    91669192
    9167   case 713:
    9168 
    9169 /* Line 1806 of yacc.c  */
    9170 #line 2696 "parser.yy"
    9171     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9172     break;
    9173 
    9174   case 714:
    9175 
    9176 /* Line 1806 of yacc.c  */
    9177 #line 2698 "parser.yy"
    9178     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9179     break;
    9180 
    9181   case 715:
    9182 
    9183 /* Line 1806 of yacc.c  */
    9184 #line 2700 "parser.yy"
    9185     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9186     break;
    9187 
    9188   case 716:
    9189 
    9190 /* Line 1806 of yacc.c  */
    9191 #line 2702 "parser.yy"
    9192     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9193     break;
    9194 
    91959193  case 717:
    91969194
    91979195/* Line 1806 of yacc.c  */
     9196#line 2703 "parser.yy"
     9197    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9198    break;
     9199
     9200  case 718:
     9201
     9202/* Line 1806 of yacc.c  */
     9203#line 2705 "parser.yy"
     9204    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     9205    break;
     9206
     9207  case 719:
     9208
     9209/* Line 1806 of yacc.c  */
     9210#line 2707 "parser.yy"
     9211    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9212    break;
     9213
     9214  case 720:
     9215
     9216/* Line 1806 of yacc.c  */
    91989217#line 2709 "parser.yy"
    9199     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9200     break;
    9201 
    9202   case 718:
     9218    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     9219    break;
     9220
     9221  case 721:
    92039222
    92049223/* Line 1806 of yacc.c  */
     
    92079226    break;
    92089227
    9209   case 719:
     9228  case 722:
    92109229
    92119230/* Line 1806 of yacc.c  */
    92129231#line 2713 "parser.yy"
     9232    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9233    break;
     9234
     9235  case 723:
     9236
     9237/* Line 1806 of yacc.c  */
     9238#line 2715 "parser.yy"
     9239    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     9240    break;
     9241
     9242  case 724:
     9243
     9244/* Line 1806 of yacc.c  */
     9245#line 2717 "parser.yy"
    92139246    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    92149247    break;
    92159248
    9216   case 720:
    9217 
    9218 /* Line 1806 of yacc.c  */
    9219 #line 2715 "parser.yy"
     9249  case 725:
     9250
     9251/* Line 1806 of yacc.c  */
     9252#line 2719 "parser.yy"
    92209253    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    92219254    break;
    92229255
    9223   case 721:
    9224 
    9225 /* Line 1806 of yacc.c  */
    9226 #line 2717 "parser.yy"
    9227     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    9228     break;
    9229 
    9230   case 722:
    9231 
    9232 /* Line 1806 of yacc.c  */
    9233 #line 2719 "parser.yy"
    9234     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9235     break;
    9236 
    9237   case 723:
     9256  case 726:
    92389257
    92399258/* Line 1806 of yacc.c  */
     
    92429261    break;
    92439262
    9244   case 724:
    9245 
    9246 /* Line 1806 of yacc.c  */
    9247 #line 2723 "parser.yy"
     9263  case 727:
     9264
     9265/* Line 1806 of yacc.c  */
     9266#line 2726 "parser.yy"
     9267    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     9268    break;
     9269
     9270  case 728:
     9271
     9272/* Line 1806 of yacc.c  */
     9273#line 2728 "parser.yy"
     9274    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
     9275    break;
     9276
     9277  case 729:
     9278
     9279/* Line 1806 of yacc.c  */
     9280#line 2733 "parser.yy"
     9281    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
     9282    break;
     9283
     9284  case 730:
     9285
     9286/* Line 1806 of yacc.c  */
     9287#line 2735 "parser.yy"
     9288    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
     9289    break;
     9290
     9291  case 732:
     9292
     9293/* Line 1806 of yacc.c  */
     9294#line 2762 "parser.yy"
     9295    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     9296    break;
     9297
     9298  case 736:
     9299
     9300/* Line 1806 of yacc.c  */
     9301#line 2773 "parser.yy"
     9302    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9303    break;
     9304
     9305  case 737:
     9306
     9307/* Line 1806 of yacc.c  */
     9308#line 2775 "parser.yy"
     9309    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9310    break;
     9311
     9312  case 738:
     9313
     9314/* Line 1806 of yacc.c  */
     9315#line 2777 "parser.yy"
     9316    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9317    break;
     9318
     9319  case 739:
     9320
     9321/* Line 1806 of yacc.c  */
     9322#line 2779 "parser.yy"
     9323    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9324    break;
     9325
     9326  case 740:
     9327
     9328/* Line 1806 of yacc.c  */
     9329#line 2781 "parser.yy"
     9330    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9331    break;
     9332
     9333  case 741:
     9334
     9335/* Line 1806 of yacc.c  */
     9336#line 2783 "parser.yy"
     9337    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9338    break;
     9339
     9340  case 742:
     9341
     9342/* Line 1806 of yacc.c  */
     9343#line 2790 "parser.yy"
     9344    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9345    break;
     9346
     9347  case 743:
     9348
     9349/* Line 1806 of yacc.c  */
     9350#line 2792 "parser.yy"
    92489351    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    92499352    break;
    92509353
    9251   case 725:
    9252 
    9253 /* Line 1806 of yacc.c  */
    9254 #line 2725 "parser.yy"
    9255     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    9256     break;
    9257 
    9258   case 726:
    9259 
    9260 /* Line 1806 of yacc.c  */
    9261 #line 2727 "parser.yy"
     9354  case 744:
     9355
     9356/* Line 1806 of yacc.c  */
     9357#line 2794 "parser.yy"
    92629358    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    92639359    break;
    92649360
    9265   case 727:
    9266 
    9267 /* Line 1806 of yacc.c  */
    9268 #line 2732 "parser.yy"
    9269     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    9270     break;
    9271 
    9272   case 728:
    9273 
    9274 /* Line 1806 of yacc.c  */
    9275 #line 2734 "parser.yy"
    9276     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    9277     break;
    9278 
    9279   case 729:
    9280 
    9281 /* Line 1806 of yacc.c  */
    9282 #line 2739 "parser.yy"
    9283     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
    9284     break;
    9285 
    9286   case 730:
    9287 
    9288 /* Line 1806 of yacc.c  */
    9289 #line 2741 "parser.yy"
    9290     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
    9291     break;
    9292 
    9293   case 732:
    9294 
    9295 /* Line 1806 of yacc.c  */
    9296 #line 2768 "parser.yy"
    9297     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    9298     break;
    9299 
    9300   case 736:
    9301 
    9302 /* Line 1806 of yacc.c  */
    9303 #line 2779 "parser.yy"
    9304     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9305     break;
    9306 
    9307   case 737:
    9308 
    9309 /* Line 1806 of yacc.c  */
    9310 #line 2781 "parser.yy"
    9311     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9312     break;
    9313 
    9314   case 738:
    9315 
    9316 /* Line 1806 of yacc.c  */
    9317 #line 2783 "parser.yy"
    9318     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9319     break;
    9320 
    9321   case 739:
    9322 
    9323 /* Line 1806 of yacc.c  */
    9324 #line 2785 "parser.yy"
    9325     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9326     break;
    9327 
    9328   case 740:
    9329 
    9330 /* Line 1806 of yacc.c  */
    9331 #line 2787 "parser.yy"
    9332     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9333     break;
    9334 
    9335   case 741:
    9336 
    9337 /* Line 1806 of yacc.c  */
    9338 #line 2789 "parser.yy"
    9339     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9340     break;
    9341 
    9342   case 742:
     9361  case 745:
    93439362
    93449363/* Line 1806 of yacc.c  */
     
    93479366    break;
    93489367
    9349   case 743:
     9368  case 746:
    93509369
    93519370/* Line 1806 of yacc.c  */
     
    93549373    break;
    93559374
    9356   case 744:
     9375  case 747:
    93579376
    93589377/* Line 1806 of yacc.c  */
     
    93619380    break;
    93629381
    9363   case 745:
    9364 
    9365 /* Line 1806 of yacc.c  */
    9366 #line 2802 "parser.yy"
    9367     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9368     break;
    9369 
    9370   case 746:
    9371 
    9372 /* Line 1806 of yacc.c  */
    9373 #line 2804 "parser.yy"
    9374     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9375     break;
    9376 
    9377   case 747:
    9378 
    9379 /* Line 1806 of yacc.c  */
    9380 #line 2806 "parser.yy"
    9381     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    9382     break;
    9383 
    93849382  case 748:
    93859383
    93869384/* Line 1806 of yacc.c  */
    9387 #line 2811 "parser.yy"
     9385#line 2805 "parser.yy"
    93889386    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    93899387    break;
     
    93929390
    93939391/* Line 1806 of yacc.c  */
    9394 #line 2816 "parser.yy"
     9392#line 2810 "parser.yy"
    93959393    { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); }
    93969394    break;
     
    93999397
    94009398/* Line 1806 of yacc.c  */
    9401 #line 2818 "parser.yy"
     9399#line 2812 "parser.yy"
    94029400    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    94039401    break;
     
    94069404
    94079405/* Line 1806 of yacc.c  */
    9408 #line 2820 "parser.yy"
     9406#line 2814 "parser.yy"
    94099407    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    94109408    break;
     
    94139411
    94149412/* Line 1806 of yacc.c  */
    9415 #line 2844 "parser.yy"
     9413#line 2838 "parser.yy"
    94169414    { (yyval.en) = 0; }
    94179415    break;
     
    94209418
    94219419/* Line 1806 of yacc.c  */
    9422 #line 2846 "parser.yy"
     9420#line 2840 "parser.yy"
    94239421    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    94249422    break;
     
    94279425
    94289426/* Line 1806 of yacc.c  */
    9429 #line 9430 "Parser/parser.cc"
     9427#line 9428 "Parser/parser.cc"
    94309428      default: break;
    94319429    }
     
    96589656
    96599657/* Line 2067 of yacc.c  */
    9660 #line 2849 "parser.yy"
     9658#line 2843 "parser.yy"
    96619659
    96629660// ----end of grammar----
  • src/Parser/parser.h

    r1b0020a r4e2a1137  
    274274        LabelNode *label;
    275275        InitializerNode *in;
    276         OperatorNode::Type op;
    277276        bool flag;
    278277
     
    280279
    281280/* Line 2068 of yacc.c  */
    282 #line 283 "Parser/parser.h"
     281#line 282 "Parser/parser.h"
    283282} YYSTYPE;
    284283# define YYSTYPE_IS_TRIVIAL 1
  • src/Parser/parser.yy

    r1b0020a r4e2a1137  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 08:15:57 2016
    13 // Update Count     : 1721
     12// Last Modified On : Thu Aug  4 11:28:18 2016
     13// Update Count     : 1672
    1414//
    1515
     
    119119        LabelNode *label;
    120120        InitializerNode *in;
    121         OperatorNode::Type op;
    122121        bool flag;
    123122}
     
    130129%type<constant> constant
    131130%type<en> tuple                                                 tuple_expression_list
    132 %type<op> ptrref_operator
    133 %type<en> unary_operator                                assignment_operator
     131%type<en> ptrref_operator                               unary_operator                          assignment_operator
    134132%type<en> primary_expression                    postfix_expression                      unary_expression
    135133%type<en> cast_expression                               multiplicative_expression       additive_expression                     shift_expression
     
    356354                // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
    357355                // equivalent to the old x[i,j].
    358                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Index, $1, $4 ) ); }
     356                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Index ), $1, $4 ); }
    359357        | postfix_expression '(' argument_expression_list ')'
    360358                { $$ = new CompositeExprNode( $1, $3 ); }
     
    362360                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
    363361        | postfix_expression '.' no_attr_identifier
    364                 { $$ = new CompositeExprNode2( build_fieldSel( $1, new VarRefNode( $3 ) ) ); }
     362                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), $1, new VarRefNode( $3 )); }
    365363        | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
    366364        | postfix_expression ARROW no_attr_identifier
    367                 { $$ = new CompositeExprNode2( build_pfieldSel( $1, new VarRefNode( $3 ) ) ); }
     365                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), $1, new VarRefNode( $3 )); }
    368366        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
    369367        | postfix_expression ICR
    370                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::IncrPost, $1 ) ); }
     368                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::IncrPost ), $1 ); }
    371369        | postfix_expression DECR
    372                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::DecrPost, $1 ) ); }
     370                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), $1 ); }
    373371        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
    374372                { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); }
     
    412410                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
    413411        | no_attr_identifier '.' field
    414                 { $$ = new CompositeExprNode2( build_fieldSel( $3, new VarRefNode( $1 ) ) ); }
     412                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( $1 ), $3 ); }
    415413        | no_attr_identifier '.' '[' push field_list pop ']'
    416                 { $$ = new CompositeExprNode2( build_fieldSel( $5, new VarRefNode( $1 ) ) ); }
     414                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( $1 ), $5 ); }
    417415        | no_attr_identifier ARROW field
    418                 { $$ = new CompositeExprNode2( build_pfieldSel( $3, new VarRefNode( $1 ) ) ); }
     416                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( $1 ), $3 ); }
    419417        | no_attr_identifier ARROW '[' push field_list pop ']'
    420                 { $$ = new CompositeExprNode2( build_pfieldSel( $5, new VarRefNode( $1 ) ) ); }
     418                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( $1 ), $5 ); }
    421419        ;
    422420
     
    431429        | EXTENSION cast_expression                                                     // GCC
    432430                { $$ = $2->set_extension( true ); }
     431        | ptrref_operator cast_expression                                       // CFA
     432                { $$ = new CompositeExprNode( $1, $2 ); }
    433433                // '*' ('&') is separated from unary_operator because of shift/reduce conflict in:
    434434                //              { * X; }         // dereference X
    435435                //              { * int X; } // CFA declaration of pointer to int
    436         | ptrref_operator cast_expression                                       // CFA
    437                 { $$ = $1 == OperatorNode::AddressOf ? (ExpressionNode*) new CompositeExprNode2( build_addressOf( $2 ) )
    438                                                                                         : (ExpressionNode*)new CompositeExprNode( new OperatorNode ( $1 ), $2 ); }
    439436        | unary_operator cast_expression
    440437                { $$ = new CompositeExprNode( $1, $2 ); }
    441438        | ICR unary_expression
    442                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::Incr, $2 ) ); }
     439                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Incr ), $2 ); }
    443440        | DECR unary_expression
    444                 { $$ = new CompositeExprNode2( build_opr1( OperatorNode::Decr, $2 ) ); }
     441                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Decr ), $2 ); }
    445442        | SIZEOF unary_expression
    446                 { $$ = new CompositeExprNode2( build_sizeOf( $2 ) ); }
     443                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), $2 ); }
    447444        | SIZEOF '(' type_name_no_function ')'
    448                 { $$ = new CompositeExprNode2( build_sizeOf( new TypeValueNode( $3 ) ) ); }
     445                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), new TypeValueNode( $3 )); }
    449446        | OFFSETOF '(' type_name_no_function ',' no_attr_identifier ')'
    450                 { $$ = new CompositeExprNode2( build_offsetOf( new TypeValueNode( $3 ), new VarRefNode( $5 ) ) ); }
     447                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::OffsetOf ), new TypeValueNode( $3 ), new VarRefNode( $5 )); }
    451448        | ATTR_IDENTIFIER
    452                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ) ); }
     449                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 )); }
    453450        | ATTR_IDENTIFIER '(' type_name ')'
    454                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), new TypeValueNode( $3 ) ); }
     451                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), new TypeValueNode( $3 )); }
    455452        | ATTR_IDENTIFIER '(' argument_expression ')'
    456453                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), $3 ); }
    457454        | ALIGNOF unary_expression                                                      // GCC, variable alignment
    458                 { $$ = new CompositeExprNode2( build_alignOf( $2 ) ); }
     455                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), $2 ); }
    459456        | ALIGNOF '(' type_name_no_function ')'                         // GCC, type alignment
    460                 { $$ = new CompositeExprNode2( build_alignOf( new TypeValueNode( $3 ) ) ); }
     457                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), new TypeValueNode( $3 ) ); }
    461458//      | ANDAND IDENTIFIER                                                                     // GCC, address of label
    462459//              { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true ) ); }
     
    464461
    465462ptrref_operator:
    466         '*'                                                                                     { $$ = OperatorNode::PointTo; }
    467         | '&'                                                                           { $$ = OperatorNode::AddressOf; }
     463        '*'                                                                                     { $$ = new OperatorNode( OperatorNode::PointTo ); }
     464        | '&'                                                                           { $$ = new OperatorNode( OperatorNode::AddressOf ); }
    468465                // GCC, address of label must be handled by semantic check for ref,ref,label
    469         | ANDAND                                                                        { $$ = OperatorNode::And; }
     466        | ANDAND                                                                        { $$ = new OperatorNode( OperatorNode::And ); }
    470467        ;
    471468
     
    480477        unary_expression
    481478        | '(' type_name_no_function ')' cast_expression
    482                 { $$ = new CompositeExprNode2( build_cast( new TypeValueNode( $2 ), $4 ) ); }
     479                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( $2 ), $4 ); }
    483480        | '(' type_name_no_function ')' tuple
    484                 { $$ = new CompositeExprNode2( build_cast( new TypeValueNode( $2 ), $4 ) ); }
     481                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( $2 ), $4 ); }
    485482        ;
    486483
     
    488485        cast_expression
    489486        | multiplicative_expression '*' cast_expression
    490                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Mul, $1, $3 ) ); }
     487                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Mul ), $1, $3 ); }
    491488        | multiplicative_expression '/' cast_expression
    492                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Div, $1, $3 ) ); }
     489                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Div ), $1, $3 ); }
    493490        | multiplicative_expression '%' cast_expression
    494                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Mod, $1, $3 ) ); }
     491                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Mod ), $1, $3 ); }
    495492        ;
    496493
     
    498495        multiplicative_expression
    499496        | additive_expression '+' multiplicative_expression
    500                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Plus, $1, $3 ) ); }
     497                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Plus ), $1, $3 ); }
    501498        | additive_expression '-' multiplicative_expression
    502                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Minus, $1, $3 ) ); }
     499                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Minus ), $1, $3 ); }
    503500        ;
    504501
     
    506503        additive_expression
    507504        | shift_expression LS additive_expression
    508                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LShift, $1, $3 ) ); }
     505                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LShift ), $1, $3 ); }
    509506        | shift_expression RS additive_expression
    510                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::RShift, $1, $3 ) ); }
     507                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::RShift ), $1, $3 ); }
    511508        ;
    512509
     
    514511        shift_expression
    515512        | relational_expression '<' shift_expression
    516                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LThan, $1, $3 ) ); }
     513                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LThan ), $1, $3 ); }
    517514        | relational_expression '>' shift_expression
    518                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::GThan, $1, $3 ) ); }
     515                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::GThan ), $1, $3 ); }
    519516        | relational_expression LE shift_expression
    520                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LEThan, $1, $3 ) ); }
     517                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LEThan ), $1, $3 ); }
    521518        | relational_expression GE shift_expression
    522                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::GEThan, $1, $3 ) ); }
     519                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::GEThan ), $1, $3 ); }
    523520        ;
    524521
     
    526523        relational_expression
    527524        | equality_expression EQ relational_expression
    528                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Eq, $1, $3 ) ); }
     525                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Eq ), $1, $3 ); }
    529526        | equality_expression NE relational_expression
    530                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Neq, $1, $3 ) ); }
     527                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Neq ), $1, $3 ); }
    531528        ;
    532529
     
    534531        equality_expression
    535532        | AND_expression '&' equality_expression
    536                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::BitAnd, $1, $3 ) ); }
     533                { $$ =new CompositeExprNode( new OperatorNode( OperatorNode::BitAnd ), $1, $3 ); }
    537534        ;
    538535
     
    540537        AND_expression
    541538        | exclusive_OR_expression '^' AND_expression
    542                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Xor, $1, $3 ) ); }
     539                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Xor ), $1, $3 ); }
    543540        ;
    544541
     
    546543        exclusive_OR_expression
    547544        | inclusive_OR_expression '|' exclusive_OR_expression
    548                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::BitOr, $1, $3 ) ); }
     545                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::BitOr ), $1, $3 ); }
    549546        ;
    550547
     
    552549        inclusive_OR_expression
    553550        | logical_AND_expression ANDAND inclusive_OR_expression
    554                 { $$ = new CompositeExprNode2( build_and_or( $1, $3, true ) ); }
     551                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::And ), $1, $3 ); }
    555552        ;
    556553
     
    558555        logical_AND_expression
    559556        | logical_OR_expression OROR logical_AND_expression
    560                 { $$ = new CompositeExprNode2( build_and_or( $1, $3, false ) ); }
     557                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Or ), $1, $3 ); }
    561558        ;
    562559
     
    564561        logical_OR_expression
    565562        | logical_OR_expression '?' comma_expression ':' conditional_expression
    566                 { $$ = new CompositeExprNode2( build_cond( $1, $3, $5 ) ); }
     563                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*$1, *$3, *$5 ) ) ); }
    567564        | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
    568                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), $1, $4 ); }
     565                { $$=new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), $1, $4 ); }
    569566        | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression
    570                 { $$ = new CompositeExprNode2( build_cond( $1, $3, $5 ) ); }
     567                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*$1, *$3, *$5 ) ) ); }
    571568        ;
    572569
     
    579576        conditional_expression
    580577        | unary_expression '=' assignment_expression
    581                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $3 ); }
     578                { $$ =new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $3 ); }
    582579        | unary_expression assignment_operator assignment_expression
    583                 { $$ = new CompositeExprNode( $2, $1, $3 ); }
     580                { $$ =new CompositeExprNode( $2, $1, $3 ); }
    584581        | tuple assignment_opt                                                          // CFA, tuple expression
    585582                { $$ = ( $2 == 0 ) ? $1 : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $2 ); }
     
    627624        assignment_expression
    628625        | comma_expression ',' assignment_expression    // { $$ = (ExpressionNode *)$1->add_to_list( $3 ); }
    629         //{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Comma ), $1, $3 ); }
    630                 { $$ = new CompositeExprNode2( build_comma( $1, $3 ) ); }
     626                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Comma ), $1, $3 ); }
    631627        ;
    632628
     
    740736        constant_expression                                                     { $$ = $1; }
    741737        | constant_expression ELLIPSIS constant_expression      // GCC, subrange
    742                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Range, $1, $3 ) ); }
     738                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), $1, $3 ); }
    743739        | subrange                                                                                      // CFA, subrange
    744740        ;
     
    746742case_value_list:                                                                                // CFA
    747743        case_value                                                                      { $$ = new StatementNode( StatementNode::Case, $1, 0 ); }
    748                 // convert case list, e.g., "case 1, 3, 5:" into "case 1: case 3: case 5"
    749744        | case_value_list ',' case_value                        { $$ = (StatementNode *)($1->set_link( new StatementNode( StatementNode::Case, $3, 0 ) ) ); }
    750745        ;
     
    17811776                { $$ = new DesignatorNode( $3, true ); }
    17821777        | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
    1783                 { $$ = new DesignatorNode( new CompositeExprNode2( build_opr2( OperatorNode::Range, $3, $5 ) ), true ); }
     1778                { $$ = new DesignatorNode( new CompositeExprNode( new OperatorNode( OperatorNode::Range ), $3, $5 ), true ); }
    17841779        | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
    17851780                { $$ = new DesignatorNode( $4 ); }
     
    21102105subrange:
    21112106        constant_expression '~' constant_expression                     // CFA, integer subrange
    2112                 { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Range, $1, $3 ) ); }
     2107                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), $1, $3 ); }
    21132108        ;
    21142109
Note: See TracChangeset for help on using the changeset viewer.