Changeset dae881f


Ignore:
Timestamp:
Aug 5, 2016, 9:25:34 AM (5 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
1b0020a
Parents:
658fafe4 (diff), 51e076e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:
src
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • src/CodeGen/CodeGenerator.cc

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

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

    r658fafe4 rdae881f  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug  2 15:10:23 2016
    13 // Update Count     : 322
     12// Last Modified On : Fri Aug  5 07:56:23 2016
     13// Update Count     : 375
    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 #include "Common/utility.h"
     313
     314Expression *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
     326Expression *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
     334Expression *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
     344Expression *build_addressOf( ExpressionNode *expr_node ) {
     345                return new AddressExpr( maybeBuild<Expression>(expr_node) );
     346}
     347Expression *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}
     354Expression *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}
     361Expression *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
     367Expression *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
     371Expression *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}
     376Expression *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
     383Expression *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
     387Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
     388        return new CommaExpr( maybeBuild<Expression>(expr_node1), maybeBuild<Expression>(expr_node2) );
     389}
     390
     391CompositeExprNode2::CompositeExprNode2( Expression *expr ) : expr( expr ) {}
     392CompositeExprNode2::CompositeExprNode2( const CompositeExprNode2 &other ) : expr( other.expr->clone() ) {}
     393CompositeExprNode2::~CompositeExprNode2() { delete expr; }
     394void CompositeExprNode2::print( std::ostream &, int indent ) const { assert( false ); }
     395void CompositeExprNode2::printOneLine( std::ostream &, int indent ) const { assert( false ); }
     396
    314397
    315398Expression *CompositeExprNode::build() const {
     
    323406        } // if
    324407
    325         switch ( op->get_type()) {
    326           case OperatorNode::Incr:
    327           case OperatorNode::Decr:
    328           case OperatorNode::IncrPost:
    329           case OperatorNode::DecrPost:
     408        switch ( op->get_type() ) {
    330409          case OperatorNode::Assign:
    331410          case OperatorNode::MulAssn:
     
    339418          case OperatorNode::ERAssn:
    340419          case OperatorNode::OrAssn:
    341                 // the rewrite rules for these expressions specify that the first argument has its address taken
    342420                assert( ! args.empty() );
    343421                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:
    383422          case OperatorNode::UnPlus:
    384423          case OperatorNode::UnMinus:
     
    388427          case OperatorNode::LabelAddress:
    389428                return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args );
    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                 }
     429
    472430          case OperatorNode::Attr:
    473431                {
    474                         VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
     432                        VarRefNode *var = dynamic_cast<VarRefNode *>( get_args() );
    475433                        assert( var );
    476434                        if ( ! get_args()->get_link() ) {
    477435                                return new AttrExpr( maybeBuild<Expression>(var), ( Expression*)0);
    478                         } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
    479                                 return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType());
     436                        } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link() ) ) {
     437                                return new AttrExpr( maybeBuild<Expression>(var), arg->get_decl()->buildType() );
    480438                        } else {
    481                                 return new AttrExpr( maybeBuild<Expression>(var), args.back());
     439                                return new AttrExpr( maybeBuild<Expression>(var), args.back() );
    482440                        } // if
    483441                }
    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 ) );
    488442          case OperatorNode::Cond:
    489443                {
     
    497451          case OperatorNode::NCond:
    498452                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                 }
    509453                // Tuples
    510454          case OperatorNode::TupleC:
     
    515459                }
    516460          default:
    517                 // shouldn't happen
    518                 assert( false );
     461                assert( ((void)"CompositeExprNode::build", false) );
    519462                return 0;
    520463        } // switch
     
    755698}
    756699
    757 
    758700ExpressionNode *flattenCommas( ExpressionNode *list ) {
    759701        if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {
  • src/Parser/ParseNode.h

    r658fafe4 rdae881f  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Jul 24 02:17:00 2016
    13 // Update Count     : 269
     12// Last Modified On : Fri Aug  5 07:49:32 2016
     13// Update Count     : 288
    1414//
    1515
     
    223223  private:
    224224        Type type;
     225};
     226
     227Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node );
     228Expression *build_fieldSel( ExpressionNode *expr_node, VarRefNode *member );
     229Expression *build_pfieldSel( ExpressionNode *expr_node, VarRefNode *member );
     230Expression *build_addressOf( ExpressionNode *expr_node );
     231Expression *build_sizeOf( ExpressionNode *expr_node );
     232Expression *build_alignOf( ExpressionNode *expr_node );
     233Expression *build_offsetOf( TypeValueNode * arg, VarRefNode *member );
     234Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     235Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
     236Expression *build_opr1( OperatorNode::Type op, ExpressionNode *expr_node );
     237Expression *build_opr2( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     238Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
     239Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     240
     241class 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;
    225254};
    226255
  • src/Parser/parser.cc

    r658fafe4 rdae881f  
    354354        LabelNode *label;
    355355        InitializerNode *in;
     356        OperatorNode::Type op;
    356357        bool flag;
    357358
     
    359360
    360361/* Line 293 of yacc.c  */
    361 #line 362 "Parser/parser.cc"
     362#line 363 "Parser/parser.cc"
    362363} YYSTYPE;
    363364# define YYSTYPE_IS_TRIVIAL 1
     
    371372
    372373/* Line 343 of yacc.c  */
    373 #line 374 "Parser/parser.cc"
     374#line 375 "Parser/parser.cc"
    374375
    375376#ifdef short
     
    10161017static const yytype_uint16 yyrline[] =
    10171018{
    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
     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
    10941095};
    10951096#endif
     
    52165217
    52175218/* Line 1806 of yacc.c  */
    5218 #line 290 "parser.yy"
     5219#line 292 "parser.yy"
    52195220    {
    52205221                        typedefTable.enterScope();
     
    52255226
    52265227/* Line 1806 of yacc.c  */
    5227 #line 296 "parser.yy"
     5228#line 298 "parser.yy"
    52285229    {
    52295230                        typedefTable.leaveScope();
     
    52345235
    52355236/* Line 1806 of yacc.c  */
    5236 #line 305 "parser.yy"
     5237#line 307 "parser.yy"
    52375238    { (yyval.constant) = makeConstantInteger( *(yyvsp[(1) - (1)].tok) ); }
    52385239    break;
     
    52415242
    52425243/* Line 1806 of yacc.c  */
    5243 #line 306 "parser.yy"
     5244#line 308 "parser.yy"
    52445245    { (yyval.constant) = makeConstantFloat( *(yyvsp[(1) - (1)].tok) ); }
    52455246    break;
     
    52485249
    52495250/* Line 1806 of yacc.c  */
    5250 #line 307 "parser.yy"
     5251#line 309 "parser.yy"
    52515252    { (yyval.constant) = makeConstantChar( *(yyvsp[(1) - (1)].tok) ); }
    52525253    break;
     
    52555256
    52565257/* Line 1806 of yacc.c  */
    5257 #line 332 "parser.yy"
     5258#line 334 "parser.yy"
    52585259    { (yyval.constant) = makeConstantStr( *(yyvsp[(1) - (1)].tok) ); }
    52595260    break;
     
    52625263
    52635264/* Line 1806 of yacc.c  */
    5264 #line 333 "parser.yy"
     5265#line 335 "parser.yy"
    52655266    { (yyval.constant) = (yyvsp[(1) - (2)].constant)->appendstr( (yyvsp[(2) - (2)].tok) ); }
    52665267    break;
    52675268
    52685269  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:
    52765270
    52775271/* Line 1806 of yacc.c  */
     
    52805274    break;
    52815275
     5276  case 19:
     5277
     5278/* Line 1806 of yacc.c  */
     5279#line 344 "parser.yy"
     5280    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
     5281    break;
     5282
    52825283  case 20:
    52835284
    52845285/* Line 1806 of yacc.c  */
    5285 #line 344 "parser.yy"
     5286#line 346 "parser.yy"
    52865287    { (yyval.en) = (yyvsp[(2) - (3)].en); }
    52875288    break;
     
    52905291
    52915292/* Line 1806 of yacc.c  */
    5292 #line 346 "parser.yy"
     5293#line 348 "parser.yy"
    52935294    { (yyval.en) = new ValofExprNode( (yyvsp[(2) - (3)].sn) ); }
    52945295    break;
     
    52975298
    52985299/* 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) ); }
     5300#line 358 "parser.yy"
     5301    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
    53015302    break;
    53025303
     
    53045305
    53055306/* Line 1806 of yacc.c  */
    5306 #line 358 "parser.yy"
     5307#line 360 "parser.yy"
    53075308    { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ); }
    53085309    break;
     
    53115312
    53125313/* Line 1806 of yacc.c  */
    5313 #line 362 "parser.yy"
    5314     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) )); }
     5314#line 364 "parser.yy"
     5315    { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
    53155316    break;
    53165317
     
    53185319
    53195320/* Line 1806 of yacc.c  */
    5320 #line 365 "parser.yy"
    5321     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) )); }
     5321#line 367 "parser.yy"
     5322    { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
    53225323    break;
    53235324
     
    53255326
    53265327/* Line 1806 of yacc.c  */
    5327 #line 368 "parser.yy"
    5328     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::IncrPost ), (yyvsp[(1) - (2)].en) ); }
     5328#line 370 "parser.yy"
     5329    { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
    53295330    break;
    53305331
     
    53325333
    53335334/* Line 1806 of yacc.c  */
    5334 #line 370 "parser.yy"
    5335     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), (yyvsp[(1) - (2)].en) ); }
     5335#line 372 "parser.yy"
     5336    { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
    53365337    break;
    53375338
     
    53395340
    53405341/* Line 1806 of yacc.c  */
    5341 #line 372 "parser.yy"
     5342#line 374 "parser.yy"
    53425343    { (yyval.en) = new CompoundLiteralNode( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ); }
    53435344    break;
     
    53465347
    53475348/* Line 1806 of yacc.c  */
    5348 #line 374 "parser.yy"
     5349#line 376 "parser.yy"
    53495350    {
    53505351                        Token fn; fn.str = new std::string( "?{}" ); // location undefined
     
    53565357
    53575358/* Line 1806 of yacc.c  */
    5358 #line 383 "parser.yy"
     5359#line 385 "parser.yy"
    53595360    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    53605361    break;
     
    53635364
    53645365/* Line 1806 of yacc.c  */
    5365 #line 388 "parser.yy"
     5366#line 390 "parser.yy"
    53665367    { (yyval.en) = 0; }
    53675368    break;
     
    53705371
    53715372/* Line 1806 of yacc.c  */
    5372 #line 391 "parser.yy"
     5373#line 393 "parser.yy"
    53735374    { (yyval.en) = (yyvsp[(3) - (3)].en)->set_argName( (yyvsp[(1) - (3)].tok) ); }
    53745375    break;
     
    53775378
    53785379/* Line 1806 of yacc.c  */
    5379 #line 396 "parser.yy"
     5380#line 398 "parser.yy"
    53805381    { (yyval.en) = (yyvsp[(7) - (7)].en)->set_argName( (yyvsp[(3) - (7)].en) ); }
    53815382    break;
     
    53845385
    53855386/* Line 1806 of yacc.c  */
    5386 #line 398 "parser.yy"
     5387#line 400 "parser.yy"
    53875388    { (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) )))); }
    53885389    break;
     
    53915392
    53925393/* Line 1806 of yacc.c  */
    5393 #line 403 "parser.yy"
     5394#line 405 "parser.yy"
    53945395    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    53955396    break;
     
    53985399
    53995400/* Line 1806 of yacc.c  */
    5400 #line 408 "parser.yy"
     5401#line 410 "parser.yy"
    54015402    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (1)].tok) ); }
    54025403    break;
     
    54055406
    54065407/* 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) ); }
     5408#line 414 "parser.yy"
     5409    { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
    54095410    break;
    54105411
     
    54125413
    54135414/* Line 1806 of yacc.c  */
    5414 #line 414 "parser.yy"
    5415     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::FieldSel ), new VarRefNode( (yyvsp[(1) - (7)].tok) ), (yyvsp[(5) - (7)].en) ); }
     5415#line 416 "parser.yy"
     5416    { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
    54165417    break;
    54175418
     
    54195420
    54205421/* Line 1806 of yacc.c  */
    5421 #line 416 "parser.yy"
    5422     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( (yyvsp[(1) - (3)].tok) ), (yyvsp[(3) - (3)].en) ); }
     5422#line 418 "parser.yy"
     5423    { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
    54235424    break;
    54245425
     
    54265427
    54275428/* Line 1806 of yacc.c  */
    5428 #line 418 "parser.yy"
    5429     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::PFieldSel ), new VarRefNode( (yyvsp[(1) - (7)].tok) ), (yyvsp[(5) - (7)].en) ); }
     5429#line 420 "parser.yy"
     5430    { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
    54305431    break;
    54315432
    54325433  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:
    54405434
    54415435/* Line 1806 of yacc.c  */
     
    54445438    break;
    54455439
     5440  case 49:
     5441
     5442/* Line 1806 of yacc.c  */
     5443#line 430 "parser.yy"
     5444    { (yyval.en) = (yyvsp[(1) - (1)].constant); }
     5445    break;
     5446
    54465447  case 50:
    54475448
    54485449/* Line 1806 of yacc.c  */
    5449 #line 430 "parser.yy"
     5450#line 432 "parser.yy"
    54505451    { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
    54515452    break;
     
    54545455
    54555456/* Line 1806 of yacc.c  */
    5456 #line 432 "parser.yy"
     5457#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"
    54575466    { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); }
    54585467    break;
    54595468
    5460   case 52:
    5461 
    5462 /* Line 1806 of yacc.c  */
    5463 #line 437 "parser.yy"
    5464     { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); }
    5465     break;
    5466 
    54675469  case 53:
    54685470
    54695471/* Line 1806 of yacc.c  */
    5470 #line 439 "parser.yy"
    5471     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Incr ), (yyvsp[(2) - (2)].en) ); }
     5472#line 442 "parser.yy"
     5473    { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::Incr, (yyvsp[(2) - (2)].en) ) ); }
    54725474    break;
    54735475
     
    54755477
    54765478/* Line 1806 of yacc.c  */
    5477 #line 441 "parser.yy"
    5478     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Decr ), (yyvsp[(2) - (2)].en) ); }
     5479#line 444 "parser.yy"
     5480    { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::Decr, (yyvsp[(2) - (2)].en) ) ); }
    54795481    break;
    54805482
     
    54825484
    54835485/* Line 1806 of yacc.c  */
    5484 #line 443 "parser.yy"
    5485     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), (yyvsp[(2) - (2)].en) ); }
     5486#line 446 "parser.yy"
     5487    { (yyval.en) = new CompositeExprNode2( build_sizeOf( (yyvsp[(2) - (2)].en) ) ); }
    54865488    break;
    54875489
     
    54895491
    54905492/* Line 1806 of yacc.c  */
    5491 #line 445 "parser.yy"
    5492     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::SizeOf ), new TypeValueNode( (yyvsp[(3) - (4)].decl) )); }
     5493#line 448 "parser.yy"
     5494    { (yyval.en) = new CompositeExprNode2( build_sizeOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    54935495    break;
    54945496
     
    54965498
    54975499/* Line 1806 of yacc.c  */
    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) )); }
     5500#line 450 "parser.yy"
     5501    { (yyval.en) = new CompositeExprNode2( build_offsetOf( new TypeValueNode( (yyvsp[(3) - (6)].decl) ), new VarRefNode( (yyvsp[(5) - (6)].tok) ) ) ); }
    55005502    break;
    55015503
     
    55035505
    55045506/* Line 1806 of yacc.c  */
    5505 #line 449 "parser.yy"
    5506     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (1)].tok) )); }
     5507#line 452 "parser.yy"
     5508    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); }
    55075509    break;
    55085510
     
    55105512
    55115513/* Line 1806 of yacc.c  */
    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) )); }
     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) ) ); }
    55145516    break;
    55155517
     
    55175519
    55185520/* Line 1806 of yacc.c  */
    5519 #line 453 "parser.yy"
     5521#line 456 "parser.yy"
    55205522    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ); }
    55215523    break;
     
    55245526
    55255527/* Line 1806 of yacc.c  */
    5526 #line 455 "parser.yy"
    5527     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), (yyvsp[(2) - (2)].en) ); }
     5528#line 458 "parser.yy"
     5529    { (yyval.en) = new CompositeExprNode2( build_alignOf( (yyvsp[(2) - (2)].en) ) ); }
    55285530    break;
    55295531
     
    55315533
    55325534/* Line 1806 of yacc.c  */
    5533 #line 457 "parser.yy"
    5534     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::AlignOf ), new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ); }
     5535#line 460 "parser.yy"
     5536    { (yyval.en) = new CompositeExprNode2( build_alignOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    55355537    break;
    55365538
     
    55385540
    55395541/* Line 1806 of yacc.c  */
    5540 #line 463 "parser.yy"
    5541     { (yyval.en) = new OperatorNode( OperatorNode::PointTo ); }
     5542#line 466 "parser.yy"
     5543    { (yyval.op) = OperatorNode::PointTo; }
    55425544    break;
    55435545
     
    55455547
    55465548/* Line 1806 of yacc.c  */
    5547 #line 464 "parser.yy"
    5548     { (yyval.en) = new OperatorNode( OperatorNode::AddressOf ); }
     5549#line 467 "parser.yy"
     5550    { (yyval.op) = OperatorNode::AddressOf; }
    55495551    break;
    55505552
     
    55525554
    55535555/* Line 1806 of yacc.c  */
    5554 #line 466 "parser.yy"
    5555     { (yyval.en) = new OperatorNode( OperatorNode::And ); }
     5556#line 469 "parser.yy"
     5557    { (yyval.op) = OperatorNode::And; }
    55565558    break;
    55575559
     
    55595561
    55605562/* Line 1806 of yacc.c  */
    5561 #line 470 "parser.yy"
     5563#line 473 "parser.yy"
    55625564    { (yyval.en) = new OperatorNode( OperatorNode::UnPlus ); }
    55635565    break;
     
    55665568
    55675569/* Line 1806 of yacc.c  */
    5568 #line 471 "parser.yy"
     5570#line 474 "parser.yy"
    55695571    { (yyval.en) = new OperatorNode( OperatorNode::UnMinus ); }
    55705572    break;
     
    55735575
    55745576/* Line 1806 of yacc.c  */
    5575 #line 472 "parser.yy"
     5577#line 475 "parser.yy"
    55765578    { (yyval.en) = new OperatorNode( OperatorNode::Neg ); }
    55775579    break;
     
    55805582
    55815583/* Line 1806 of yacc.c  */
    5582 #line 473 "parser.yy"
     5584#line 476 "parser.yy"
    55835585    { (yyval.en) = new OperatorNode( OperatorNode::BitNeg ); }
    55845586    break;
     
    55875589
    55885590/* Line 1806 of yacc.c  */
    5589 #line 479 "parser.yy"
    5590     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ); }
     5591#line 482 "parser.yy"
     5592    { (yyval.en) = new CompositeExprNode2( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
    55915593    break;
    55925594
     
    55945596
    55955597/* Line 1806 of yacc.c  */
    5596 #line 481 "parser.yy"
    5597     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cast ), new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ); }
     5598#line 484 "parser.yy"
     5599    { (yyval.en) = new CompositeExprNode2( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
    55985600    break;
    55995601
     
    56015603
    56025604/* Line 1806 of yacc.c  */
    5603 #line 487 "parser.yy"
    5604     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Mul ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5605#line 490 "parser.yy"
     5606    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56055607    break;
    56065608
     
    56085610
    56095611/* Line 1806 of yacc.c  */
    5610 #line 489 "parser.yy"
    5611     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Div ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5612#line 492 "parser.yy"
     5613    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56125614    break;
    56135615
     
    56155617
    56165618/* Line 1806 of yacc.c  */
    5617 #line 491 "parser.yy"
    5618     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Mod ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5619#line 494 "parser.yy"
     5620    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56195621    break;
    56205622
     
    56225624
    56235625/* Line 1806 of yacc.c  */
    5624 #line 497 "parser.yy"
    5625     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Plus ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5626#line 500 "parser.yy"
     5627    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56265628    break;
    56275629
     
    56295631
    56305632/* Line 1806 of yacc.c  */
    5631 #line 499 "parser.yy"
    5632     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Minus ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5633#line 502 "parser.yy"
     5634    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56335635    break;
    56345636
     
    56365638
    56375639/* Line 1806 of yacc.c  */
    5638 #line 505 "parser.yy"
    5639     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LShift ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5640#line 508 "parser.yy"
     5641    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56405642    break;
    56415643
     
    56435645
    56445646/* Line 1806 of yacc.c  */
    5645 #line 507 "parser.yy"
    5646     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::RShift ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5647#line 510 "parser.yy"
     5648    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56475649    break;
    56485650
     
    56505652
    56515653/* Line 1806 of yacc.c  */
    5652 #line 513 "parser.yy"
    5653     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5654#line 516 "parser.yy"
     5655    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56545656    break;
    56555657
     
    56575659
    56585660/* Line 1806 of yacc.c  */
    5659 #line 515 "parser.yy"
    5660     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::GThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5661#line 518 "parser.yy"
     5662    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56615663    break;
    56625664
     
    56645666
    56655667/* Line 1806 of yacc.c  */
    5666 #line 517 "parser.yy"
    5667     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::LEThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5668#line 520 "parser.yy"
     5669    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56685670    break;
    56695671
     
    56715673
    56725674/* Line 1806 of yacc.c  */
    5673 #line 519 "parser.yy"
    5674     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::GEThan ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5675#line 522 "parser.yy"
     5676    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56755677    break;
    56765678
     
    56785680
    56795681/* Line 1806 of yacc.c  */
    5680 #line 525 "parser.yy"
    5681     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Eq ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5682#line 528 "parser.yy"
     5683    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56825684    break;
    56835685
     
    56855687
    56865688/* Line 1806 of yacc.c  */
    5687 #line 527 "parser.yy"
    5688     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Neq ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5689#line 530 "parser.yy"
     5690    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56895691    break;
    56905692
     
    56925694
    56935695/* Line 1806 of yacc.c  */
    5694 #line 533 "parser.yy"
    5695     { (yyval.en) =new CompositeExprNode( new OperatorNode( OperatorNode::BitAnd ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5696#line 536 "parser.yy"
     5697    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56965698    break;
    56975699
     
    56995701
    57005702/* Line 1806 of yacc.c  */
    5701 #line 539 "parser.yy"
    5702     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Xor ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5703#line 542 "parser.yy"
     5704    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    57035705    break;
    57045706
     
    57065708
    57075709/* Line 1806 of yacc.c  */
    5708 #line 545 "parser.yy"
    5709     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::BitOr ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5710#line 548 "parser.yy"
     5711    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    57105712    break;
    57115713
     
    57135715
    57145716/* Line 1806 of yacc.c  */
    5715 #line 551 "parser.yy"
    5716     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::And ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5717#line 554 "parser.yy"
     5718    { (yyval.en) = new CompositeExprNode2( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
    57175719    break;
    57185720
     
    57205722
    57215723/* Line 1806 of yacc.c  */
    5722 #line 557 "parser.yy"
    5723     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Or ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     5724#line 560 "parser.yy"
     5725    { (yyval.en) = new CompositeExprNode2( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
    57245726    break;
    57255727
     
    57275729
    57285730/* 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#line 567 "parser.yy"
     5732    { (yyval.en) = new CompositeExprNode2( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    57315733    break;
    57325734
     
    57345736
    57355737/* 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#line 569 "parser.yy"
     5739    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    57385740    break;
    57395741
     
    57415743
    57425744/* Line 1806 of yacc.c  */
    5743 #line 567 "parser.yy"
    5744     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*(yyvsp[(1) - (5)].en), *(yyvsp[(3) - (5)].en), *(yyvsp[(5) - (5)].en) ) ) ); }
     5745#line 571 "parser.yy"
     5746    { (yyval.en) = new CompositeExprNode2( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    57455747    break;
    57465748
     
    57485750
    57495751/* 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#line 582 "parser.yy"
     5753    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    57525754    break;
    57535755
     
    57555757
    57565758/* 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#line 584 "parser.yy"
     5760    { (yyval.en) = new CompositeExprNode( (yyvsp[(2) - (3)].en), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
    57595761    break;
    57605762
     
    57625764
    57635765/* Line 1806 of yacc.c  */
    5764 #line 582 "parser.yy"
     5766#line 586 "parser.yy"
    57655767    { (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) ); }
    57665768    break;
     
    57695771
    57705772/* Line 1806 of yacc.c  */
    5771 #line 587 "parser.yy"
     5773#line 591 "parser.yy"
    57725774    { (yyval.en) = new NullExprNode; }
    57735775    break;
     
    57765778
    57775779/* Line 1806 of yacc.c  */
    5778 #line 595 "parser.yy"
     5780#line 599 "parser.yy"
    57795781    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
    57805782    break;
     
    57835785
    57845786/* Line 1806 of yacc.c  */
    5785 #line 597 "parser.yy"
     5787#line 601 "parser.yy"
    57865788    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (yyvsp[(3) - (5)].en) ); }
    57875789    break;
     
    57905792
    57915793/* Line 1806 of yacc.c  */
    5792 #line 599 "parser.yy"
     5794#line 603 "parser.yy"
    57935795    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ); }
    57945796    break;
     
    57975799
    57985800/* Line 1806 of yacc.c  */
    5799 #line 601 "parser.yy"
     5801#line 605 "parser.yy"
    58005802    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( flattenCommas( (yyvsp[(5) - (7)].en) ) ) ); }
    58015803    break;
     
    58045806
    58055807/* Line 1806 of yacc.c  */
    5806 #line 607 "parser.yy"
     5808#line 611 "parser.yy"
    58075809    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    58085810    break;
     
    58115813
    58125814/* Line 1806 of yacc.c  */
    5813 #line 611 "parser.yy"
     5815#line 615 "parser.yy"
    58145816    { (yyval.en) = new OperatorNode( OperatorNode::MulAssn ); }
    58155817    break;
     
    58185820
    58195821/* Line 1806 of yacc.c  */
    5820 #line 612 "parser.yy"
     5822#line 616 "parser.yy"
    58215823    { (yyval.en) = new OperatorNode( OperatorNode::DivAssn ); }
    58225824    break;
     
    58255827
    58265828/* Line 1806 of yacc.c  */
    5827 #line 613 "parser.yy"
     5829#line 617 "parser.yy"
    58285830    { (yyval.en) = new OperatorNode( OperatorNode::ModAssn ); }
    58295831    break;
     
    58325834
    58335835/* Line 1806 of yacc.c  */
    5834 #line 614 "parser.yy"
     5836#line 618 "parser.yy"
    58355837    { (yyval.en) = new OperatorNode( OperatorNode::PlusAssn ); }
    58365838    break;
     
    58395841
    58405842/* Line 1806 of yacc.c  */
    5841 #line 615 "parser.yy"
     5843#line 619 "parser.yy"
    58425844    { (yyval.en) = new OperatorNode( OperatorNode::MinusAssn ); }
    58435845    break;
     
    58465848
    58475849/* Line 1806 of yacc.c  */
    5848 #line 616 "parser.yy"
     5850#line 620 "parser.yy"
    58495851    { (yyval.en) = new OperatorNode( OperatorNode::LSAssn ); }
    58505852    break;
     
    58535855
    58545856/* Line 1806 of yacc.c  */
    5855 #line 617 "parser.yy"
     5857#line 621 "parser.yy"
    58565858    { (yyval.en) = new OperatorNode( OperatorNode::RSAssn ); }
    58575859    break;
     
    58605862
    58615863/* Line 1806 of yacc.c  */
    5862 #line 618 "parser.yy"
     5864#line 622 "parser.yy"
    58635865    { (yyval.en) = new OperatorNode( OperatorNode::AndAssn ); }
    58645866    break;
     
    58675869
    58685870/* Line 1806 of yacc.c  */
    5869 #line 619 "parser.yy"
     5871#line 623 "parser.yy"
    58705872    { (yyval.en) = new OperatorNode( OperatorNode::ERAssn ); }
    58715873    break;
     
    58745876
    58755877/* Line 1806 of yacc.c  */
    5876 #line 620 "parser.yy"
     5878#line 624 "parser.yy"
    58775879    { (yyval.en) = new OperatorNode( OperatorNode::OrAssn ); }
    58785880    break;
     
    58815883
    58825884/* 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#line 631 "parser.yy"
     5886    { (yyval.en) = new CompositeExprNode2( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    58855887    break;
    58865888
     
    58885890
    58895891/* Line 1806 of yacc.c  */
    5890 #line 631 "parser.yy"
     5892#line 636 "parser.yy"
    58915893    { (yyval.en) = 0; }
    58925894    break;
     
    58955897
    58965898/* Line 1806 of yacc.c  */
    5897 #line 640 "parser.yy"
     5899#line 645 "parser.yy"
    58985900    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    58995901    break;
     
    59025904
    59035905/* Line 1806 of yacc.c  */
    5904 #line 647 "parser.yy"
     5906#line 652 "parser.yy"
    59055907    {
    59065908                        Token fn; fn.str = new std::string( "^?{}" ); // location undefined
     
    59135915
    59145916/* Line 1806 of yacc.c  */
    5915 #line 657 "parser.yy"
     5917#line 662 "parser.yy"
    59165918    {
    59175919                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
     
    59225924
    59235925/* Line 1806 of yacc.c  */
    5924 #line 664 "parser.yy"
     5926#line 669 "parser.yy"
    59255927    { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
    59265928    break;
     
    59295931
    59305932/* Line 1806 of yacc.c  */
    5931 #line 671 "parser.yy"
     5933#line 676 "parser.yy"
    59325934    { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); }
    59335935    break;
     
    59365938
    59375939/* Line 1806 of yacc.c  */
    5938 #line 677 "parser.yy"
     5940#line 682 "parser.yy"
    59395941    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    59405942    break;
     
    59435945
    59445946/* Line 1806 of yacc.c  */
    5945 #line 682 "parser.yy"
     5947#line 687 "parser.yy"
    59465948    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    59475949    break;
     
    59505952
    59515953/* Line 1806 of yacc.c  */
    5952 #line 684 "parser.yy"
     5954#line 689 "parser.yy"
    59535955    {   // mark all fields in list
    59545956                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    59615963
    59625964/* Line 1806 of yacc.c  */
    5963 #line 690 "parser.yy"
     5965#line 695 "parser.yy"
    59645966    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    59655967    break;
     
    59685970
    59695971/* Line 1806 of yacc.c  */
    5970 #line 697 "parser.yy"
     5972#line 702 "parser.yy"
    59715973    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    59725974    break;
     
    59755977
    59765978/* Line 1806 of yacc.c  */
    5977 #line 702 "parser.yy"
     5979#line 707 "parser.yy"
    59785980    { (yyval.sn) = new StatementNode( StatementNode::Exp, (yyvsp[(1) - (2)].en), 0 ); }
    59795981    break;
     
    59825984
    59835985/* Line 1806 of yacc.c  */
    5984 #line 708 "parser.yy"
     5986#line 713 "parser.yy"
    59855987    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    59865988    break;
     
    59895991
    59905992/* Line 1806 of yacc.c  */
    5991 #line 710 "parser.yy"
     5993#line 715 "parser.yy"
    59925994    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn) )) ); }
    59935995    break;
     
    59965998
    59975999/* Line 1806 of yacc.c  */
    5998 #line 712 "parser.yy"
     6000#line 717 "parser.yy"
    59996001    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    60006002    break;
     
    60036005
    60046006/* Line 1806 of yacc.c  */
    6005 #line 714 "parser.yy"
     6007#line 719 "parser.yy"
    60066008    {
    60076009                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     
    60186020
    60196021/* Line 1806 of yacc.c  */
    6020 #line 724 "parser.yy"
     6022#line 729 "parser.yy"
    60216023    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    60226024    break;
     
    60256027
    60266028/* Line 1806 of yacc.c  */
    6027 #line 726 "parser.yy"
     6029#line 731 "parser.yy"
    60286030    {
    60296031                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     
    60356037
    60366038/* Line 1806 of yacc.c  */
    6037 #line 736 "parser.yy"
     6039#line 741 "parser.yy"
    60386040    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    60396041    break;
     
    60426044
    60436045/* 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#line 743 "parser.yy"
     6047    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Range, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    60466048    break;
    60476049
     
    60496051
    60506052/* Line 1806 of yacc.c  */
    6051 #line 743 "parser.yy"
     6053#line 748 "parser.yy"
    60526054    { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(1) - (1)].en), 0 ); }
    60536055    break;
     
    60566058
    60576059/* Line 1806 of yacc.c  */
    6058 #line 744 "parser.yy"
     6060#line 750 "parser.yy"
    60596061    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode( StatementNode::Case, (yyvsp[(3) - (3)].en), 0 ) ) ); }
    60606062    break;
     
    60636065
    60646066/* Line 1806 of yacc.c  */
    6065 #line 748 "parser.yy"
     6067#line 754 "parser.yy"
    60666068    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    60676069    break;
     
    60706072
    60716073/* Line 1806 of yacc.c  */
    6072 #line 749 "parser.yy"
     6074#line 755 "parser.yy"
    60736075    { (yyval.sn) = new StatementNode( StatementNode::Default ); }
    60746076    break;
     
    60776079
    60786080/* Line 1806 of yacc.c  */
    6079 #line 755 "parser.yy"
     6081#line 761 "parser.yy"
    60806082    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
    60816083    break;
     
    60846086
    60856087/* Line 1806 of yacc.c  */
    6086 #line 759 "parser.yy"
     6088#line 765 "parser.yy"
    60876089    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    60886090    break;
     
    60916093
    60926094/* Line 1806 of yacc.c  */
    6093 #line 764 "parser.yy"
     6095#line 770 "parser.yy"
    60946096    { (yyval.sn) = 0; }
    60956097    break;
     
    60986100
    60996101/* Line 1806 of yacc.c  */
    6100 #line 770 "parser.yy"
     6102#line 776 "parser.yy"
    61016103    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    61026104    break;
     
    61056107
    61066108/* Line 1806 of yacc.c  */
    6107 #line 772 "parser.yy"
     6109#line 778 "parser.yy"
    61086110    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    61096111    break;
     
    61126114
    61136115/* Line 1806 of yacc.c  */
    6114 #line 777 "parser.yy"
     6116#line 783 "parser.yy"
    61156117    { (yyval.sn) = 0; }
    61166118    break;
     
    61196121
    61206122/* Line 1806 of yacc.c  */
    6121 #line 783 "parser.yy"
     6123#line 789 "parser.yy"
    61226124    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    61236125    break;
     
    61266128
    61276129/* Line 1806 of yacc.c  */
    6128 #line 785 "parser.yy"
     6130#line 791 "parser.yy"
    61296131    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
    61306132    break;
     
    61336135
    61346136/* Line 1806 of yacc.c  */
    6135 #line 787 "parser.yy"
     6137#line 793 "parser.yy"
    61366138    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    61376139    break;
     
    61406142
    61416143/* Line 1806 of yacc.c  */
    6142 #line 789 "parser.yy"
     6144#line 795 "parser.yy"
    61436145    { (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) ) ) ) ) ) ); }
    61446146    break;
     
    61476149
    61486150/* Line 1806 of yacc.c  */
    6149 #line 794 "parser.yy"
     6151#line 800 "parser.yy"
    61506152    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    61516153    break;
     
    61546156
    61556157/* Line 1806 of yacc.c  */
    6156 #line 800 "parser.yy"
     6158#line 806 "parser.yy"
    61576159    { (yyval.sn) = 0; }
    61586160    break;
     
    61616163
    61626164/* Line 1806 of yacc.c  */
    6163 #line 802 "parser.yy"
     6165#line 808 "parser.yy"
    61646166    { (yyval.sn) = 0; }
    61656167    break;
     
    61686170
    61696171/* Line 1806 of yacc.c  */
    6170 #line 807 "parser.yy"
     6172#line 813 "parser.yy"
    61716173    { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    61726174    break;
     
    61756177
    61766178/* Line 1806 of yacc.c  */
    6177 #line 809 "parser.yy"
     6179#line 815 "parser.yy"
    61786180    { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); }
    61796181    break;
     
    61826184
    61836185/* Line 1806 of yacc.c  */
    6184 #line 811 "parser.yy"
     6186#line 817 "parser.yy"
    61856187    { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); }
    61866188    break;
     
    61896191
    61906192/* Line 1806 of yacc.c  */
    6191 #line 816 "parser.yy"
     6193#line 822 "parser.yy"
    61926194    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    61936195    break;
     
    61966198
    61976199/* Line 1806 of yacc.c  */
    6198 #line 818 "parser.yy"
     6200#line 824 "parser.yy"
    61996201    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    62006202    break;
     
    62036205
    62046206/* Line 1806 of yacc.c  */
    6205 #line 823 "parser.yy"
     6207#line 829 "parser.yy"
    62066208    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
    62076209    break;
     
    62106212
    62116213/* Line 1806 of yacc.c  */
    6212 #line 827 "parser.yy"
     6214#line 833 "parser.yy"
    62136215    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
    62146216    break;
     
    62176219
    62186220/* Line 1806 of yacc.c  */
    6219 #line 830 "parser.yy"
     6221#line 836 "parser.yy"
    62206222    { (yyval.sn) = new StatementNode( StatementNode::Continue ); }
    62216223    break;
     
    62246226
    62256227/* Line 1806 of yacc.c  */
    6226 #line 834 "parser.yy"
     6228#line 840 "parser.yy"
    62276229    { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
    62286230    break;
     
    62316233
    62326234/* Line 1806 of yacc.c  */
    6233 #line 837 "parser.yy"
     6235#line 843 "parser.yy"
    62346236    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    62356237    break;
     
    62386240
    62396241/* Line 1806 of yacc.c  */
    6240 #line 841 "parser.yy"
     6242#line 847 "parser.yy"
    62416243    { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
    62426244    break;
     
    62456247
    62466248/* Line 1806 of yacc.c  */
    6247 #line 843 "parser.yy"
     6249#line 849 "parser.yy"
    62486250    { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); }
    62496251    break;
     
    62526254
    62536255/* Line 1806 of yacc.c  */
    6254 #line 845 "parser.yy"
     6256#line 851 "parser.yy"
    62556257    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    62566258    break;
     
    62596261
    62606262/* Line 1806 of yacc.c  */
    6261 #line 849 "parser.yy"
     6263#line 855 "parser.yy"
    62626264    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    62636265    break;
     
    62666268
    62676269/* Line 1806 of yacc.c  */
    6268 #line 851 "parser.yy"
     6270#line 857 "parser.yy"
    62696271    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (5)].en), 0 ); }
    62706272    break;
     
    62736275
    62746276/* Line 1806 of yacc.c  */
    6275 #line 858 "parser.yy"
     6277#line 864 "parser.yy"
    62766278    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    62776279    break;
     
    62806282
    62816283/* Line 1806 of yacc.c  */
    6282 #line 860 "parser.yy"
     6284#line 866 "parser.yy"
    62836285    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    62846286    break;
     
    62876289
    62886290/* Line 1806 of yacc.c  */
    6289 #line 862 "parser.yy"
     6291#line 868 "parser.yy"
    62906292    {
    62916293                        (yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) );
     
    62976299
    62986300/* Line 1806 of yacc.c  */
    6299 #line 873 "parser.yy"
     6301#line 879 "parser.yy"
    63006302    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    63016303    break;
     
    63046306
    63056307/* Line 1806 of yacc.c  */
    6306 #line 875 "parser.yy"
     6308#line 881 "parser.yy"
    63076309    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    63086310    break;
     
    63116313
    63126314/* Line 1806 of yacc.c  */
    6313 #line 877 "parser.yy"
     6315#line 883 "parser.yy"
    63146316    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    63156317    break;
     
    63186320
    63196321/* Line 1806 of yacc.c  */
    6320 #line 879 "parser.yy"
     6322#line 885 "parser.yy"
    63216323    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    63226324    break;
     
    63256327
    63266328/* Line 1806 of yacc.c  */
    6327 #line 884 "parser.yy"
     6329#line 890 "parser.yy"
    63286330    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    63296331    break;
     
    63326334
    63336335/* Line 1806 of yacc.c  */
    6334 #line 886 "parser.yy"
     6336#line 892 "parser.yy"
    63356337    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    63366338    break;
     
    63396341
    63406342/* Line 1806 of yacc.c  */
    6341 #line 888 "parser.yy"
     6343#line 894 "parser.yy"
    63426344    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    63436345    break;
     
    63466348
    63476349/* Line 1806 of yacc.c  */
    6348 #line 890 "parser.yy"
     6350#line 896 "parser.yy"
    63496351    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    63506352    break;
     
    63536355
    63546356/* Line 1806 of yacc.c  */
    6355 #line 895 "parser.yy"
     6357#line 901 "parser.yy"
    63566358    {
    63576359                        (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
     
    63636365
    63646366/* Line 1806 of yacc.c  */
    6365 #line 909 "parser.yy"
     6367#line 915 "parser.yy"
    63666368    {
    63676369                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63736375
    63746376/* Line 1806 of yacc.c  */
    6375 #line 914 "parser.yy"
     6377#line 920 "parser.yy"
    63766378    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    63776379    break;
     
    63806382
    63816383/* Line 1806 of yacc.c  */
    6382 #line 916 "parser.yy"
     6384#line 922 "parser.yy"
    63836385    {
    63846386                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63906392
    63916393/* Line 1806 of yacc.c  */
    6392 #line 925 "parser.yy"
     6394#line 931 "parser.yy"
    63936395    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
    63946396    break;
     
    63976399
    63986400/* Line 1806 of yacc.c  */
    6399 #line 927 "parser.yy"
     6401#line 933 "parser.yy"
    64006402    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
    64016403    break;
     
    64046406
    64056407/* Line 1806 of yacc.c  */
    6406 #line 929 "parser.yy"
     6408#line 935 "parser.yy"
    64076409    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
    64086410    break;
     
    64116413
    64126414/* Line 1806 of yacc.c  */
    6413 #line 931 "parser.yy"
     6415#line 937 "parser.yy"
    64146416    { (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) ); }
    64156417    break;
     
    64186420
    64196421/* Line 1806 of yacc.c  */
    6420 #line 933 "parser.yy"
     6422#line 939 "parser.yy"
    64216423    { (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) ); }
    64226424    break;
     
    64256427
    64266428/* Line 1806 of yacc.c  */
    6427 #line 938 "parser.yy"
     6429#line 944 "parser.yy"
    64286430    { (yyval.flag) = false; }
    64296431    break;
     
    64326434
    64336435/* Line 1806 of yacc.c  */
    6434 #line 940 "parser.yy"
     6436#line 946 "parser.yy"
    64356437    { (yyval.flag) = true; }
    64366438    break;
     
    64396441
    64406442/* Line 1806 of yacc.c  */
    6441 #line 945 "parser.yy"
     6443#line 951 "parser.yy"
    64426444    { (yyval.en) = 0; }
    64436445    break;
     
    64466448
    64476449/* Line 1806 of yacc.c  */
    6448 #line 952 "parser.yy"
     6450#line 958 "parser.yy"
    64496451    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    64506452    break;
     
    64536455
    64546456/* Line 1806 of yacc.c  */
    6455 #line 957 "parser.yy"
     6457#line 963 "parser.yy"
    64566458    { (yyval.en) = new AsmExprNode( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ); }
    64576459    break;
     
    64606462
    64616463/* Line 1806 of yacc.c  */
    6462 #line 959 "parser.yy"
     6464#line 965 "parser.yy"
    64636465    { (yyval.en) = new AsmExprNode( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ); }
    64646466    break;
     
    64676469
    64686470/* Line 1806 of yacc.c  */
    6469 #line 964 "parser.yy"
     6471#line 970 "parser.yy"
    64706472    { (yyval.constant) = 0; }
    64716473    break;
     
    64746476
    64756477/* Line 1806 of yacc.c  */
    6476 #line 966 "parser.yy"
     6478#line 972 "parser.yy"
    64776479    { (yyval.constant) = (yyvsp[(1) - (1)].constant); }
    64786480    break;
     
    64816483
    64826484/* Line 1806 of yacc.c  */
    6483 #line 968 "parser.yy"
     6485#line 974 "parser.yy"
    64846486    { (yyval.constant) = (ConstantNode *)(yyvsp[(1) - (3)].constant)->set_link( (yyvsp[(3) - (3)].constant) ); }
    64856487    break;
     
    64886490
    64896491/* Line 1806 of yacc.c  */
    6490 #line 973 "parser.yy"
     6492#line 979 "parser.yy"
    64916493    { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
    64926494    break;
     
    64956497
    64966498/* Line 1806 of yacc.c  */
    6497 #line 975 "parser.yy"
     6499#line 981 "parser.yy"
    64986500    { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
    64996501    break;
     
    65026504
    65036505/* Line 1806 of yacc.c  */
    6504 #line 982 "parser.yy"
     6506#line 988 "parser.yy"
    65056507    { (yyval.decl) = 0; }
    65066508    break;
     
    65096511
    65106512/* Line 1806 of yacc.c  */
    6511 #line 989 "parser.yy"
     6513#line 995 "parser.yy"
    65126514    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    65136515    break;
     
    65166518
    65176519/* Line 1806 of yacc.c  */
    6518 #line 994 "parser.yy"
     6520#line 1000 "parser.yy"
    65196521    { (yyval.decl) = 0; }
    65206522    break;
     
    65236525
    65246526/* Line 1806 of yacc.c  */
    6525 #line 1001 "parser.yy"
     6527#line 1007 "parser.yy"
    65266528    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    65276529    break;
     
    65306532
    65316533/* Line 1806 of yacc.c  */
    6532 #line 1015 "parser.yy"
     6534#line 1021 "parser.yy"
    65336535    {}
    65346536    break;
     
    65376539
    65386540/* Line 1806 of yacc.c  */
    6539 #line 1016 "parser.yy"
     6541#line 1022 "parser.yy"
    65406542    {}
    65416543    break;
     
    65446546
    65456547/* Line 1806 of yacc.c  */
    6546 #line 1045 "parser.yy"
     6548#line 1051 "parser.yy"
    65476549    {
    65486550                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65546556
    65556557/* Line 1806 of yacc.c  */
    6556 #line 1052 "parser.yy"
     6558#line 1058 "parser.yy"
    65576559    {
    65586560                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65646566
    65656567/* Line 1806 of yacc.c  */
    6566 #line 1057 "parser.yy"
     6568#line 1063 "parser.yy"
    65676569    {
    65686570                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
     
    65746576
    65756577/* Line 1806 of yacc.c  */
    6576 #line 1067 "parser.yy"
     6578#line 1073 "parser.yy"
    65776579    {
    65786580                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    65846586
    65856587/* Line 1806 of yacc.c  */
    6586 #line 1072 "parser.yy"
     6588#line 1078 "parser.yy"
    65876589    {
    65886590                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    65946596
    65956597/* Line 1806 of yacc.c  */
    6596 #line 1077 "parser.yy"
     6598#line 1083 "parser.yy"
    65976599    {
    65986600                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
     
    66046606
    66056607/* Line 1806 of yacc.c  */
    6606 #line 1085 "parser.yy"
     6608#line 1091 "parser.yy"
    66076609    {
    66086610                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66146616
    66156617/* Line 1806 of yacc.c  */
    6616 #line 1090 "parser.yy"
     6618#line 1096 "parser.yy"
    66176619    {
    66186620                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66246626
    66256627/* Line 1806 of yacc.c  */
    6626 #line 1095 "parser.yy"
     6628#line 1101 "parser.yy"
    66276629    {
    66286630                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66346636
    66356637/* Line 1806 of yacc.c  */
    6636 #line 1100 "parser.yy"
     6638#line 1106 "parser.yy"
    66376639    {
    66386640                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66446646
    66456647/* Line 1806 of yacc.c  */
    6646 #line 1105 "parser.yy"
     6648#line 1111 "parser.yy"
    66476649    {
    66486650                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    66546656
    66556657/* Line 1806 of yacc.c  */
    6656 #line 1113 "parser.yy"
     6658#line 1119 "parser.yy"
    66576659    {
    66586660                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
     
    66636665
    66646666/* Line 1806 of yacc.c  */
    6665 #line 1136 "parser.yy"
     6667#line 1142 "parser.yy"
    66666668    {
    66676669                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    66726674
    66736675/* Line 1806 of yacc.c  */
    6674 #line 1140 "parser.yy"
     6676#line 1146 "parser.yy"
    66756677    {
    66766678                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    66816683
    66826684/* Line 1806 of yacc.c  */
    6683 #line 1147 "parser.yy"
     6685#line 1153 "parser.yy"
    66846686    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    66856687    break;
     
    66886690
    66896691/* Line 1806 of yacc.c  */
    6690 #line 1151 "parser.yy"
     6692#line 1157 "parser.yy"
    66916693    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    66926694    break;
     
    66956697
    66966698/* Line 1806 of yacc.c  */
    6697 #line 1156 "parser.yy"
     6699#line 1162 "parser.yy"
    66986700    {
    66996701                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67056707
    67066708/* Line 1806 of yacc.c  */
    6707 #line 1161 "parser.yy"
     6709#line 1167 "parser.yy"
    67086710    {
    67096711                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67156717
    67166718/* Line 1806 of yacc.c  */
    6717 #line 1166 "parser.yy"
     6719#line 1172 "parser.yy"
    67186720    {
    67196721                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
     
    67256727
    67266728/* Line 1806 of yacc.c  */
    6727 #line 1177 "parser.yy"
     6729#line 1183 "parser.yy"
    67286730    {
    67296731                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67356737
    67366738/* Line 1806 of yacc.c  */
    6737 #line 1182 "parser.yy"
     6739#line 1188 "parser.yy"
    67386740    {
    67396741                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67456747
    67466748/* Line 1806 of yacc.c  */
    6747 #line 1187 "parser.yy"
     6749#line 1193 "parser.yy"
    67486750    {
    67496751                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67556757
    67566758/* Line 1806 of yacc.c  */
    6757 #line 1192 "parser.yy"
     6759#line 1198 "parser.yy"
    67586760    {
    67596761                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67656767
    67666768/* Line 1806 of yacc.c  */
    6767 #line 1197 "parser.yy"
     6769#line 1203 "parser.yy"
    67686770    {
    67696771                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67756777
    67766778/* Line 1806 of yacc.c  */
    6777 #line 1206 "parser.yy"
     6779#line 1212 "parser.yy"
    67786780    {
    67796781                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
     
    67856787
    67866788/* Line 1806 of yacc.c  */
    6787 #line 1211 "parser.yy"
     6789#line 1217 "parser.yy"
    67886790    {
    67896791                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
     
    67956797
    67966798/* Line 1806 of yacc.c  */
    6797 #line 1228 "parser.yy"
     6799#line 1234 "parser.yy"
    67986800    {
    67996801                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    68056807
    68066808/* Line 1806 of yacc.c  */
    6807 #line 1233 "parser.yy"
     6809#line 1239 "parser.yy"
    68086810    {
    68096811                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    68156817
    68166818/* Line 1806 of yacc.c  */
    6817 #line 1255 "parser.yy"
     6819#line 1261 "parser.yy"
    68186820    { (yyval.decl) = 0; }
    68196821    break;
     
    68226824
    68236825/* Line 1806 of yacc.c  */
    6824 #line 1267 "parser.yy"
     6826#line 1273 "parser.yy"
    68256827    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68266828    break;
     
    68296831
    68306832/* Line 1806 of yacc.c  */
    6831 #line 1278 "parser.yy"
     6833#line 1284 "parser.yy"
    68326834    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    68336835    break;
     
    68366838
    68376839/* Line 1806 of yacc.c  */
    6838 #line 1280 "parser.yy"
     6840#line 1286 "parser.yy"
    68396841    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    68406842    break;
     
    68436845
    68446846/* Line 1806 of yacc.c  */
    6845 #line 1282 "parser.yy"
     6847#line 1288 "parser.yy"
    68466848    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    68476849    break;
     
    68506852
    68516853/* Line 1806 of yacc.c  */
    6852 #line 1284 "parser.yy"
     6854#line 1290 "parser.yy"
    68536855    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    68546856    break;
     
    68576859
    68586860/* Line 1806 of yacc.c  */
    6859 #line 1286 "parser.yy"
     6861#line 1292 "parser.yy"
    68606862    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    68616863    break;
     
    68646866
    68656867/* Line 1806 of yacc.c  */
    6866 #line 1288 "parser.yy"
     6868#line 1294 "parser.yy"
    68676869    {
    68686870                        typedefTable.enterScope();
     
    68736875
    68746876/* Line 1806 of yacc.c  */
    6875 #line 1292 "parser.yy"
     6877#line 1298 "parser.yy"
    68766878    {
    68776879                        typedefTable.leaveScope();
     
    68836885
    68846886/* Line 1806 of yacc.c  */
    6885 #line 1301 "parser.yy"
     6887#line 1307 "parser.yy"
    68866888    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68876889    break;
     
    68906892
    68916893/* Line 1806 of yacc.c  */
    6892 #line 1303 "parser.yy"
     6894#line 1309 "parser.yy"
    68936895    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68946896    break;
     
    68976899
    68986900/* Line 1806 of yacc.c  */
    6899 #line 1314 "parser.yy"
     6901#line 1320 "parser.yy"
    69006902    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69016903    break;
     
    69046906
    69056907/* Line 1806 of yacc.c  */
    6906 #line 1323 "parser.yy"
     6908#line 1329 "parser.yy"
    69076909    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    69086910    break;
     
    69116913
    69126914/* Line 1806 of yacc.c  */
    6913 #line 1325 "parser.yy"
     6915#line 1331 "parser.yy"
    69146916    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    69156917    break;
     
    69186920
    69196921/* Line 1806 of yacc.c  */
    6920 #line 1327 "parser.yy"
     6922#line 1333 "parser.yy"
    69216923    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    69226924    break;
     
    69256927
    69266928/* Line 1806 of yacc.c  */
    6927 #line 1329 "parser.yy"
     6929#line 1335 "parser.yy"
    69286930    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    69296931    break;
     
    69326934
    69336935/* Line 1806 of yacc.c  */
    6934 #line 1331 "parser.yy"
     6936#line 1337 "parser.yy"
    69356937    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    69366938    break;
     
    69396941
    69406942/* Line 1806 of yacc.c  */
    6941 #line 1333 "parser.yy"
     6943#line 1339 "parser.yy"
    69426944    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    69436945    break;
     
    69466948
    69476949/* Line 1806 of yacc.c  */
    6948 #line 1335 "parser.yy"
     6950#line 1341 "parser.yy"
    69496951    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
    69506952    break;
     
    69536955
    69546956/* Line 1806 of yacc.c  */
    6955 #line 1337 "parser.yy"
     6957#line 1343 "parser.yy"
    69566958    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    69576959    break;
     
    69606962
    69616963/* Line 1806 of yacc.c  */
    6962 #line 1342 "parser.yy"
     6964#line 1348 "parser.yy"
    69636965    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    69646966    break;
     
    69676969
    69686970/* Line 1806 of yacc.c  */
    6969 #line 1344 "parser.yy"
     6971#line 1350 "parser.yy"
    69706972    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    69716973    break;
     
    69746976
    69756977/* Line 1806 of yacc.c  */
    6976 #line 1346 "parser.yy"
     6978#line 1352 "parser.yy"
    69776979    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    69786980    break;
     
    69816983
    69826984/* Line 1806 of yacc.c  */
    6983 #line 1348 "parser.yy"
     6985#line 1354 "parser.yy"
    69846986    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    69856987    break;
     
    69886990
    69896991/* Line 1806 of yacc.c  */
    6990 #line 1350 "parser.yy"
     6992#line 1356 "parser.yy"
    69916993    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
    69926994    break;
     
    69956997
    69966998/* Line 1806 of yacc.c  */
    6997 #line 1352 "parser.yy"
     6999#line 1358 "parser.yy"
    69987000    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
    69997001    break;
     
    70027004
    70037005/* Line 1806 of yacc.c  */
    7004 #line 1354 "parser.yy"
     7006#line 1360 "parser.yy"
    70057007    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
    70067008    break;
     
    70097011
    70107012/* Line 1806 of yacc.c  */
    7011 #line 1356 "parser.yy"
     7013#line 1362 "parser.yy"
    70127014    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
    70137015    break;
     
    70167018
    70177019/* Line 1806 of yacc.c  */
    7018 #line 1358 "parser.yy"
     7020#line 1364 "parser.yy"
    70197021    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    70207022    break;
     
    70237025
    70247026/* Line 1806 of yacc.c  */
    7025 #line 1360 "parser.yy"
     7027#line 1366 "parser.yy"
    70267028    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    70277029    break;
     
    70307032
    70317033/* Line 1806 of yacc.c  */
    7032 #line 1362 "parser.yy"
     7034#line 1368 "parser.yy"
    70337035    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
    70347036    break;
     
    70377039
    70387040/* Line 1806 of yacc.c  */
    7039 #line 1364 "parser.yy"
     7041#line 1370 "parser.yy"
    70407042    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
    70417043    break;
     
    70447046
    70457047/* Line 1806 of yacc.c  */
    7046 #line 1366 "parser.yy"
     7048#line 1372 "parser.yy"
    70477049    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    70487050    break;
     
    70517053
    70527054/* Line 1806 of yacc.c  */
    7053 #line 1373 "parser.yy"
     7055#line 1379 "parser.yy"
    70547056    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    70557057    break;
     
    70587060
    70597061/* Line 1806 of yacc.c  */
    7060 #line 1375 "parser.yy"
     7062#line 1381 "parser.yy"
    70617063    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    70627064    break;
     
    70657067
    70667068/* Line 1806 of yacc.c  */
    7067 #line 1377 "parser.yy"
     7069#line 1383 "parser.yy"
    70687070    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    70697071    break;
     
    70727074
    70737075/* Line 1806 of yacc.c  */
    7074 #line 1379 "parser.yy"
     7076#line 1385 "parser.yy"
    70757077    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    70767078    break;
     
    70797081
    70807082/* Line 1806 of yacc.c  */
    7081 #line 1385 "parser.yy"
     7083#line 1391 "parser.yy"
    70827084    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    70837085    break;
     
    70867088
    70877089/* Line 1806 of yacc.c  */
    7088 #line 1392 "parser.yy"
     7090#line 1398 "parser.yy"
    70897091    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    70907092    break;
     
    70937095
    70947096/* Line 1806 of yacc.c  */
    7095 #line 1394 "parser.yy"
     7097#line 1400 "parser.yy"
    70967098    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    70977099    break;
     
    71007102
    71017103/* Line 1806 of yacc.c  */
    7102 #line 1396 "parser.yy"
     7104#line 1402 "parser.yy"
    71037105    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    71047106    break;
     
    71077109
    71087110/* Line 1806 of yacc.c  */
    7109 #line 1401 "parser.yy"
     7111#line 1407 "parser.yy"
    71107112    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    71117113    break;
     
    71147116
    71157117/* Line 1806 of yacc.c  */
    7116 #line 1403 "parser.yy"
     7118#line 1409 "parser.yy"
    71177119    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    71187120    break;
     
    71217123
    71227124/* Line 1806 of yacc.c  */
    7123 #line 1405 "parser.yy"
     7125#line 1411 "parser.yy"
    71247126    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    71257127    break;
     
    71287130
    71297131/* Line 1806 of yacc.c  */
    7130 #line 1407 "parser.yy"
     7132#line 1413 "parser.yy"
    71317133    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    71327134    break;
     
    71357137
    71367138/* Line 1806 of yacc.c  */
    7137 #line 1413 "parser.yy"
     7139#line 1419 "parser.yy"
    71387140    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    71397141    break;
     
    71427144
    71437145/* Line 1806 of yacc.c  */
    7144 #line 1415 "parser.yy"
     7146#line 1421 "parser.yy"
    71457147    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    71467148    break;
     
    71497151
    71507152/* Line 1806 of yacc.c  */
    7151 #line 1417 "parser.yy"
     7153#line 1423 "parser.yy"
    71527154    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    71537155    break;
     
    71567158
    71577159/* Line 1806 of yacc.c  */
    7158 #line 1423 "parser.yy"
     7160#line 1429 "parser.yy"
    71597161    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    71607162    break;
     
    71637165
    71647166/* Line 1806 of yacc.c  */
    7165 #line 1425 "parser.yy"
     7167#line 1431 "parser.yy"
    71667168    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    71677169    break;
     
    71707172
    71717173/* Line 1806 of yacc.c  */
    7172 #line 1431 "parser.yy"
     7174#line 1437 "parser.yy"
    71737175    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    71747176    break;
     
    71777179
    71787180/* Line 1806 of yacc.c  */
    7179 #line 1433 "parser.yy"
     7181#line 1439 "parser.yy"
    71807182    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    71817183    break;
     
    71847186
    71857187/* Line 1806 of yacc.c  */
    7186 #line 1435 "parser.yy"
     7188#line 1441 "parser.yy"
    71877189    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    71887190    break;
     
    71917193
    71927194/* Line 1806 of yacc.c  */
    7193 #line 1440 "parser.yy"
     7195#line 1446 "parser.yy"
    71947196    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    71957197    break;
     
    71987200
    71997201/* Line 1806 of yacc.c  */
    7200 #line 1442 "parser.yy"
     7202#line 1448 "parser.yy"
    72017203    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    72027204    break;
     
    72057207
    72067208/* Line 1806 of yacc.c  */
    7207 #line 1444 "parser.yy"
     7209#line 1450 "parser.yy"
    72087210    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    72097211    break;
     
    72127214
    72137215/* Line 1806 of yacc.c  */
    7214 #line 1454 "parser.yy"
     7216#line 1460 "parser.yy"
    72157217    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
    72167218    break;
     
    72197221
    72207222/* Line 1806 of yacc.c  */
    7221 #line 1456 "parser.yy"
     7223#line 1462 "parser.yy"
    72227224    {
    72237225                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    72297231
    72307232/* Line 1806 of yacc.c  */
    7231 #line 1461 "parser.yy"
     7233#line 1467 "parser.yy"
    72327234    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    72337235    break;
     
    72367238
    72377239/* Line 1806 of yacc.c  */
    7238 #line 1463 "parser.yy"
     7240#line 1469 "parser.yy"
    72397241    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
    72407242    break;
     
    72437245
    72447246/* Line 1806 of yacc.c  */
    7245 #line 1465 "parser.yy"
     7247#line 1471 "parser.yy"
    72467248    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    72477249    break;
     
    72507252
    72517253/* Line 1806 of yacc.c  */
    7252 #line 1467 "parser.yy"
     7254#line 1473 "parser.yy"
    72537255    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    72547256    break;
     
    72577259
    72587260/* Line 1806 of yacc.c  */
    7259 #line 1472 "parser.yy"
     7261#line 1478 "parser.yy"
    72607262    { (yyval.aggKey) = DeclarationNode::Struct; }
    72617263    break;
     
    72647266
    72657267/* Line 1806 of yacc.c  */
    7266 #line 1474 "parser.yy"
     7268#line 1480 "parser.yy"
    72677269    { (yyval.aggKey) = DeclarationNode::Union; }
    72687270    break;
     
    72717273
    72727274/* Line 1806 of yacc.c  */
    7273 #line 1479 "parser.yy"
     7275#line 1485 "parser.yy"
    72747276    { (yyval.decl) = 0; }
    72757277    break;
     
    72787280
    72797281/* Line 1806 of yacc.c  */
    7280 #line 1481 "parser.yy"
     7282#line 1487 "parser.yy"
    72817283    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    72827284    break;
     
    72857287
    72867288/* Line 1806 of yacc.c  */
    7287 #line 1487 "parser.yy"
     7289#line 1493 "parser.yy"
    72887290    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    72897291    break;
     
    72927294
    72937295/* Line 1806 of yacc.c  */
    7294 #line 1490 "parser.yy"
     7296#line 1496 "parser.yy"
    72957297    {   // mark all fields in list
    72967298                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    73037305
    73047306/* Line 1806 of yacc.c  */
    7305 #line 1500 "parser.yy"
     7307#line 1506 "parser.yy"
    73067308    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    73077309    break;
     
    73107312
    73117313/* Line 1806 of yacc.c  */
    7312 #line 1502 "parser.yy"
     7314#line 1508 "parser.yy"
    73137315    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    73147316    break;
     
    73177319
    73187320/* Line 1806 of yacc.c  */
    7319 #line 1504 "parser.yy"
     7321#line 1510 "parser.yy"
    73207322    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    73217323    break;
     
    73247326
    73257327/* Line 1806 of yacc.c  */
    7326 #line 1509 "parser.yy"
     7328#line 1515 "parser.yy"
    73277329    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73287330    break;
     
    73317333
    73327334/* Line 1806 of yacc.c  */
    7333 #line 1511 "parser.yy"
     7335#line 1517 "parser.yy"
    73347336    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    73357337    break;
     
    73387340
    73397341/* Line 1806 of yacc.c  */
    7340 #line 1516 "parser.yy"
     7342#line 1522 "parser.yy"
    73417343    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    73427344    break;
     
    73457347
    73467348/* Line 1806 of yacc.c  */
    7347 #line 1518 "parser.yy"
     7349#line 1524 "parser.yy"
    73487350    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    73497351    break;
     
    73527354
    73537355/* Line 1806 of yacc.c  */
    7354 #line 1521 "parser.yy"
     7356#line 1527 "parser.yy"
    73557357    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    73567358    break;
     
    73597361
    73607362/* Line 1806 of yacc.c  */
    7361 #line 1524 "parser.yy"
     7363#line 1530 "parser.yy"
    73627364    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    73637365    break;
     
    73667368
    73677369/* Line 1806 of yacc.c  */
    7368 #line 1530 "parser.yy"
     7370#line 1536 "parser.yy"
    73697371    { (yyval.en) = 0; }
    73707372    break;
     
    73737375
    73747376/* Line 1806 of yacc.c  */
    7375 #line 1532 "parser.yy"
     7377#line 1538 "parser.yy"
    73767378    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    73777379    break;
     
    73807382
    73817383/* Line 1806 of yacc.c  */
    7382 #line 1537 "parser.yy"
     7384#line 1543 "parser.yy"
    73837385    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    73847386    break;
     
    73877389
    73887390/* Line 1806 of yacc.c  */
    7389 #line 1546 "parser.yy"
     7391#line 1552 "parser.yy"
    73907392    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
    73917393    break;
     
    73947396
    73957397/* Line 1806 of yacc.c  */
    7396 #line 1548 "parser.yy"
     7398#line 1554 "parser.yy"
    73977399    {
    73987400                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    74047406
    74057407/* Line 1806 of yacc.c  */
    7406 #line 1553 "parser.yy"
     7408#line 1559 "parser.yy"
    74077409    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    74087410    break;
     
    74117413
    74127414/* Line 1806 of yacc.c  */
    7413 #line 1555 "parser.yy"
     7415#line 1561 "parser.yy"
    74147416    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    74157417    break;
     
    74187420
    74197421/* Line 1806 of yacc.c  */
    7420 #line 1560 "parser.yy"
     7422#line 1566 "parser.yy"
    74217423    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    74227424    break;
     
    74257427
    74267428/* Line 1806 of yacc.c  */
    7427 #line 1562 "parser.yy"
     7429#line 1568 "parser.yy"
    74287430    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    74297431    break;
     
    74327434
    74337435/* Line 1806 of yacc.c  */
    7434 #line 1567 "parser.yy"
     7436#line 1573 "parser.yy"
    74357437    { (yyval.en) = 0; }
    74367438    break;
     
    74397441
    74407442/* Line 1806 of yacc.c  */
    7441 #line 1569 "parser.yy"
     7443#line 1575 "parser.yy"
    74427444    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    74437445    break;
     
    74467448
    74477449/* Line 1806 of yacc.c  */
    7448 #line 1576 "parser.yy"
     7450#line 1582 "parser.yy"
    74497451    { (yyval.decl) = 0; }
    74507452    break;
     
    74537455
    74547456/* Line 1806 of yacc.c  */
    7455 #line 1584 "parser.yy"
     7457#line 1590 "parser.yy"
    74567458    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74577459    break;
     
    74607462
    74617463/* Line 1806 of yacc.c  */
    7462 #line 1586 "parser.yy"
     7464#line 1592 "parser.yy"
    74637465    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    74647466    break;
     
    74677469
    74687470/* Line 1806 of yacc.c  */
    7469 #line 1588 "parser.yy"
     7471#line 1594 "parser.yy"
    74707472    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    74717473    break;
     
    74747476
    74757477/* Line 1806 of yacc.c  */
    7476 #line 1596 "parser.yy"
     7478#line 1602 "parser.yy"
    74777479    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74787480    break;
     
    74817483
    74827484/* Line 1806 of yacc.c  */
    7483 #line 1598 "parser.yy"
     7485#line 1604 "parser.yy"
    74847486    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74857487    break;
     
    74887490
    74897491/* Line 1806 of yacc.c  */
    7490 #line 1600 "parser.yy"
     7492#line 1606 "parser.yy"
    74917493    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    74927494    break;
     
    74957497
    74967498/* Line 1806 of yacc.c  */
    7497 #line 1606 "parser.yy"
     7499#line 1612 "parser.yy"
    74987500    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74997501    break;
     
    75027504
    75037505/* Line 1806 of yacc.c  */
    7504 #line 1611 "parser.yy"
     7506#line 1617 "parser.yy"
    75057507    { (yyval.decl) = 0; }
    75067508    break;
     
    75097511
    75107512/* Line 1806 of yacc.c  */
    7511 #line 1618 "parser.yy"
     7513#line 1624 "parser.yy"
    75127514    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    75137515    break;
     
    75167518
    75177519/* Line 1806 of yacc.c  */
    7518 #line 1625 "parser.yy"
     7520#line 1631 "parser.yy"
    75197521    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    75207522    break;
     
    75237525
    75247526/* Line 1806 of yacc.c  */
    7525 #line 1627 "parser.yy"
     7527#line 1633 "parser.yy"
    75267528    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    75277529    break;
     
    75307532
    75317533/* Line 1806 of yacc.c  */
    7532 #line 1636 "parser.yy"
     7534#line 1642 "parser.yy"
    75337535    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    75347536    break;
     
    75377539
    75387540/* Line 1806 of yacc.c  */
    7539 #line 1639 "parser.yy"
     7541#line 1645 "parser.yy"
    75407542    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    75417543    break;
     
    75447546
    75457547/* Line 1806 of yacc.c  */
    7546 #line 1641 "parser.yy"
     7548#line 1647 "parser.yy"
    75477549    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    75487550    break;
     
    75517553
    75527554/* Line 1806 of yacc.c  */
    7553 #line 1651 "parser.yy"
     7555#line 1657 "parser.yy"
    75547556    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75557557    break;
     
    75587560
    75597561/* Line 1806 of yacc.c  */
    7560 #line 1657 "parser.yy"
     7562#line 1663 "parser.yy"
    75617563    {
    75627564                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    75687570
    75697571/* Line 1806 of yacc.c  */
    7570 #line 1662 "parser.yy"
     7572#line 1668 "parser.yy"
    75717573    {
    75727574                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    75787580
    75797581/* Line 1806 of yacc.c  */
    7580 #line 1671 "parser.yy"
     7582#line 1677 "parser.yy"
    75817583    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    75827584    break;
     
    75857587
    75867588/* Line 1806 of yacc.c  */
    7587 #line 1680 "parser.yy"
     7589#line 1686 "parser.yy"
    75887590    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    75897591    break;
     
    75927594
    75937595/* Line 1806 of yacc.c  */
    7594 #line 1682 "parser.yy"
     7596#line 1688 "parser.yy"
    75957597    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    75967598    break;
     
    75997601
    76007602/* Line 1806 of yacc.c  */
    7601 #line 1707 "parser.yy"
     7603#line 1713 "parser.yy"
    76027604    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    76037605    break;
     
    76067608
    76077609/* Line 1806 of yacc.c  */
    7608 #line 1715 "parser.yy"
     7610#line 1721 "parser.yy"
    76097611    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    76107612    break;
     
    76137615
    76147616/* Line 1806 of yacc.c  */
    7615 #line 1720 "parser.yy"
     7617#line 1726 "parser.yy"
    76167618    { (yyval.in) = 0; }
    76177619    break;
     
    76207622
    76217623/* Line 1806 of yacc.c  */
    7622 #line 1722 "parser.yy"
     7624#line 1728 "parser.yy"
    76237625    { (yyval.in) = (yyvsp[(2) - (2)].in); }
    76247626    break;
     
    76277629
    76287630/* Line 1806 of yacc.c  */
    7629 #line 1724 "parser.yy"
     7631#line 1730 "parser.yy"
    76307632    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    76317633    break;
     
    76347636
    76357637/* Line 1806 of yacc.c  */
    7636 #line 1728 "parser.yy"
     7638#line 1734 "parser.yy"
    76377639    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    76387640    break;
     
    76417643
    76427644/* Line 1806 of yacc.c  */
    7643 #line 1729 "parser.yy"
     7645#line 1735 "parser.yy"
    76447646    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    76457647    break;
     
    76487650
    76497651/* Line 1806 of yacc.c  */
    7650 #line 1734 "parser.yy"
     7652#line 1740 "parser.yy"
    76517653    { (yyval.in) = 0; }
    76527654    break;
     
    76557657
    76567658/* Line 1806 of yacc.c  */
    7657 #line 1736 "parser.yy"
     7659#line 1742 "parser.yy"
    76587660    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    76597661    break;
     
    76627664
    76637665/* Line 1806 of yacc.c  */
    7664 #line 1737 "parser.yy"
     7666#line 1743 "parser.yy"
    76657667    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
    76667668    break;
     
    76697671
    76707672/* Line 1806 of yacc.c  */
    7671 #line 1739 "parser.yy"
     7673#line 1745 "parser.yy"
    76727674    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    76737675    break;
     
    76767678
    76777679/* Line 1806 of yacc.c  */
    7678 #line 1755 "parser.yy"
     7680#line 1761 "parser.yy"
    76797681    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (2)].tok) ); }
    76807682    break;
     
    76837685
    76847686/* Line 1806 of yacc.c  */
    7685 #line 1761 "parser.yy"
     7687#line 1767 "parser.yy"
    76867688    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) )); }
    76877689    break;
     
    76907692
    76917693/* Line 1806 of yacc.c  */
    7692 #line 1769 "parser.yy"
     7694#line 1775 "parser.yy"
    76937695    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); }
    76947696    break;
     
    76977699
    76987700/* Line 1806 of yacc.c  */
    7699 #line 1771 "parser.yy"
     7701#line 1777 "parser.yy"
    77007702    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(2) - (2)].tok) ) ); }
    77017703    break;
     
    77047706
    77057707/* Line 1806 of yacc.c  */
    7706 #line 1774 "parser.yy"
     7708#line 1780 "parser.yy"
    77077709    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    77087710    break;
     
    77117713
    77127714/* Line 1806 of yacc.c  */
    7713 #line 1776 "parser.yy"
     7715#line 1782 "parser.yy"
    77147716    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    77157717    break;
     
    77187720
    77197721/* 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#line 1784 "parser.yy"
     7723    { (yyval.en) = new DesignatorNode( new CompositeExprNode2( build_opr2( OperatorNode::Range, (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ), true ); }
    77227724    break;
    77237725
     
    77257727
    77267728/* Line 1806 of yacc.c  */
    7727 #line 1780 "parser.yy"
     7729#line 1786 "parser.yy"
    77287730    { (yyval.en) = new DesignatorNode( (yyvsp[(4) - (6)].en) ); }
    77297731    break;
     
    77327734
    77337735/* Line 1806 of yacc.c  */
    7734 #line 1804 "parser.yy"
     7736#line 1810 "parser.yy"
    77357737    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    77367738    break;
     
    77397741
    77407742/* Line 1806 of yacc.c  */
    7741 #line 1806 "parser.yy"
     7743#line 1812 "parser.yy"
    77427744    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    77437745    break;
     
    77467748
    77477749/* Line 1806 of yacc.c  */
    7748 #line 1808 "parser.yy"
     7750#line 1814 "parser.yy"
    77497751    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    77507752    break;
     
    77537755
    77547756/* Line 1806 of yacc.c  */
    7755 #line 1814 "parser.yy"
     7757#line 1820 "parser.yy"
    77567758    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    77577759    break;
     
    77607762
    77617763/* Line 1806 of yacc.c  */
    7762 #line 1816 "parser.yy"
     7764#line 1822 "parser.yy"
    77637765    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    77647766    break;
     
    77677769
    77687770/* Line 1806 of yacc.c  */
    7769 #line 1821 "parser.yy"
     7771#line 1827 "parser.yy"
    77707772    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    77717773    break;
     
    77747776
    77757777/* Line 1806 of yacc.c  */
    7776 #line 1827 "parser.yy"
     7778#line 1833 "parser.yy"
    77777779    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    77787780    break;
     
    77817783
    77827784/* Line 1806 of yacc.c  */
    7783 #line 1832 "parser.yy"
     7785#line 1838 "parser.yy"
    77847786    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    77857787    break;
     
    77887790
    77897791/* Line 1806 of yacc.c  */
    7790 #line 1834 "parser.yy"
     7792#line 1840 "parser.yy"
    77917793    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    77927794    break;
     
    77957797
    77967798/* Line 1806 of yacc.c  */
    7797 #line 1840 "parser.yy"
     7799#line 1846 "parser.yy"
    77987800    { (yyval.tclass) = DeclarationNode::Type; }
    77997801    break;
     
    78027804
    78037805/* Line 1806 of yacc.c  */
    7804 #line 1842 "parser.yy"
     7806#line 1848 "parser.yy"
    78057807    { (yyval.tclass) = DeclarationNode::Ftype; }
    78067808    break;
     
    78097811
    78107812/* Line 1806 of yacc.c  */
    7811 #line 1844 "parser.yy"
     7813#line 1850 "parser.yy"
    78127814    { (yyval.tclass) = DeclarationNode::Dtype; }
    78137815    break;
     
    78167818
    78177819/* Line 1806 of yacc.c  */
    7818 #line 1849 "parser.yy"
     7820#line 1855 "parser.yy"
    78197821    { (yyval.decl) = 0; }
    78207822    break;
     
    78237825
    78247826/* Line 1806 of yacc.c  */
    7825 #line 1851 "parser.yy"
     7827#line 1857 "parser.yy"
    78267828    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    78277829    break;
     
    78307832
    78317833/* Line 1806 of yacc.c  */
    7832 #line 1856 "parser.yy"
     7834#line 1862 "parser.yy"
    78337835    {
    78347836                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
     
    78407842
    78417843/* Line 1806 of yacc.c  */
    7842 #line 1861 "parser.yy"
     7844#line 1867 "parser.yy"
    78437845    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    78447846    break;
     
    78477849
    78487850/* Line 1806 of yacc.c  */
    7849 #line 1863 "parser.yy"
     7851#line 1869 "parser.yy"
    78507852    { (yyval.decl) = 0; }
    78517853    break;
     
    78547856
    78557857/* Line 1806 of yacc.c  */
    7856 #line 1868 "parser.yy"
     7858#line 1874 "parser.yy"
    78577859    { (yyval.en) = new TypeValueNode( (yyvsp[(1) - (1)].decl) ); }
    78587860    break;
     
    78617863
    78627864/* Line 1806 of yacc.c  */
    7863 #line 1871 "parser.yy"
     7865#line 1877 "parser.yy"
    78647866    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new TypeValueNode( (yyvsp[(3) - (3)].decl) ))); }
    78657867    break;
     
    78687870
    78697871/* Line 1806 of yacc.c  */
    7870 #line 1873 "parser.yy"
     7872#line 1879 "parser.yy"
    78717873    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    78727874    break;
     
    78757877
    78767878/* Line 1806 of yacc.c  */
    7877 #line 1878 "parser.yy"
     7879#line 1884 "parser.yy"
    78787880    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    78797881    break;
     
    78827884
    78837885/* Line 1806 of yacc.c  */
    7884 #line 1880 "parser.yy"
     7886#line 1886 "parser.yy"
    78857887    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    78867888    break;
     
    78897891
    78907892/* Line 1806 of yacc.c  */
    7891 #line 1882 "parser.yy"
     7893#line 1888 "parser.yy"
    78927894    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    78937895    break;
     
    78967898
    78977899/* Line 1806 of yacc.c  */
    7898 #line 1887 "parser.yy"
     7900#line 1893 "parser.yy"
    78997901    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    79007902    break;
     
    79037905
    79047906/* Line 1806 of yacc.c  */
    7905 #line 1889 "parser.yy"
     7907#line 1895 "parser.yy"
    79067908    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    79077909    break;
     
    79107912
    79117913/* Line 1806 of yacc.c  */
    7912 #line 1894 "parser.yy"
     7914#line 1900 "parser.yy"
    79137915    {
    79147916                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
     
    79207922
    79217923/* Line 1806 of yacc.c  */
    7922 #line 1899 "parser.yy"
     7924#line 1905 "parser.yy"
    79237925    {
    79247926                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
     
    79307932
    79317933/* Line 1806 of yacc.c  */
    7932 #line 1907 "parser.yy"
     7934#line 1913 "parser.yy"
    79337935    {
    79347936                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
     
    79407942
    79417943/* Line 1806 of yacc.c  */
    7942 #line 1912 "parser.yy"
     7944#line 1918 "parser.yy"
    79437945    {
    79447946                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
     
    79507952
    79517953/* Line 1806 of yacc.c  */
    7952 #line 1917 "parser.yy"
     7954#line 1923 "parser.yy"
    79537955    {
    79547956                        typedefTable.leaveTrait();
     
    79617963
    79627964/* Line 1806 of yacc.c  */
    7963 #line 1927 "parser.yy"
     7965#line 1933 "parser.yy"
    79647966    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    79657967    break;
     
    79687970
    79697971/* Line 1806 of yacc.c  */
    7970 #line 1937 "parser.yy"
     7972#line 1943 "parser.yy"
    79717973    {
    79727974                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    79787980
    79797981/* Line 1806 of yacc.c  */
    7980 #line 1942 "parser.yy"
     7982#line 1948 "parser.yy"
    79817983    {
    79827984                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    79887990
    79897991/* Line 1806 of yacc.c  */
    7990 #line 1947 "parser.yy"
     7992#line 1953 "parser.yy"
    79917993    {
    79927994                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    79988000
    79998001/* Line 1806 of yacc.c  */
    8000 #line 1955 "parser.yy"
     8002#line 1961 "parser.yy"
    80018003    {
    80028004                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    80088010
    80098011/* Line 1806 of yacc.c  */
    8010 #line 1960 "parser.yy"
     8012#line 1966 "parser.yy"
    80118013    {
    80128014                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    80188020
    80198021/* Line 1806 of yacc.c  */
    8020 #line 1970 "parser.yy"
     8022#line 1976 "parser.yy"
    80218023    {}
    80228024    break;
     
    80258027
    80268028/* Line 1806 of yacc.c  */
    8027 #line 1972 "parser.yy"
     8029#line 1978 "parser.yy"
    80288030    {
    80298031                        if ( theTree ) {
     
    80388040
    80398041/* Line 1806 of yacc.c  */
    8040 #line 1984 "parser.yy"
     8042#line 1990 "parser.yy"
    80418043    { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    80428044    break;
     
    80458047
    80468048/* Line 1806 of yacc.c  */
    8047 #line 1989 "parser.yy"
     8049#line 1995 "parser.yy"
    80488050    { (yyval.decl) = 0; }
    80498051    break;
     
    80528054
    80538055/* Line 1806 of yacc.c  */
    8054 #line 1997 "parser.yy"
     8056#line 2003 "parser.yy"
    80558057    {}
    80568058    break;
     
    80598061
    80608062/* Line 1806 of yacc.c  */
    8061 #line 1999 "parser.yy"
     8063#line 2005 "parser.yy"
    80628064    {
    80638065                        linkageStack.push( linkage );
     
    80698071
    80708072/* Line 1806 of yacc.c  */
    8071 #line 2004 "parser.yy"
     8073#line 2010 "parser.yy"
    80728074    {
    80738075                        linkage = linkageStack.top();
     
    80808082
    80818083/* Line 1806 of yacc.c  */
    8082 #line 2010 "parser.yy"
     8084#line 2016 "parser.yy"
    80838085    {   // mark all fields in list
    80848086                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    80918093
    80928094/* Line 1806 of yacc.c  */
    8093 #line 2025 "parser.yy"
     8095#line 2031 "parser.yy"
    80948096    {
    80958097                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81028104
    81038105/* Line 1806 of yacc.c  */
    8104 #line 2031 "parser.yy"
     8106#line 2037 "parser.yy"
    81058107    {
    81068108                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81138115
    81148116/* Line 1806 of yacc.c  */
    8115 #line 2040 "parser.yy"
     8117#line 2046 "parser.yy"
    81168118    {
    81178119                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81248126
    81258127/* Line 1806 of yacc.c  */
    8126 #line 2046 "parser.yy"
     8128#line 2052 "parser.yy"
    81278129    {
    81288130                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81338135
    81348136  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:
    81468137
    81478138/* Line 1806 of yacc.c  */
     
    81548145    break;
    81558146
     8147  case 538:
     8148
     8149/* Line 1806 of yacc.c  */
     8150#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
    81568158  case 539:
    81578159
    81588160/* Line 1806 of yacc.c  */
    8159 #line 2064 "parser.yy"
     8161#line 2070 "parser.yy"
    81608162    {
    81618163                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81688170
    81698171/* Line 1806 of yacc.c  */
    8170 #line 2072 "parser.yy"
     8172#line 2078 "parser.yy"
    81718173    {
    81728174                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81798181
    81808182/* Line 1806 of yacc.c  */
    8181 #line 2078 "parser.yy"
     8183#line 2084 "parser.yy"
    81828184    {
    81838185                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81908192
    81918193/* Line 1806 of yacc.c  */
    8192 #line 2086 "parser.yy"
     8194#line 2092 "parser.yy"
    81938195    {
    81948196                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    82018203
    82028204/* Line 1806 of yacc.c  */
    8203 #line 2092 "parser.yy"
     8205#line 2098 "parser.yy"
    82048206    {
    82058207                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    82128214
    82138215/* Line 1806 of yacc.c  */
    8214 #line 2107 "parser.yy"
    8215     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ); }
     8216#line 2113 "parser.yy"
     8217    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Range, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    82168218    break;
    82178219
     
    82198221
    82208222/* Line 1806 of yacc.c  */
    8221 #line 2117 "parser.yy"
     8223#line 2123 "parser.yy"
    82228224    { (yyval.decl) = 0; }
    82238225    break;
     
    82268228
    82278229/* Line 1806 of yacc.c  */
    8228 #line 2124 "parser.yy"
     8230#line 2130 "parser.yy"
    82298231    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    82308232    break;
     
    82338235
    82348236/* Line 1806 of yacc.c  */
    8235 #line 2130 "parser.yy"
     8237#line 2136 "parser.yy"
    82368238    { (yyval.decl) = 0; }
    82378239    break;
     
    82408242
    82418243/* Line 1806 of yacc.c  */
    8242 #line 2145 "parser.yy"
     8244#line 2151 "parser.yy"
    82438245    {}
    82448246    break;
     
    82478249
    82488250/* Line 1806 of yacc.c  */
    8249 #line 2146 "parser.yy"
     8251#line 2152 "parser.yy"
    82508252    {}
    82518253    break;
     
    82548256
    82558257/* Line 1806 of yacc.c  */
    8256 #line 2147 "parser.yy"
     8258#line 2153 "parser.yy"
    82578259    {}
    82588260    break;
     
    82618263
    82628264/* Line 1806 of yacc.c  */
    8263 #line 2148 "parser.yy"
     8265#line 2154 "parser.yy"
    82648266    {}
    82658267    break;
     
    82688270
    82698271/* Line 1806 of yacc.c  */
    8270 #line 2183 "parser.yy"
     8272#line 2189 "parser.yy"
    82718273    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82728274    break;
     
    82758277
    82768278/* Line 1806 of yacc.c  */
    8277 #line 2186 "parser.yy"
     8279#line 2192 "parser.yy"
    82788280    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82798281    break;
     
    82828284
    82838285/* Line 1806 of yacc.c  */
    8284 #line 2188 "parser.yy"
     8286#line 2194 "parser.yy"
    82858287    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82868288    break;
     
    82898291
    82908292/* Line 1806 of yacc.c  */
    8291 #line 2193 "parser.yy"
     8293#line 2199 "parser.yy"
    82928294    {
    82938295                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    82998301
    83008302/* Line 1806 of yacc.c  */
    8301 #line 2198 "parser.yy"
     8303#line 2204 "parser.yy"
    83028304    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83038305    break;
     
    83068308
    83078309/* Line 1806 of yacc.c  */
    8308 #line 2203 "parser.yy"
     8310#line 2209 "parser.yy"
    83098311    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    83108312    break;
     
    83138315
    83148316/* Line 1806 of yacc.c  */
    8315 #line 2205 "parser.yy"
     8317#line 2211 "parser.yy"
    83168318    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    83178319    break;
     
    83208322
    83218323/* Line 1806 of yacc.c  */
    8322 #line 2207 "parser.yy"
     8324#line 2213 "parser.yy"
    83238325    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83248326    break;
     
    83278329
    83288330/* Line 1806 of yacc.c  */
    8329 #line 2212 "parser.yy"
     8331#line 2218 "parser.yy"
    83308332    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    83318333    break;
     
    83348336
    83358337/* Line 1806 of yacc.c  */
    8336 #line 2214 "parser.yy"
     8338#line 2220 "parser.yy"
    83378339    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83388340    break;
     
    83418343
    83428344/* Line 1806 of yacc.c  */
    8343 #line 2216 "parser.yy"
     8345#line 2222 "parser.yy"
    83448346    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83458347    break;
     
    83488350
    83498351/* Line 1806 of yacc.c  */
    8350 #line 2218 "parser.yy"
     8352#line 2224 "parser.yy"
    83518353    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83528354    break;
     
    83558357
    83568358/* Line 1806 of yacc.c  */
    8357 #line 2223 "parser.yy"
     8359#line 2229 "parser.yy"
    83588360    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83598361    break;
     
    83628364
    83638365/* Line 1806 of yacc.c  */
    8364 #line 2225 "parser.yy"
     8366#line 2231 "parser.yy"
    83658367    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83668368    break;
     
    83698371
    83708372/* Line 1806 of yacc.c  */
    8371 #line 2234 "parser.yy"
     8373#line 2240 "parser.yy"
    83728374    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83738375    break;
     
    83768378
    83778379/* Line 1806 of yacc.c  */
    8378 #line 2237 "parser.yy"
     8380#line 2243 "parser.yy"
    83798381    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83808382    break;
     
    83838385
    83848386/* Line 1806 of yacc.c  */
    8385 #line 2242 "parser.yy"
     8387#line 2248 "parser.yy"
    83868388    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    83878389    break;
     
    83908392
    83918393/* Line 1806 of yacc.c  */
    8392 #line 2244 "parser.yy"
     8394#line 2250 "parser.yy"
    83938395    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83948396    break;
     
    83978399
    83988400/* Line 1806 of yacc.c  */
    8399 #line 2246 "parser.yy"
     8401#line 2252 "parser.yy"
    84008402    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84018403    break;
     
    84048406
    84058407/* Line 1806 of yacc.c  */
    8406 #line 2251 "parser.yy"
     8408#line 2257 "parser.yy"
    84078409    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    84088410    break;
     
    84118413
    84128414/* Line 1806 of yacc.c  */
    8413 #line 2253 "parser.yy"
     8415#line 2259 "parser.yy"
    84148416    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84158417    break;
     
    84188420
    84198421/* Line 1806 of yacc.c  */
    8420 #line 2255 "parser.yy"
     8422#line 2261 "parser.yy"
    84218423    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84228424    break;
     
    84258427
    84268428/* Line 1806 of yacc.c  */
    8427 #line 2260 "parser.yy"
     8429#line 2266 "parser.yy"
    84288430    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84298431    break;
     
    84328434
    84338435/* Line 1806 of yacc.c  */
    8434 #line 2262 "parser.yy"
     8436#line 2268 "parser.yy"
    84358437    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84368438    break;
     
    84398441
    84408442/* Line 1806 of yacc.c  */
    8441 #line 2264 "parser.yy"
     8443#line 2270 "parser.yy"
    84428444    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84438445    break;
     
    84468448
    84478449/* Line 1806 of yacc.c  */
    8448 #line 2279 "parser.yy"
     8450#line 2285 "parser.yy"
    84498451    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    84508452    break;
     
    84538455
    84548456/* Line 1806 of yacc.c  */
    8455 #line 2281 "parser.yy"
     8457#line 2287 "parser.yy"
    84568458    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    84578459    break;
     
    84608462
    84618463/* Line 1806 of yacc.c  */
    8462 #line 2283 "parser.yy"
     8464#line 2289 "parser.yy"
    84638465    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84648466    break;
     
    84678469
    84688470/* Line 1806 of yacc.c  */
    8469 #line 2288 "parser.yy"
     8471#line 2294 "parser.yy"
    84708472    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    84718473    break;
     
    84748476
    84758477/* Line 1806 of yacc.c  */
    8476 #line 2290 "parser.yy"
     8478#line 2296 "parser.yy"
    84778479    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84788480    break;
     
    84818483
    84828484/* Line 1806 of yacc.c  */
    8483 #line 2292 "parser.yy"
     8485#line 2298 "parser.yy"
    84848486    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84858487    break;
     
    84888490
    84898491/* Line 1806 of yacc.c  */
    8490 #line 2297 "parser.yy"
     8492#line 2303 "parser.yy"
    84918493    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84928494    break;
     
    84958497
    84968498/* Line 1806 of yacc.c  */
    8497 #line 2299 "parser.yy"
     8499#line 2305 "parser.yy"
    84988500    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84998501    break;
     
    85028504
    85038505/* Line 1806 of yacc.c  */
    8504 #line 2301 "parser.yy"
     8506#line 2307 "parser.yy"
    85058507    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85068508    break;
     
    85098511
    85108512/* Line 1806 of yacc.c  */
    8511 #line 2316 "parser.yy"
     8513#line 2322 "parser.yy"
    85128514    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85138515    break;
     
    85168518
    85178519/* Line 1806 of yacc.c  */
    8518 #line 2319 "parser.yy"
     8520#line 2325 "parser.yy"
    85198521    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85208522    break;
     
    85238525
    85248526/* Line 1806 of yacc.c  */
    8525 #line 2321 "parser.yy"
     8527#line 2327 "parser.yy"
    85268528    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85278529    break;
     
    85308532
    85318533/* Line 1806 of yacc.c  */
    8532 #line 2327 "parser.yy"
     8534#line 2333 "parser.yy"
    85338535    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85348536    break;
     
    85378539
    85388540/* Line 1806 of yacc.c  */
    8539 #line 2332 "parser.yy"
     8541#line 2338 "parser.yy"
    85408542    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    85418543    break;
     
    85448546
    85458547/* Line 1806 of yacc.c  */
    8546 #line 2334 "parser.yy"
     8548#line 2340 "parser.yy"
    85478549    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    85488550    break;
     
    85518553
    85528554/* Line 1806 of yacc.c  */
    8553 #line 2336 "parser.yy"
     8555#line 2342 "parser.yy"
    85548556    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85558557    break;
     
    85588560
    85598561/* Line 1806 of yacc.c  */
    8560 #line 2341 "parser.yy"
     8562#line 2347 "parser.yy"
    85618563    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    85628564    break;
     
    85658567
    85668568/* Line 1806 of yacc.c  */
    8567 #line 2343 "parser.yy"
     8569#line 2349 "parser.yy"
    85688570    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85698571    break;
     
    85728574
    85738575/* Line 1806 of yacc.c  */
    8574 #line 2345 "parser.yy"
     8576#line 2351 "parser.yy"
    85758577    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85768578    break;
     
    85798581
    85808582/* Line 1806 of yacc.c  */
    8581 #line 2347 "parser.yy"
     8583#line 2353 "parser.yy"
    85828584    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85838585    break;
     
    85868588
    85878589/* Line 1806 of yacc.c  */
    8588 #line 2352 "parser.yy"
     8590#line 2358 "parser.yy"
    85898591    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    85908592    break;
     
    85938595
    85948596/* Line 1806 of yacc.c  */
    8595 #line 2354 "parser.yy"
     8597#line 2360 "parser.yy"
    85968598    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85978599    break;
     
    86008602
    86018603/* Line 1806 of yacc.c  */
    8602 #line 2356 "parser.yy"
     8604#line 2362 "parser.yy"
    86038605    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86048606    break;
     
    86078609
    86088610/* Line 1806 of yacc.c  */
    8609 #line 2366 "parser.yy"
     8611#line 2372 "parser.yy"
    86108612    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86118613    break;
     
    86148616
    86158617/* Line 1806 of yacc.c  */
    8616 #line 2369 "parser.yy"
     8618#line 2375 "parser.yy"
    86178619    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86188620    break;
     
    86218623
    86228624/* Line 1806 of yacc.c  */
    8623 #line 2371 "parser.yy"
     8625#line 2377 "parser.yy"
    86248626    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86258627    break;
     
    86288630
    86298631/* Line 1806 of yacc.c  */
    8630 #line 2376 "parser.yy"
     8632#line 2382 "parser.yy"
    86318633    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    86328634    break;
     
    86358637
    86368638/* Line 1806 of yacc.c  */
    8637 #line 2378 "parser.yy"
     8639#line 2384 "parser.yy"
    86388640    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    86398641    break;
     
    86428644
    86438645/* Line 1806 of yacc.c  */
    8644 #line 2380 "parser.yy"
     8646#line 2386 "parser.yy"
    86458647    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86468648    break;
     
    86498651
    86508652/* Line 1806 of yacc.c  */
    8651 #line 2385 "parser.yy"
     8653#line 2391 "parser.yy"
    86528654    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    86538655    break;
     
    86568658
    86578659/* Line 1806 of yacc.c  */
    8658 #line 2387 "parser.yy"
     8660#line 2393 "parser.yy"
    86598661    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86608662    break;
     
    86638665
    86648666/* Line 1806 of yacc.c  */
    8665 #line 2389 "parser.yy"
     8667#line 2395 "parser.yy"
    86668668    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86678669    break;
     
    86708672
    86718673/* Line 1806 of yacc.c  */
    8672 #line 2391 "parser.yy"
     8674#line 2397 "parser.yy"
    86738675    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86748676    break;
     
    86778679
    86788680/* Line 1806 of yacc.c  */
    8679 #line 2396 "parser.yy"
     8681#line 2402 "parser.yy"
    86808682    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    86818683    break;
     
    86848686
    86858687/* Line 1806 of yacc.c  */
    8686 #line 2398 "parser.yy"
     8688#line 2404 "parser.yy"
    86878689    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    86888690    break;
     
    86918693
    86928694/* Line 1806 of yacc.c  */
    8693 #line 2400 "parser.yy"
     8695#line 2406 "parser.yy"
    86948696    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86958697    break;
     
    86988700
    86998701/* Line 1806 of yacc.c  */
    8700 #line 2431 "parser.yy"
     8702#line 2437 "parser.yy"
    87018703    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87028704    break;
     
    87058707
    87068708/* Line 1806 of yacc.c  */
    8707 #line 2434 "parser.yy"
     8709#line 2440 "parser.yy"
    87088710    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87098711    break;
     
    87128714
    87138715/* Line 1806 of yacc.c  */
    8714 #line 2436 "parser.yy"
     8716#line 2442 "parser.yy"
    87158717    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87168718    break;
     
    87198721
    87208722/* Line 1806 of yacc.c  */
    8721 #line 2441 "parser.yy"
     8723#line 2447 "parser.yy"
    87228724    {
    87238725                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    87298731
    87308732/* Line 1806 of yacc.c  */
    8731 #line 2446 "parser.yy"
     8733#line 2452 "parser.yy"
    87328734    {
    87338735                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    87398741
    87408742/* Line 1806 of yacc.c  */
    8741 #line 2454 "parser.yy"
     8743#line 2460 "parser.yy"
    87428744    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    87438745    break;
     
    87468748
    87478749/* Line 1806 of yacc.c  */
    8748 #line 2456 "parser.yy"
     8750#line 2462 "parser.yy"
    87498751    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    87508752    break;
     
    87538755
    87548756/* Line 1806 of yacc.c  */
    8755 #line 2458 "parser.yy"
     8757#line 2464 "parser.yy"
    87568758    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87578759    break;
     
    87608762
    87618763/* Line 1806 of yacc.c  */
    8762 #line 2463 "parser.yy"
     8764#line 2469 "parser.yy"
    87638765    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    87648766    break;
     
    87678769
    87688770/* Line 1806 of yacc.c  */
    8769 #line 2465 "parser.yy"
     8771#line 2471 "parser.yy"
    87708772    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87718773    break;
     
    87748776
    87758777/* Line 1806 of yacc.c  */
    8776 #line 2470 "parser.yy"
     8778#line 2476 "parser.yy"
    87778779    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    87788780    break;
     
    87818783
    87828784/* Line 1806 of yacc.c  */
    8783 #line 2472 "parser.yy"
     8785#line 2478 "parser.yy"
    87848786    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87858787    break;
     
    87888790
    87898791/* Line 1806 of yacc.c  */
    8790 #line 2487 "parser.yy"
     8792#line 2493 "parser.yy"
    87918793    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87928794    break;
     
    87958797
    87968798/* Line 1806 of yacc.c  */
    8797 #line 2489 "parser.yy"
     8799#line 2495 "parser.yy"
    87988800    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87998801    break;
     
    88028804
    88038805/* Line 1806 of yacc.c  */
    8804 #line 2494 "parser.yy"
     8806#line 2500 "parser.yy"
    88058807    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    88068808    break;
     
    88098811
    88108812/* Line 1806 of yacc.c  */
    8811 #line 2496 "parser.yy"
     8813#line 2502 "parser.yy"
    88128814    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    88138815    break;
     
    88168818
    88178819/* Line 1806 of yacc.c  */
    8818 #line 2498 "parser.yy"
     8820#line 2504 "parser.yy"
    88198821    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    88208822    break;
     
    88238825
    88248826/* Line 1806 of yacc.c  */
    8825 #line 2500 "parser.yy"
     8827#line 2506 "parser.yy"
    88268828    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    88278829    break;
     
    88308832
    88318833/* Line 1806 of yacc.c  */
    8832 #line 2502 "parser.yy"
     8834#line 2508 "parser.yy"
    88338835    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88348836    break;
     
    88378839
    88388840/* Line 1806 of yacc.c  */
    8839 #line 2508 "parser.yy"
     8841#line 2514 "parser.yy"
    88408842    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    88418843    break;
     
    88448846
    88458847/* Line 1806 of yacc.c  */
    8846 #line 2510 "parser.yy"
     8848#line 2516 "parser.yy"
    88478849    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    88488850    break;
     
    88518853
    88528854/* Line 1806 of yacc.c  */
    8853 #line 2512 "parser.yy"
     8855#line 2518 "parser.yy"
    88548856    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88558857    break;
     
    88588860
    88598861/* Line 1806 of yacc.c  */
    8860 #line 2517 "parser.yy"
     8862#line 2523 "parser.yy"
    88618863    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    88628864    break;
     
    88658867
    88668868/* Line 1806 of yacc.c  */
    8867 #line 2519 "parser.yy"
     8869#line 2525 "parser.yy"
    88688870    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    88698871    break;
     
    88728874
    88738875/* Line 1806 of yacc.c  */
    8874 #line 2521 "parser.yy"
     8876#line 2527 "parser.yy"
    88758877    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88768878    break;
     
    88798881
    88808882/* Line 1806 of yacc.c  */
    8881 #line 2527 "parser.yy"
     8883#line 2533 "parser.yy"
    88828884    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    88838885    break;
     
    88868888
    88878889/* Line 1806 of yacc.c  */
    8888 #line 2529 "parser.yy"
     8890#line 2535 "parser.yy"
    88898891    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    88908892    break;
     
    88938895
    88948896/* Line 1806 of yacc.c  */
    8895 #line 2535 "parser.yy"
     8897#line 2541 "parser.yy"
    88968898    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    88978899    break;
     
    89008902
    89018903/* Line 1806 of yacc.c  */
    8902 #line 2537 "parser.yy"
     8904#line 2543 "parser.yy"
    89038905    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    89048906    break;
     
    89078909
    89088910/* Line 1806 of yacc.c  */
    8909 #line 2539 "parser.yy"
     8911#line 2545 "parser.yy"
    89108912    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    89118913    break;
     
    89148916
    89158917/* Line 1806 of yacc.c  */
    8916 #line 2541 "parser.yy"
     8918#line 2547 "parser.yy"
    89178919    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    89188920    break;
     
    89218923
    89228924/* Line 1806 of yacc.c  */
    8923 #line 2556 "parser.yy"
     8925#line 2562 "parser.yy"
    89248926    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    89258927    break;
     
    89288930
    89298931/* Line 1806 of yacc.c  */
    8930 #line 2558 "parser.yy"
     8932#line 2564 "parser.yy"
    89318933    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    89328934    break;
     
    89358937
    89368938/* Line 1806 of yacc.c  */
    8937 #line 2563 "parser.yy"
     8939#line 2569 "parser.yy"
    89388940    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    89398941    break;
     
    89428944
    89438945/* Line 1806 of yacc.c  */
    8944 #line 2565 "parser.yy"
     8946#line 2571 "parser.yy"
    89458947    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    89468948    break;
     
    89498951
    89508952/* Line 1806 of yacc.c  */
    8951 #line 2567 "parser.yy"
     8953#line 2573 "parser.yy"
    89528954    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    89538955    break;
     
    89568958
    89578959/* Line 1806 of yacc.c  */
    8958 #line 2569 "parser.yy"
     8960#line 2575 "parser.yy"
    89598961    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    89608962    break;
     
    89638965
    89648966/* Line 1806 of yacc.c  */
    8965 #line 2571 "parser.yy"
     8967#line 2577 "parser.yy"
    89668968    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89678969    break;
     
    89708972
    89718973/* Line 1806 of yacc.c  */
    8972 #line 2577 "parser.yy"
     8974#line 2583 "parser.yy"
    89738975    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    89748976    break;
     
    89778979
    89788980/* Line 1806 of yacc.c  */
    8979 #line 2579 "parser.yy"
     8981#line 2585 "parser.yy"
    89808982    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    89818983    break;
     
    89848986
    89858987/* Line 1806 of yacc.c  */
    8986 #line 2581 "parser.yy"
     8988#line 2587 "parser.yy"
    89878989    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89888990    break;
     
    89918993
    89928994/* Line 1806 of yacc.c  */
    8993 #line 2586 "parser.yy"
     8995#line 2592 "parser.yy"
    89948996    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    89958997    break;
     
    89989000
    89999001/* Line 1806 of yacc.c  */
    9000 #line 2588 "parser.yy"
     9002#line 2594 "parser.yy"
    90019003    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    90029004    break;
     
    90059007
    90069008/* Line 1806 of yacc.c  */
    9007 #line 2590 "parser.yy"
     9009#line 2596 "parser.yy"
    90089010    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    90099011    break;
     
    90129014
    90139015/* Line 1806 of yacc.c  */
    9014 #line 2597 "parser.yy"
     9016#line 2603 "parser.yy"
    90159017    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    90169018    break;
     
    90199021
    90209022/* Line 1806 of yacc.c  */
    9021 #line 2608 "parser.yy"
     9023#line 2614 "parser.yy"
    90229024    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    90239025    break;
     
    90269028
    90279029/* Line 1806 of yacc.c  */
    9028 #line 2611 "parser.yy"
     9030#line 2617 "parser.yy"
    90299031    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    90309032    break;
     
    90339035
    90349036/* Line 1806 of yacc.c  */
    9035 #line 2613 "parser.yy"
     9037#line 2619 "parser.yy"
    90369038    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    90379039    break;
     
    90409042
    90419043/* Line 1806 of yacc.c  */
    9042 #line 2616 "parser.yy"
     9044#line 2622 "parser.yy"
    90439045    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    90449046    break;
     
    90479049
    90489050/* Line 1806 of yacc.c  */
    9049 #line 2618 "parser.yy"
     9051#line 2624 "parser.yy"
    90509052    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    90519053    break;
     
    90549056
    90559057/* Line 1806 of yacc.c  */
    9056 #line 2620 "parser.yy"
     9058#line 2626 "parser.yy"
    90579059    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    90589060    break;
     
    90619063
    90629064/* Line 1806 of yacc.c  */
    9063 #line 2634 "parser.yy"
     9065#line 2640 "parser.yy"
    90649066    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    90659067    break;
     
    90689070
    90699071/* Line 1806 of yacc.c  */
    9070 #line 2636 "parser.yy"
     9072#line 2642 "parser.yy"
    90719073    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    90729074    break;
     
    90759077
    90769078/* Line 1806 of yacc.c  */
    9077 #line 2641 "parser.yy"
     9079#line 2647 "parser.yy"
    90789080    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    90799081    break;
     
    90829084
    90839085/* Line 1806 of yacc.c  */
    9084 #line 2643 "parser.yy"
     9086#line 2649 "parser.yy"
    90859087    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    90869088    break;
     
    90899091
    90909092/* Line 1806 of yacc.c  */
    9091 #line 2645 "parser.yy"
     9093#line 2651 "parser.yy"
    90929094    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    90939095    break;
     
    90969098
    90979099/* Line 1806 of yacc.c  */
    9098 #line 2647 "parser.yy"
     9100#line 2653 "parser.yy"
    90999101    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    91009102    break;
     
    91039105
    91049106/* Line 1806 of yacc.c  */
    9105 #line 2649 "parser.yy"
     9107#line 2655 "parser.yy"
    91069108    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    91079109    break;
     
    91109112
    91119113/* Line 1806 of yacc.c  */
    9112 #line 2655 "parser.yy"
     9114#line 2661 "parser.yy"
    91139115    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    91149116    break;
     
    91179119
    91189120/* Line 1806 of yacc.c  */
    9119 #line 2657 "parser.yy"
     9121#line 2663 "parser.yy"
    91209122    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    91219123    break;
     
    91249126
    91259127/* Line 1806 of yacc.c  */
    9126 #line 2659 "parser.yy"
     9128#line 2665 "parser.yy"
    91279129    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    91289130    break;
     
    91319133
    91329134/* Line 1806 of yacc.c  */
    9133 #line 2664 "parser.yy"
     9135#line 2670 "parser.yy"
    91349136    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    91359137    break;
     
    91389140
    91399141/* Line 1806 of yacc.c  */
    9140 #line 2666 "parser.yy"
     9142#line 2672 "parser.yy"
    91419143    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    91429144    break;
     
    91459147
    91469148/* Line 1806 of yacc.c  */
    9147 #line 2676 "parser.yy"
     9149#line 2682 "parser.yy"
    91489150    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    91499151    break;
     
    91529154
    91539155/* Line 1806 of yacc.c  */
    9154 #line 2686 "parser.yy"
     9156#line 2692 "parser.yy"
    91559157    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91569158    break;
     
    91599161
    91609162/* Line 1806 of yacc.c  */
    9161 #line 2688 "parser.yy"
     9163#line 2694 "parser.yy"
    91629164    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91639165    break;
     
    91669168
    91679169/* Line 1806 of yacc.c  */
    9168 #line 2690 "parser.yy"
     9170#line 2696 "parser.yy"
    91699171    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91709172    break;
     
    91739175
    91749176/* Line 1806 of yacc.c  */
    9175 #line 2692 "parser.yy"
     9177#line 2698 "parser.yy"
    91769178    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91779179    break;
     
    91809182
    91819183/* Line 1806 of yacc.c  */
    9182 #line 2694 "parser.yy"
     9184#line 2700 "parser.yy"
    91839185    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91849186    break;
     
    91879189
    91889190/* Line 1806 of yacc.c  */
    9189 #line 2696 "parser.yy"
     9191#line 2702 "parser.yy"
    91909192    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91919193    break;
     
    91949196
    91959197/* Line 1806 of yacc.c  */
    9196 #line 2703 "parser.yy"
     9198#line 2709 "parser.yy"
    91979199    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    91989200    break;
    91999201
    92009202  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  */
    9217 #line 2709 "parser.yy"
    9218     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    9219     break;
    9220 
    9221   case 721:
    92229203
    92239204/* Line 1806 of yacc.c  */
     
    92269207    break;
    92279208
     9209  case 719:
     9210
     9211/* Line 1806 of yacc.c  */
     9212#line 2713 "parser.yy"
     9213    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9214    break;
     9215
     9216  case 720:
     9217
     9218/* Line 1806 of yacc.c  */
     9219#line 2715 "parser.yy"
     9220    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     9221    break;
     9222
     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
    92289230  case 722:
    92299231
    92309232/* Line 1806 of yacc.c  */
    9231 #line 2713 "parser.yy"
     9233#line 2719 "parser.yy"
    92329234    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    92339235    break;
    92349236
    92359237  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"
    9246     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9247     break;
    9248 
    9249   case 725:
    9250 
    9251 /* Line 1806 of yacc.c  */
    9252 #line 2719 "parser.yy"
    9253     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    9254     break;
    9255 
    9256   case 726:
    92579238
    92589239/* Line 1806 of yacc.c  */
     
    92619242    break;
    92629243
     9244  case 724:
     9245
     9246/* Line 1806 of yacc.c  */
     9247#line 2723 "parser.yy"
     9248    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9249    break;
     9250
     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"
     9262    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     9263    break;
     9264
    92639265  case 727:
    92649266
    92659267/* Line 1806 of yacc.c  */
    9266 #line 2726 "parser.yy"
     9268#line 2732 "parser.yy"
    92679269    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    92689270    break;
     
    92719273
    92729274/* Line 1806 of yacc.c  */
    9273 #line 2728 "parser.yy"
     9275#line 2734 "parser.yy"
    92749276    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    92759277    break;
     
    92789280
    92799281/* Line 1806 of yacc.c  */
    9280 #line 2733 "parser.yy"
     9282#line 2739 "parser.yy"
    92819283    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
    92829284    break;
     
    92859287
    92869288/* Line 1806 of yacc.c  */
    9287 #line 2735 "parser.yy"
     9289#line 2741 "parser.yy"
    92889290    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
    92899291    break;
     
    92929294
    92939295/* Line 1806 of yacc.c  */
    9294 #line 2762 "parser.yy"
     9296#line 2768 "parser.yy"
    92959297    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    92969298    break;
     
    92999301
    93009302/* Line 1806 of yacc.c  */
    9301 #line 2773 "parser.yy"
     9303#line 2779 "parser.yy"
    93029304    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    93039305    break;
     
    93069308
    93079309/* Line 1806 of yacc.c  */
    9308 #line 2775 "parser.yy"
     9310#line 2781 "parser.yy"
    93099311    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    93109312    break;
     
    93139315
    93149316/* Line 1806 of yacc.c  */
    9315 #line 2777 "parser.yy"
     9317#line 2783 "parser.yy"
    93169318    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    93179319    break;
     
    93209322
    93219323/* Line 1806 of yacc.c  */
    9322 #line 2779 "parser.yy"
     9324#line 2785 "parser.yy"
    93239325    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    93249326    break;
     
    93279329
    93289330/* Line 1806 of yacc.c  */
    9329 #line 2781 "parser.yy"
     9331#line 2787 "parser.yy"
    93309332    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    93319333    break;
     
    93349336
    93359337/* Line 1806 of yacc.c  */
    9336 #line 2783 "parser.yy"
     9338#line 2789 "parser.yy"
    93379339    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    93389340    break;
    93399341
    93409342  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"
    9351     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9352     break;
    9353 
    9354   case 744:
    9355 
    9356 /* Line 1806 of yacc.c  */
    9357 #line 2794 "parser.yy"
    9358     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    9359     break;
    9360 
    9361   case 745:
    93629343
    93639344/* Line 1806 of yacc.c  */
     
    93669347    break;
    93679348
    9368   case 746:
     9349  case 743:
    93699350
    93709351/* Line 1806 of yacc.c  */
     
    93739354    break;
    93749355
    9375   case 747:
     9356  case 744:
    93769357
    93779358/* Line 1806 of yacc.c  */
     
    93809361    break;
    93819362
     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
    93829384  case 748:
    93839385
    93849386/* Line 1806 of yacc.c  */
    9385 #line 2805 "parser.yy"
     9387#line 2811 "parser.yy"
    93869388    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    93879389    break;
     
    93909392
    93919393/* Line 1806 of yacc.c  */
    9392 #line 2810 "parser.yy"
     9394#line 2816 "parser.yy"
    93939395    { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); }
    93949396    break;
     
    93979399
    93989400/* Line 1806 of yacc.c  */
    9399 #line 2812 "parser.yy"
     9401#line 2818 "parser.yy"
    94009402    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    94019403    break;
     
    94049406
    94059407/* Line 1806 of yacc.c  */
    9406 #line 2814 "parser.yy"
     9408#line 2820 "parser.yy"
    94079409    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    94089410    break;
     
    94119413
    94129414/* Line 1806 of yacc.c  */
    9413 #line 2838 "parser.yy"
     9415#line 2844 "parser.yy"
    94149416    { (yyval.en) = 0; }
    94159417    break;
     
    94189420
    94199421/* Line 1806 of yacc.c  */
    9420 #line 2840 "parser.yy"
     9422#line 2846 "parser.yy"
    94219423    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    94229424    break;
     
    94259427
    94269428/* Line 1806 of yacc.c  */
    9427 #line 9428 "Parser/parser.cc"
     9429#line 9430 "Parser/parser.cc"
    94289430      default: break;
    94299431    }
     
    96569658
    96579659/* Line 2067 of yacc.c  */
    9658 #line 2843 "parser.yy"
     9660#line 2849 "parser.yy"
    96599661
    96609662// ----end of grammar----
  • src/Parser/parser.h

    r658fafe4 rdae881f  
    274274        LabelNode *label;
    275275        InitializerNode *in;
     276        OperatorNode::Type op;
    276277        bool flag;
    277278
     
    279280
    280281/* Line 2068 of yacc.c  */
    281 #line 282 "Parser/parser.h"
     282#line 283 "Parser/parser.h"
    282283} YYSTYPE;
    283284# define YYSTYPE_IS_TRIVIAL 1