Changeset 51e076e


Ignore:
Timestamp:
Aug 5, 2016, 8:27:33 AM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
9706554, dae881f
Parents:
b87e2b6
Message:

more refactoring of parser code

Location:
src/Parser
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/ExpressionNode.cc

    rb87e2b6 r51e076e  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  4 16:11:23 2016
    13 // Update Count     : 338
     12// Last Modified On : Fri Aug  5 07:56:23 2016
     13// Update Count     : 375
    1414//
    1515
     
    365365}
    366366
     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
    367391CompositeExprNode2::CompositeExprNode2( Expression *expr ) : expr( expr ) {}
    368392CompositeExprNode2::CompositeExprNode2( const CompositeExprNode2 &other ) : expr( other.expr->clone() ) {}
     
    382406        } // if
    383407
    384         switch ( op->get_type()) {
    385           case OperatorNode::Incr:
    386           case OperatorNode::Decr:
    387           case OperatorNode::IncrPost:
    388           case OperatorNode::DecrPost:
     408        switch ( op->get_type() ) {
    389409          case OperatorNode::Assign:
    390410          case OperatorNode::MulAssn:
     
    398418          case OperatorNode::ERAssn:
    399419          case OperatorNode::OrAssn:
    400                 // the rewrite rules for these expressions specify that the first argument has its address taken
    401420                assert( ! args.empty() );
    402421                args.front() = new AddressExpr( args.front() );
    403                 break;
    404           default:              // do nothing
    405                 ;
    406         } // switch
    407 
    408         switch ( op->get_type() ) {
    409           case OperatorNode::Incr:
    410           case OperatorNode::Decr:
    411           case OperatorNode::IncrPost:
    412           case OperatorNode::DecrPost:
    413           case OperatorNode::Assign:
    414           case OperatorNode::MulAssn:
    415           case OperatorNode::DivAssn:
    416           case OperatorNode::ModAssn:
    417           case OperatorNode::PlusAssn:
    418           case OperatorNode::MinusAssn:
    419           case OperatorNode::LSAssn:
    420           case OperatorNode::RSAssn:
    421           case OperatorNode::AndAssn:
    422           case OperatorNode::ERAssn:
    423           case OperatorNode::OrAssn:
    424           case OperatorNode::Plus:
    425           case OperatorNode::Minus:
    426           case OperatorNode::Mul:
    427           case OperatorNode::Div:
    428           case OperatorNode::Mod:
    429           case OperatorNode::BitOr:
    430           case OperatorNode::BitAnd:
    431           case OperatorNode::Xor:
    432           case OperatorNode::LShift:
    433           case OperatorNode::RShift:
    434           case OperatorNode::LThan:
    435           case OperatorNode::GThan:
    436           case OperatorNode::LEThan:
    437           case OperatorNode::GEThan:
    438           case OperatorNode::Eq:
    439           case OperatorNode::Neq:
    440           case OperatorNode::Index:
    441           case OperatorNode::Range:
    442422          case OperatorNode::UnPlus:
    443423          case OperatorNode::UnMinus:
     
    447427          case OperatorNode::LabelAddress:
    448428                return new UntypedExpr( new NameExpr( opName[ op->get_type() ] ), args );
     429
    449430          case OperatorNode::Attr:
    450431                {
    451                         VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
     432                        VarRefNode *var = dynamic_cast<VarRefNode *>( get_args() );
    452433                        assert( var );
    453434                        if ( ! get_args()->get_link() ) {
    454435                                return new AttrExpr( maybeBuild<Expression>(var), ( Expression*)0);
    455                         } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
    456                                 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() );
    457438                        } else {
    458                                 return new AttrExpr( maybeBuild<Expression>(var), args.back());
     439                                return new AttrExpr( maybeBuild<Expression>(var), args.back() );
    459440                        } // if
    460441                }
    461           case OperatorNode::Or:
    462           case OperatorNode::And:
    463                 assert( args.size() == 2);
    464                 return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) );
    465442          case OperatorNode::Cond:
    466443                {
     
    474451          case OperatorNode::NCond:
    475452                throw UnimplementedError( "GNU 2-argument conditional expression" );
    476           case OperatorNode::Comma:
    477                 {
    478                         assert( args.size() == 2);
    479                         std::list< Expression * >::const_iterator i = args.begin();
    480                         Expression *ret = *i++;
    481                         while ( i != args.end() ) {
    482                                 ret = new CommaExpr( ret, *i++ );
    483                         }
    484                         return ret;
    485                 }
    486453                // Tuples
    487454          case OperatorNode::TupleC:
     
    492459                }
    493460          default:
    494                 // shouldn't happen
    495                 assert( false );
     461                assert( ((void)"CompositeExprNode::build", false) );
    496462                return 0;
    497463        } // switch
  • src/Parser/ParseNode.h

    rb87e2b6 r51e076e  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  4 16:34:16 2016
    13 // Update Count     : 277
     12// Last Modified On : Fri Aug  5 07:49:32 2016
     13// Update Count     : 288
    1414//
    1515
     
    232232Expression *build_alignOf( ExpressionNode *expr_node );
    233233Expression *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;
     254};
    234255
    235256class CompositeExprNode : public ExpressionNode {
     
    258279        ExpressionNode *function;
    259280        ExpressionNode *arguments;
    260 };
    261 
    262 class CompositeExprNode2 : public ExpressionNode {
    263   public:
    264         CompositeExprNode2( Expression *expr );
    265         CompositeExprNode2( const CompositeExprNode2 &other );
    266         virtual ~CompositeExprNode2();
    267 
    268         virtual CompositeExprNode2 *clone() const { return new CompositeExprNode2( *this ); }
    269         virtual Expression *build() const { return expr->clone(); }
    270 
    271         virtual void print( std::ostream &, int indent = 0) const;
    272         virtual void printOneLine( std::ostream &, int indent = 0) const;
    273   private:
    274         Expression *expr;
    275281};
    276282
  • src/Parser/parser.cc

    rb87e2b6 r51e076e  
    10221022     371,   373,   375,   383,   384,   390,   391,   392,   397,   399,
    10231023     404,   405,   409,   413,   415,   417,   419,   424,   427,   429,
    1024      431,   433,   438,   440,   442,   444,   446,   448,   450,   452,
    1025      454,   456,   458,   465,   466,   468,   472,   473,   474,   475,
    1026      479,   480,   482,   487,   488,   490,   492,   497,   498,   500,
    1027      505,   506,   508,   513,   514,   516,   518,   520,   525,   526,
    1028      528,   533,   534,   539,   540,   545,   546,   551,   552,   557,
    1029      558,   563,   564,   566,   568,   573,   578,   579,   581,   583,
    1030      589,   590,   596,   598,   600,   602,   607,   608,   613,   614,
    1031      615,   616,   617,   618,   619,   620,   621,   622,   626,   627,
    1032      633,   634,   640,   641,   642,   643,   644,   645,   646,   647,
    1033      648,   658,   665,   667,   677,   678,   683,   685,   691,   693,
    1034      697,   698,   703,   708,   711,   713,   715,   725,   727,   738,
    1035      739,   741,   745,   747,   751,   752,   757,   758,   762,   767,
    1036      768,   772,   774,   780,   781,   785,   787,   789,   791,   797,
    1037      798,   802,   804,   809,   811,   813,   818,   820,   825,   827,
    1038      831,   834,   838,   841,   845,   847,   851,   853,   860,   862,
    1039      864,   873,   875,   877,   879,   881,   886,   888,   890,   892,
    1040      897,   910,   911,   916,   918,   923,   927,   929,   931,   933,
    1041      935,   941,   942,   948,   949,   953,   954,   959,   961,   967,
    1042      968,   970,   975,   977,   984,   986,   990,   991,   996,   998,
    1043     1002,  1003,  1007,  1009,  1013,  1014,  1018,  1019,  1023,  1024,
    1044     1039,  1040,  1041,  1042,  1043,  1047,  1052,  1059,  1069,  1074,
    1045     1079,  1087,  1092,  1097,  1102,  1107,  1115,  1137,  1142,  1149,
    1046     1151,  1158,  1163,  1168,  1179,  1184,  1189,  1194,  1199,  1208,
    1047     1213,  1221,  1222,  1223,  1224,  1230,  1235,  1243,  1244,  1245,
    1048     1246,  1250,  1251,  1252,  1253,  1258,  1259,  1268,  1269,  1274,
    1049     1275,  1280,  1282,  1284,  1286,  1288,  1291,  1290,  1302,  1303,
    1050     1305,  1315,  1316,  1321,  1325,  1327,  1329,  1331,  1333,  1335,
    1051     1337,  1339,  1344,  1346,  1348,  1350,  1352,  1354,  1356,  1358,
    1052     1360,  1362,  1364,  1366,  1368,  1374,  1375,  1377,  1379,  1381,
    1053     1386,  1387,  1393,  1394,  1396,  1398,  1403,  1405,  1407,  1409,
    1054     1414,  1415,  1417,  1419,  1424,  1425,  1427,  1432,  1433,  1435,
    1055     1437,  1442,  1444,  1446,  1451,  1452,  1456,  1458,  1464,  1463,
    1056     1467,  1469,  1474,  1476,  1482,  1483,  1488,  1489,  1491,  1492,
    1057     1501,  1502,  1504,  1506,  1511,  1513,  1519,  1520,  1522,  1525,
    1058     1528,  1533,  1534,  1539,  1544,  1548,  1550,  1556,  1555,  1562,
    1059     1564,  1570,  1571,  1579,  1580,  1584,  1585,  1586,  1588,  1590,
    1060     1597,  1598,  1600,  1602,  1607,  1608,  1614,  1615,  1619,  1620,
    1061     1625,  1626,  1627,  1629,  1637,  1638,  1640,  1643,  1645,  1649,
    1062     1650,  1651,  1653,  1655,  1659,  1664,  1672,  1673,  1682,  1684,
    1063     1689,  1690,  1691,  1695,  1696,  1697,  1701,  1702,  1703,  1707,
    1064     1708,  1709,  1714,  1715,  1716,  1717,  1723,  1724,  1726,  1731,
    1065     1732,  1737,  1738,  1739,  1740,  1741,  1756,  1757,  1762,  1763,
    1066     1771,  1773,  1775,  1778,  1780,  1782,  1805,  1806,  1808,  1810,
    1067     1815,  1816,  1818,  1823,  1828,  1829,  1835,  1834,  1838,  1842,
    1068     1844,  1846,  1852,  1853,  1858,  1863,  1865,  1870,  1872,  1873,
    1069     1875,  1880,  1882,  1884,  1889,  1891,  1896,  1901,  1909,  1915,
    1070     1914,  1928,  1929,  1934,  1935,  1939,  1944,  1949,  1957,  1962,
    1071     1973,  1974,  1985,  1986,  1992,  1993,  1997,  1998,  1999,  2002,
    1072     2001,  2012,  2021,  2027,  2033,  2042,  2048,  2054,  2060,  2066,
    1073     2074,  2080,  2088,  2094,  2103,  2104,  2105,  2109,  2113,  2115,
    1074     2120,  2121,  2125,  2126,  2131,  2137,  2138,  2141,  2143,  2144,
    1075     2148,  2149,  2150,  2151,  2185,  2187,  2188,  2190,  2195,  2200,
    1076     2205,  2207,  2209,  2214,  2216,  2218,  2220,  2225,  2227,  2236,
    1077     2238,  2239,  2244,  2246,  2248,  2253,  2255,  2257,  2262,  2264,
    1078     2266,  2275,  2276,  2277,  2281,  2283,  2285,  2290,  2292,  2294,
    1079     2299,  2301,  2303,  2318,  2320,  2321,  2323,  2328,  2329,  2334,
    1080     2336,  2338,  2343,  2345,  2347,  2349,  2354,  2356,  2358,  2368,
    1081     2370,  2371,  2373,  2378,  2380,  2382,  2387,  2389,  2391,  2393,
    1082     2398,  2400,  2402,  2433,  2435,  2436,  2438,  2443,  2448,  2456,
    1083     2458,  2460,  2465,  2467,  2472,  2474,  2488,  2489,  2491,  2496,
    1084     2498,  2500,  2502,  2504,  2509,  2510,  2512,  2514,  2519,  2521,
    1085     2523,  2529,  2531,  2533,  2537,  2539,  2541,  2543,  2557,  2558,
    1086     2560,  2565,  2567,  2569,  2571,  2573,  2578,  2579,  2581,  2583,
    1087     2588,  2590,  2592,  2598,  2599,  2601,  2610,  2613,  2615,  2618,
    1088     2620,  2622,  2635,  2636,  2638,  2643,  2645,  2647,  2649,  2651,
    1089     2656,  2657,  2659,  2661,  2666,  2668,  2676,  2677,  2678,  2683,
    1090     2684,  2688,  2690,  2692,  2694,  2696,  2698,  2705,  2707,  2709,
    1091     2711,  2713,  2715,  2717,  2719,  2721,  2723,  2728,  2730,  2732,
    1092     2737,  2763,  2764,  2766,  2770,  2771,  2775,  2777,  2779,  2781,
    1093     2783,  2785,  2792,  2794,  2796,  2798,  2800,  2802,  2807,  2812,
    1094     2814,  2816,  2834,  2836,  2841,  2842
     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
    10951095};
    10961096#endif
     
    52995299/* Line 1806 of yacc.c  */
    53005300#line 358 "parser.yy"
    5301     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Index ), (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ); }
     5301    { (yyval.en) = new CompositeExprNode2( build_opr2( OperatorNode::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
    53025302    break;
    53035303
     
    53275327/* Line 1806 of yacc.c  */
    53285328#line 370 "parser.yy"
    5329     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::IncrPost ), (yyvsp[(1) - (2)].en) ); }
     5329    { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
    53305330    break;
    53315331
     
    53345334/* Line 1806 of yacc.c  */
    53355335#line 372 "parser.yy"
    5336     { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), (yyvsp[(1) - (2)].en) ); }
     5336    { (yyval.en) = new CompositeExprNode2( build_opr1( OperatorNode::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
    53375337    break;
    53385338
     
    54555455
    54565456/* Line 1806 of yacc.c  */
    5457 #line 434 "parser.yy"
    5458     { (yyval.en) = (yyvsp[(1) - (2)].op) == OperatorNode::AddressOf ? (ExpressionNode*) new CompositeExprNode2( build_addressOf( (yyvsp[(2) - (2)].en) ) ) : (ExpressionNode*)new CompositeExprNode( new OperatorNode ( (yyvsp[(1) - (2)].op) ), (yyvsp[(2) - (2)].en) ); }
     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) ); }
    54595460    break;
    54605461
     
    54625463
    54635464/* Line 1806 of yacc.c  */
    5464 #line 439 "parser.yy"
     5465#line 440 "parser.yy"
    54655466    { (yyval.en) = new CompositeExprNode( (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ); }
    54665467    break;
     
    54695470
    54705471/* Line 1806 of yacc.c  */
    5471 #line 441 "parser.yy"
    5472     { (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) ) ); }
    54735474    break;
    54745475
     
    54765477
    54775478/* Line 1806 of yacc.c  */
    5478 #line 443 "parser.yy"
    5479     { (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) ) ); }
    54805481    break;
    54815482
     
    54835484
    54845485/* Line 1806 of yacc.c  */
    5485 #line 445 "parser.yy"
     5486#line 446 "parser.yy"
    54865487    { (yyval.en) = new CompositeExprNode2( build_sizeOf( (yyvsp[(2) - (2)].en) ) ); }
    54875488    break;
     
    54905491
    54915492/* Line 1806 of yacc.c  */
    5492 #line 447 "parser.yy"
     5493#line 448 "parser.yy"
    54935494    { (yyval.en) = new CompositeExprNode2( build_sizeOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    54945495    break;
     
    54975498
    54985499/* Line 1806 of yacc.c  */
    5499 #line 449 "parser.yy"
     5500#line 450 "parser.yy"
    55005501    { (yyval.en) = new CompositeExprNode2( build_offsetOf( new TypeValueNode( (yyvsp[(3) - (6)].decl) ), new VarRefNode( (yyvsp[(5) - (6)].tok) ) ) ); }
    55015502    break;
     
    55045505
    55055506/* Line 1806 of yacc.c  */
    5506 #line 451 "parser.yy"
    5507     { (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) ) ); }
    55085509    break;
    55095510
     
    55115512
    55125513/* Line 1806 of yacc.c  */
    5513 #line 453 "parser.yy"
    5514     { (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) ) ); }
    55155516    break;
    55165517
     
    55185519
    55195520/* Line 1806 of yacc.c  */
    5520 #line 455 "parser.yy"
     5521#line 456 "parser.yy"
    55215522    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ); }
    55225523    break;
     
    55255526
    55265527/* Line 1806 of yacc.c  */
    5527 #line 457 "parser.yy"
     5528#line 458 "parser.yy"
    55285529    { (yyval.en) = new CompositeExprNode2( build_alignOf( (yyvsp[(2) - (2)].en) ) ); }
    55295530    break;
     
    55325533
    55335534/* Line 1806 of yacc.c  */
    5534 #line 459 "parser.yy"
     5535#line 460 "parser.yy"
    55355536    { (yyval.en) = new CompositeExprNode2( build_alignOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    55365537    break;
     
    55395540
    55405541/* Line 1806 of yacc.c  */
    5541 #line 465 "parser.yy"
     5542#line 466 "parser.yy"
    55425543    { (yyval.op) = OperatorNode::PointTo; }
    55435544    break;
     
    55465547
    55475548/* Line 1806 of yacc.c  */
    5548 #line 466 "parser.yy"
     5549#line 467 "parser.yy"
    55495550    { (yyval.op) = OperatorNode::AddressOf; }
    55505551    break;
     
    55535554
    55545555/* Line 1806 of yacc.c  */
    5555 #line 468 "parser.yy"
     5556#line 469 "parser.yy"
    55565557    { (yyval.op) = OperatorNode::And; }
    55575558    break;
     
    55605561
    55615562/* Line 1806 of yacc.c  */
    5562 #line 472 "parser.yy"
     5563#line 473 "parser.yy"
    55635564    { (yyval.en) = new OperatorNode( OperatorNode::UnPlus ); }
    55645565    break;
     
    55675568
    55685569/* Line 1806 of yacc.c  */
    5569 #line 473 "parser.yy"
     5570#line 474 "parser.yy"
    55705571    { (yyval.en) = new OperatorNode( OperatorNode::UnMinus ); }
    55715572    break;
     
    55745575
    55755576/* Line 1806 of yacc.c  */
    5576 #line 474 "parser.yy"
     5577#line 475 "parser.yy"
    55775578    { (yyval.en) = new OperatorNode( OperatorNode::Neg ); }
    55785579    break;
     
    55815582
    55825583/* Line 1806 of yacc.c  */
    5583 #line 475 "parser.yy"
     5584#line 476 "parser.yy"
    55845585    { (yyval.en) = new OperatorNode( OperatorNode::BitNeg ); }
    55855586    break;
     
    55885589
    55895590/* Line 1806 of yacc.c  */
    5590 #line 481 "parser.yy"
     5591#line 482 "parser.yy"
    55915592    { (yyval.en) = new CompositeExprNode2( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
    55925593    break;
     
    55955596
    55965597/* Line 1806 of yacc.c  */
    5597 #line 483 "parser.yy"
     5598#line 484 "parser.yy"
    55985599    { (yyval.en) = new CompositeExprNode2( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
    55995600    break;
     
    56025603
    56035604/* Line 1806 of yacc.c  */
    5604 #line 489 "parser.yy"
    5605     { (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) ) ); }
    56065607    break;
    56075608
     
    56095610
    56105611/* Line 1806 of yacc.c  */
    5611 #line 491 "parser.yy"
    5612     { (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) ) ); }
    56135614    break;
    56145615
     
    56165617
    56175618/* Line 1806 of yacc.c  */
    5618 #line 493 "parser.yy"
    5619     { (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) ) ); }
    56205621    break;
    56215622
     
    56235624
    56245625/* Line 1806 of yacc.c  */
    5625 #line 499 "parser.yy"
    5626     { (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) ) ); }
    56275628    break;
    56285629
     
    56305631
    56315632/* Line 1806 of yacc.c  */
    5632 #line 501 "parser.yy"
    5633     { (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) ) ); }
    56345635    break;
    56355636
     
    56375638
    56385639/* Line 1806 of yacc.c  */
    5639 #line 507 "parser.yy"
    5640     { (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) ) ); }
    56415642    break;
    56425643
     
    56445645
    56455646/* Line 1806 of yacc.c  */
    5646 #line 509 "parser.yy"
    5647     { (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) ) ); }
    56485649    break;
    56495650
     
    56515652
    56525653/* Line 1806 of yacc.c  */
    5653 #line 515 "parser.yy"
    5654     { (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) ) ); }
    56555656    break;
    56565657
     
    56585659
    56595660/* Line 1806 of yacc.c  */
    5660 #line 517 "parser.yy"
    5661     { (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) ) ); }
    56625663    break;
    56635664
     
    56655666
    56665667/* Line 1806 of yacc.c  */
    5667 #line 519 "parser.yy"
    5668     { (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) ) ); }
    56695670    break;
    56705671
     
    56725673
    56735674/* Line 1806 of yacc.c  */
    5674 #line 521 "parser.yy"
    5675     { (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) ) ); }
    56765677    break;
    56775678
     
    56795680
    56805681/* Line 1806 of yacc.c  */
    5681 #line 527 "parser.yy"
    5682     { (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) ) ); }
    56835684    break;
    56845685
     
    56865687
    56875688/* Line 1806 of yacc.c  */
    5688 #line 529 "parser.yy"
    5689     { (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) ) ); }
    56905691    break;
    56915692
     
    56935694
    56945695/* Line 1806 of yacc.c  */
    5695 #line 535 "parser.yy"
    5696     { (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) ) ); }
    56975698    break;
    56985699
     
    57005701
    57015702/* Line 1806 of yacc.c  */
    5702 #line 541 "parser.yy"
    5703     { (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) ) ); }
    57045705    break;
    57055706
     
    57075708
    57085709/* Line 1806 of yacc.c  */
    5709 #line 547 "parser.yy"
    5710     { (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) ) ); }
    57115712    break;
    57125713
     
    57145715
    57155716/* Line 1806 of yacc.c  */
    5716 #line 553 "parser.yy"
    5717     { (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 ) ); }
    57185719    break;
    57195720
     
    57215722
    57225723/* Line 1806 of yacc.c  */
    5723 #line 559 "parser.yy"
    5724     { (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 ) ); }
    57255726    break;
    57265727
     
    57285729
    57295730/* Line 1806 of yacc.c  */
    5730 #line 565 "parser.yy"
    5731     { (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) ) ); }
    57325733    break;
    57335734
     
    57355736
    57365737/* Line 1806 of yacc.c  */
    5737 #line 567 "parser.yy"
    5738     { (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) ); }
    57395740    break;
    57405741
     
    57425743
    57435744/* Line 1806 of yacc.c  */
    5744 #line 569 "parser.yy"
    5745     { (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) ) ); }
    57465747    break;
    57475748
     
    57495750
    57505751/* Line 1806 of yacc.c  */
    5751 #line 580 "parser.yy"
    5752     { (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) ); }
    57535754    break;
    57545755
     
    57565757
    57575758/* Line 1806 of yacc.c  */
    5758 #line 582 "parser.yy"
    5759     { (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) ); }
    57605761    break;
    57615762
     
    57635764
    57645765/* Line 1806 of yacc.c  */
    5765 #line 584 "parser.yy"
     5766#line 586 "parser.yy"
    57665767    { (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) ); }
    57675768    break;
     
    57705771
    57715772/* Line 1806 of yacc.c  */
    5772 #line 589 "parser.yy"
     5773#line 591 "parser.yy"
    57735774    { (yyval.en) = new NullExprNode; }
    57745775    break;
     
    57775778
    57785779/* Line 1806 of yacc.c  */
    5779 #line 597 "parser.yy"
     5780#line 599 "parser.yy"
    57805781    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ) ); }
    57815782    break;
     
    57845785
    57855786/* Line 1806 of yacc.c  */
    5786 #line 599 "parser.yy"
     5787#line 601 "parser.yy"
    57875788    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (yyvsp[(3) - (5)].en) ); }
    57885789    break;
     
    57915792
    57925793/* Line 1806 of yacc.c  */
    5793 #line 601 "parser.yy"
     5794#line 603 "parser.yy"
    57945795    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ); }
    57955796    break;
     
    57985799
    57995800/* Line 1806 of yacc.c  */
    5800 #line 603 "parser.yy"
     5801#line 605 "parser.yy"
    58015802    { (yyval.en) = new CompositeExprNode( new OperatorNode( OperatorNode::TupleC ), (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( flattenCommas( (yyvsp[(5) - (7)].en) ) ) ); }
    58025803    break;
     
    58055806
    58065807/* Line 1806 of yacc.c  */
    5807 #line 609 "parser.yy"
     5808#line 611 "parser.yy"
    58085809    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    58095810    break;
     
    58125813
    58135814/* Line 1806 of yacc.c  */
    5814 #line 613 "parser.yy"
     5815#line 615 "parser.yy"
    58155816    { (yyval.en) = new OperatorNode( OperatorNode::MulAssn ); }
    58165817    break;
     
    58195820
    58205821/* Line 1806 of yacc.c  */
    5821 #line 614 "parser.yy"
     5822#line 616 "parser.yy"
    58225823    { (yyval.en) = new OperatorNode( OperatorNode::DivAssn ); }
    58235824    break;
     
    58265827
    58275828/* Line 1806 of yacc.c  */
    5828 #line 615 "parser.yy"
     5829#line 617 "parser.yy"
    58295830    { (yyval.en) = new OperatorNode( OperatorNode::ModAssn ); }
    58305831    break;
     
    58335834
    58345835/* Line 1806 of yacc.c  */
    5835 #line 616 "parser.yy"
     5836#line 618 "parser.yy"
    58365837    { (yyval.en) = new OperatorNode( OperatorNode::PlusAssn ); }
    58375838    break;
     
    58405841
    58415842/* Line 1806 of yacc.c  */
    5842 #line 617 "parser.yy"
     5843#line 619 "parser.yy"
    58435844    { (yyval.en) = new OperatorNode( OperatorNode::MinusAssn ); }
    58445845    break;
     
    58475848
    58485849/* Line 1806 of yacc.c  */
    5849 #line 618 "parser.yy"
     5850#line 620 "parser.yy"
    58505851    { (yyval.en) = new OperatorNode( OperatorNode::LSAssn ); }
    58515852    break;
     
    58545855
    58555856/* Line 1806 of yacc.c  */
    5856 #line 619 "parser.yy"
     5857#line 621 "parser.yy"
    58575858    { (yyval.en) = new OperatorNode( OperatorNode::RSAssn ); }
    58585859    break;
     
    58615862
    58625863/* Line 1806 of yacc.c  */
    5863 #line 620 "parser.yy"
     5864#line 622 "parser.yy"
    58645865    { (yyval.en) = new OperatorNode( OperatorNode::AndAssn ); }
    58655866    break;
     
    58685869
    58695870/* Line 1806 of yacc.c  */
    5870 #line 621 "parser.yy"
     5871#line 623 "parser.yy"
    58715872    { (yyval.en) = new OperatorNode( OperatorNode::ERAssn ); }
    58725873    break;
     
    58755876
    58765877/* Line 1806 of yacc.c  */
    5877 #line 622 "parser.yy"
     5878#line 624 "parser.yy"
    58785879    { (yyval.en) = new OperatorNode( OperatorNode::OrAssn ); }
    58795880    break;
     
    58825883
    58835884/* Line 1806 of yacc.c  */
    5884 #line 628 "parser.yy"
    5885     { (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) ) ); }
    58865887    break;
    58875888
     
    58895890
    58905891/* Line 1806 of yacc.c  */
    5891 #line 633 "parser.yy"
     5892#line 636 "parser.yy"
    58925893    { (yyval.en) = 0; }
    58935894    break;
     
    58965897
    58975898/* Line 1806 of yacc.c  */
    5898 #line 642 "parser.yy"
     5899#line 645 "parser.yy"
    58995900    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    59005901    break;
     
    59035904
    59045905/* Line 1806 of yacc.c  */
    5905 #line 649 "parser.yy"
     5906#line 652 "parser.yy"
    59065907    {
    59075908                        Token fn; fn.str = new std::string( "^?{}" ); // location undefined
     
    59145915
    59155916/* Line 1806 of yacc.c  */
    5916 #line 659 "parser.yy"
     5917#line 662 "parser.yy"
    59175918    {
    59185919                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
     
    59235924
    59245925/* Line 1806 of yacc.c  */
    5925 #line 666 "parser.yy"
     5926#line 669 "parser.yy"
    59265927    { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
    59275928    break;
     
    59305931
    59315932/* Line 1806 of yacc.c  */
    5932 #line 673 "parser.yy"
     5933#line 676 "parser.yy"
    59335934    { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); }
    59345935    break;
     
    59375938
    59385939/* Line 1806 of yacc.c  */
    5939 #line 679 "parser.yy"
     5940#line 682 "parser.yy"
    59405941    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    59415942    break;
     
    59445945
    59455946/* Line 1806 of yacc.c  */
    5946 #line 684 "parser.yy"
     5947#line 687 "parser.yy"
    59475948    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    59485949    break;
     
    59515952
    59525953/* Line 1806 of yacc.c  */
    5953 #line 686 "parser.yy"
     5954#line 689 "parser.yy"
    59545955    {   // mark all fields in list
    59555956                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    59625963
    59635964/* Line 1806 of yacc.c  */
    5964 #line 692 "parser.yy"
     5965#line 695 "parser.yy"
    59655966    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    59665967    break;
     
    59695970
    59705971/* Line 1806 of yacc.c  */
    5971 #line 699 "parser.yy"
     5972#line 702 "parser.yy"
    59725973    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    59735974    break;
     
    59765977
    59775978/* Line 1806 of yacc.c  */
    5978 #line 704 "parser.yy"
     5979#line 707 "parser.yy"
    59795980    { (yyval.sn) = new StatementNode( StatementNode::Exp, (yyvsp[(1) - (2)].en), 0 ); }
    59805981    break;
     
    59835984
    59845985/* Line 1806 of yacc.c  */
    5985 #line 710 "parser.yy"
     5986#line 713 "parser.yy"
    59865987    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    59875988    break;
     
    59905991
    59915992/* Line 1806 of yacc.c  */
    5992 #line 712 "parser.yy"
     5993#line 715 "parser.yy"
    59935994    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn) )) ); }
    59945995    break;
     
    59975998
    59985999/* Line 1806 of yacc.c  */
    5999 #line 714 "parser.yy"
     6000#line 717 "parser.yy"
    60006001    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    60016002    break;
     
    60046005
    60056006/* Line 1806 of yacc.c  */
    6006 #line 716 "parser.yy"
     6007#line 719 "parser.yy"
    60076008    {
    60086009                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     
    60196020
    60206021/* Line 1806 of yacc.c  */
    6021 #line 726 "parser.yy"
     6022#line 729 "parser.yy"
    60226023    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    60236024    break;
     
    60266027
    60276028/* Line 1806 of yacc.c  */
    6028 #line 728 "parser.yy"
     6029#line 731 "parser.yy"
    60296030    {
    60306031                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     
    60366037
    60376038/* Line 1806 of yacc.c  */
    6038 #line 738 "parser.yy"
     6039#line 741 "parser.yy"
    60396040    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    60406041    break;
     
    60436044
    60446045/* Line 1806 of yacc.c  */
    6045 #line 740 "parser.yy"
    6046     { (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) ) ); }
    60476048    break;
    60486049
     
    60506051
    60516052/* Line 1806 of yacc.c  */
    6052 #line 745 "parser.yy"
     6053#line 748 "parser.yy"
    60536054    { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(1) - (1)].en), 0 ); }
    60546055    break;
     
    60576058
    60586059/* Line 1806 of yacc.c  */
    6059 #line 747 "parser.yy"
     6060#line 750 "parser.yy"
    60606061    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode( StatementNode::Case, (yyvsp[(3) - (3)].en), 0 ) ) ); }
    60616062    break;
     
    60646065
    60656066/* Line 1806 of yacc.c  */
    6066 #line 751 "parser.yy"
     6067#line 754 "parser.yy"
    60676068    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    60686069    break;
     
    60716072
    60726073/* Line 1806 of yacc.c  */
    6073 #line 752 "parser.yy"
     6074#line 755 "parser.yy"
    60746075    { (yyval.sn) = new StatementNode( StatementNode::Default ); }
    60756076    break;
     
    60786079
    60796080/* Line 1806 of yacc.c  */
    6080 #line 758 "parser.yy"
     6081#line 761 "parser.yy"
    60816082    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
    60826083    break;
     
    60856086
    60866087/* Line 1806 of yacc.c  */
    6087 #line 762 "parser.yy"
     6088#line 765 "parser.yy"
    60886089    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    60896090    break;
     
    60926093
    60936094/* Line 1806 of yacc.c  */
    6094 #line 767 "parser.yy"
     6095#line 770 "parser.yy"
    60956096    { (yyval.sn) = 0; }
    60966097    break;
     
    60996100
    61006101/* Line 1806 of yacc.c  */
    6101 #line 773 "parser.yy"
     6102#line 776 "parser.yy"
    61026103    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    61036104    break;
     
    61066107
    61076108/* Line 1806 of yacc.c  */
    6108 #line 775 "parser.yy"
     6109#line 778 "parser.yy"
    61096110    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    61106111    break;
     
    61136114
    61146115/* Line 1806 of yacc.c  */
    6115 #line 780 "parser.yy"
     6116#line 783 "parser.yy"
    61166117    { (yyval.sn) = 0; }
    61176118    break;
     
    61206121
    61216122/* Line 1806 of yacc.c  */
    6122 #line 786 "parser.yy"
     6123#line 789 "parser.yy"
    61236124    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    61246125    break;
     
    61276128
    61286129/* Line 1806 of yacc.c  */
    6129 #line 788 "parser.yy"
     6130#line 791 "parser.yy"
    61306131    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
    61316132    break;
     
    61346135
    61356136/* Line 1806 of yacc.c  */
    6136 #line 790 "parser.yy"
     6137#line 793 "parser.yy"
    61376138    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    61386139    break;
     
    61416142
    61426143/* Line 1806 of yacc.c  */
    6143 #line 792 "parser.yy"
     6144#line 795 "parser.yy"
    61446145    { (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) ) ) ) ) ) ); }
    61456146    break;
     
    61486149
    61496150/* Line 1806 of yacc.c  */
    6150 #line 797 "parser.yy"
     6151#line 800 "parser.yy"
    61516152    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    61526153    break;
     
    61556156
    61566157/* Line 1806 of yacc.c  */
    6157 #line 803 "parser.yy"
     6158#line 806 "parser.yy"
    61586159    { (yyval.sn) = 0; }
    61596160    break;
     
    61626163
    61636164/* Line 1806 of yacc.c  */
    6164 #line 805 "parser.yy"
     6165#line 808 "parser.yy"
    61656166    { (yyval.sn) = 0; }
    61666167    break;
     
    61696170
    61706171/* Line 1806 of yacc.c  */
    6171 #line 810 "parser.yy"
     6172#line 813 "parser.yy"
    61726173    { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    61736174    break;
     
    61766177
    61776178/* Line 1806 of yacc.c  */
    6178 #line 812 "parser.yy"
     6179#line 815 "parser.yy"
    61796180    { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); }
    61806181    break;
     
    61836184
    61846185/* Line 1806 of yacc.c  */
    6185 #line 814 "parser.yy"
     6186#line 817 "parser.yy"
    61866187    { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); }
    61876188    break;
     
    61906191
    61916192/* Line 1806 of yacc.c  */
    6192 #line 819 "parser.yy"
     6193#line 822 "parser.yy"
    61936194    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    61946195    break;
     
    61976198
    61986199/* Line 1806 of yacc.c  */
    6199 #line 821 "parser.yy"
     6200#line 824 "parser.yy"
    62006201    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    62016202    break;
     
    62046205
    62056206/* Line 1806 of yacc.c  */
    6206 #line 826 "parser.yy"
     6207#line 829 "parser.yy"
    62076208    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
    62086209    break;
     
    62116212
    62126213/* Line 1806 of yacc.c  */
    6213 #line 830 "parser.yy"
     6214#line 833 "parser.yy"
    62146215    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
    62156216    break;
     
    62186219
    62196220/* Line 1806 of yacc.c  */
    6220 #line 833 "parser.yy"
     6221#line 836 "parser.yy"
    62216222    { (yyval.sn) = new StatementNode( StatementNode::Continue ); }
    62226223    break;
     
    62256226
    62266227/* Line 1806 of yacc.c  */
    6227 #line 837 "parser.yy"
     6228#line 840 "parser.yy"
    62286229    { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
    62296230    break;
     
    62326233
    62336234/* Line 1806 of yacc.c  */
    6234 #line 840 "parser.yy"
     6235#line 843 "parser.yy"
    62356236    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    62366237    break;
     
    62396240
    62406241/* Line 1806 of yacc.c  */
    6241 #line 844 "parser.yy"
     6242#line 847 "parser.yy"
    62426243    { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
    62436244    break;
     
    62466247
    62476248/* Line 1806 of yacc.c  */
    6248 #line 846 "parser.yy"
     6249#line 849 "parser.yy"
    62496250    { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); }
    62506251    break;
     
    62536254
    62546255/* Line 1806 of yacc.c  */
    6255 #line 848 "parser.yy"
     6256#line 851 "parser.yy"
    62566257    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    62576258    break;
     
    62606261
    62616262/* Line 1806 of yacc.c  */
    6262 #line 852 "parser.yy"
     6263#line 855 "parser.yy"
    62636264    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    62646265    break;
     
    62676268
    62686269/* Line 1806 of yacc.c  */
    6269 #line 854 "parser.yy"
     6270#line 857 "parser.yy"
    62706271    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (5)].en), 0 ); }
    62716272    break;
     
    62746275
    62756276/* Line 1806 of yacc.c  */
    6276 #line 861 "parser.yy"
     6277#line 864 "parser.yy"
    62776278    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    62786279    break;
     
    62816282
    62826283/* Line 1806 of yacc.c  */
    6283 #line 863 "parser.yy"
     6284#line 866 "parser.yy"
    62846285    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    62856286    break;
     
    62886289
    62896290/* Line 1806 of yacc.c  */
    6290 #line 865 "parser.yy"
     6291#line 868 "parser.yy"
    62916292    {
    62926293                        (yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) );
     
    62986299
    62996300/* Line 1806 of yacc.c  */
    6300 #line 876 "parser.yy"
     6301#line 879 "parser.yy"
    63016302    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    63026303    break;
     
    63056306
    63066307/* Line 1806 of yacc.c  */
    6307 #line 878 "parser.yy"
     6308#line 881 "parser.yy"
    63086309    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    63096310    break;
     
    63126313
    63136314/* Line 1806 of yacc.c  */
    6314 #line 880 "parser.yy"
     6315#line 883 "parser.yy"
    63156316    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    63166317    break;
     
    63196320
    63206321/* Line 1806 of yacc.c  */
    6321 #line 882 "parser.yy"
     6322#line 885 "parser.yy"
    63226323    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    63236324    break;
     
    63266327
    63276328/* Line 1806 of yacc.c  */
    6328 #line 887 "parser.yy"
     6329#line 890 "parser.yy"
    63296330    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    63306331    break;
     
    63336334
    63346335/* Line 1806 of yacc.c  */
    6335 #line 889 "parser.yy"
     6336#line 892 "parser.yy"
    63366337    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    63376338    break;
     
    63406341
    63416342/* Line 1806 of yacc.c  */
    6342 #line 891 "parser.yy"
     6343#line 894 "parser.yy"
    63436344    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    63446345    break;
     
    63476348
    63486349/* Line 1806 of yacc.c  */
    6349 #line 893 "parser.yy"
     6350#line 896 "parser.yy"
    63506351    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    63516352    break;
     
    63546355
    63556356/* Line 1806 of yacc.c  */
    6356 #line 898 "parser.yy"
     6357#line 901 "parser.yy"
    63576358    {
    63586359                        (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
     
    63646365
    63656366/* Line 1806 of yacc.c  */
    6366 #line 912 "parser.yy"
     6367#line 915 "parser.yy"
    63676368    {
    63686369                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63746375
    63756376/* Line 1806 of yacc.c  */
    6376 #line 917 "parser.yy"
     6377#line 920 "parser.yy"
    63776378    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    63786379    break;
     
    63816382
    63826383/* Line 1806 of yacc.c  */
    6383 #line 919 "parser.yy"
     6384#line 922 "parser.yy"
    63846385    {
    63856386                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63916392
    63926393/* Line 1806 of yacc.c  */
    6393 #line 928 "parser.yy"
     6394#line 931 "parser.yy"
    63946395    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
    63956396    break;
     
    63986399
    63996400/* Line 1806 of yacc.c  */
    6400 #line 930 "parser.yy"
     6401#line 933 "parser.yy"
    64016402    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
    64026403    break;
     
    64056406
    64066407/* Line 1806 of yacc.c  */
    6407 #line 932 "parser.yy"
     6408#line 935 "parser.yy"
    64086409    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
    64096410    break;
     
    64126413
    64136414/* Line 1806 of yacc.c  */
    6414 #line 934 "parser.yy"
     6415#line 937 "parser.yy"
    64156416    { (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) ); }
    64166417    break;
     
    64196420
    64206421/* Line 1806 of yacc.c  */
    6421 #line 936 "parser.yy"
     6422#line 939 "parser.yy"
    64226423    { (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) ); }
    64236424    break;
     
    64266427
    64276428/* Line 1806 of yacc.c  */
    6428 #line 941 "parser.yy"
     6429#line 944 "parser.yy"
    64296430    { (yyval.flag) = false; }
    64306431    break;
     
    64336434
    64346435/* Line 1806 of yacc.c  */
    6435 #line 943 "parser.yy"
     6436#line 946 "parser.yy"
    64366437    { (yyval.flag) = true; }
    64376438    break;
     
    64406441
    64416442/* Line 1806 of yacc.c  */
    6442 #line 948 "parser.yy"
     6443#line 951 "parser.yy"
    64436444    { (yyval.en) = 0; }
    64446445    break;
     
    64476448
    64486449/* Line 1806 of yacc.c  */
    6449 #line 955 "parser.yy"
     6450#line 958 "parser.yy"
    64506451    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    64516452    break;
     
    64546455
    64556456/* Line 1806 of yacc.c  */
    6456 #line 960 "parser.yy"
     6457#line 963 "parser.yy"
    64576458    { (yyval.en) = new AsmExprNode( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ); }
    64586459    break;
     
    64616462
    64626463/* Line 1806 of yacc.c  */
    6463 #line 962 "parser.yy"
     6464#line 965 "parser.yy"
    64646465    { (yyval.en) = new AsmExprNode( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ); }
    64656466    break;
     
    64686469
    64696470/* Line 1806 of yacc.c  */
    6470 #line 967 "parser.yy"
     6471#line 970 "parser.yy"
    64716472    { (yyval.constant) = 0; }
    64726473    break;
     
    64756476
    64766477/* Line 1806 of yacc.c  */
    6477 #line 969 "parser.yy"
     6478#line 972 "parser.yy"
    64786479    { (yyval.constant) = (yyvsp[(1) - (1)].constant); }
    64796480    break;
     
    64826483
    64836484/* Line 1806 of yacc.c  */
    6484 #line 971 "parser.yy"
     6485#line 974 "parser.yy"
    64856486    { (yyval.constant) = (ConstantNode *)(yyvsp[(1) - (3)].constant)->set_link( (yyvsp[(3) - (3)].constant) ); }
    64866487    break;
     
    64896490
    64906491/* Line 1806 of yacc.c  */
    6491 #line 976 "parser.yy"
     6492#line 979 "parser.yy"
    64926493    { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
    64936494    break;
     
    64966497
    64976498/* Line 1806 of yacc.c  */
    6498 #line 978 "parser.yy"
     6499#line 981 "parser.yy"
    64996500    { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
    65006501    break;
     
    65036504
    65046505/* Line 1806 of yacc.c  */
    6505 #line 985 "parser.yy"
     6506#line 988 "parser.yy"
    65066507    { (yyval.decl) = 0; }
    65076508    break;
     
    65106511
    65116512/* Line 1806 of yacc.c  */
    6512 #line 992 "parser.yy"
     6513#line 995 "parser.yy"
    65136514    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    65146515    break;
     
    65176518
    65186519/* Line 1806 of yacc.c  */
    6519 #line 997 "parser.yy"
     6520#line 1000 "parser.yy"
    65206521    { (yyval.decl) = 0; }
    65216522    break;
     
    65246525
    65256526/* Line 1806 of yacc.c  */
    6526 #line 1004 "parser.yy"
     6527#line 1007 "parser.yy"
    65276528    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    65286529    break;
     
    65316532
    65326533/* Line 1806 of yacc.c  */
    6533 #line 1018 "parser.yy"
     6534#line 1021 "parser.yy"
    65346535    {}
    65356536    break;
     
    65386539
    65396540/* Line 1806 of yacc.c  */
    6540 #line 1019 "parser.yy"
     6541#line 1022 "parser.yy"
    65416542    {}
    65426543    break;
     
    65456546
    65466547/* Line 1806 of yacc.c  */
    6547 #line 1048 "parser.yy"
     6548#line 1051 "parser.yy"
    65486549    {
    65496550                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65556556
    65566557/* Line 1806 of yacc.c  */
    6557 #line 1055 "parser.yy"
     6558#line 1058 "parser.yy"
    65586559    {
    65596560                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65656566
    65666567/* Line 1806 of yacc.c  */
    6567 #line 1060 "parser.yy"
     6568#line 1063 "parser.yy"
    65686569    {
    65696570                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
     
    65756576
    65766577/* Line 1806 of yacc.c  */
    6577 #line 1070 "parser.yy"
     6578#line 1073 "parser.yy"
    65786579    {
    65796580                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    65856586
    65866587/* Line 1806 of yacc.c  */
    6587 #line 1075 "parser.yy"
     6588#line 1078 "parser.yy"
    65886589    {
    65896590                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    65956596
    65966597/* Line 1806 of yacc.c  */
    6597 #line 1080 "parser.yy"
     6598#line 1083 "parser.yy"
    65986599    {
    65996600                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
     
    66056606
    66066607/* Line 1806 of yacc.c  */
    6607 #line 1088 "parser.yy"
     6608#line 1091 "parser.yy"
    66086609    {
    66096610                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66156616
    66166617/* Line 1806 of yacc.c  */
    6617 #line 1093 "parser.yy"
     6618#line 1096 "parser.yy"
    66186619    {
    66196620                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66256626
    66266627/* Line 1806 of yacc.c  */
    6627 #line 1098 "parser.yy"
     6628#line 1101 "parser.yy"
    66286629    {
    66296630                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66356636
    66366637/* Line 1806 of yacc.c  */
    6637 #line 1103 "parser.yy"
     6638#line 1106 "parser.yy"
    66386639    {
    66396640                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66456646
    66466647/* Line 1806 of yacc.c  */
    6647 #line 1108 "parser.yy"
     6648#line 1111 "parser.yy"
    66486649    {
    66496650                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    66556656
    66566657/* Line 1806 of yacc.c  */
    6657 #line 1116 "parser.yy"
     6658#line 1119 "parser.yy"
    66586659    {
    66596660                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
     
    66646665
    66656666/* Line 1806 of yacc.c  */
    6666 #line 1139 "parser.yy"
     6667#line 1142 "parser.yy"
    66676668    {
    66686669                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    66736674
    66746675/* Line 1806 of yacc.c  */
    6675 #line 1143 "parser.yy"
     6676#line 1146 "parser.yy"
    66766677    {
    66776678                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    66826683
    66836684/* Line 1806 of yacc.c  */
    6684 #line 1150 "parser.yy"
     6685#line 1153 "parser.yy"
    66856686    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    66866687    break;
     
    66896690
    66906691/* Line 1806 of yacc.c  */
    6691 #line 1154 "parser.yy"
     6692#line 1157 "parser.yy"
    66926693    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    66936694    break;
     
    66966697
    66976698/* Line 1806 of yacc.c  */
    6698 #line 1159 "parser.yy"
     6699#line 1162 "parser.yy"
    66996700    {
    67006701                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67066707
    67076708/* Line 1806 of yacc.c  */
    6708 #line 1164 "parser.yy"
     6709#line 1167 "parser.yy"
    67096710    {
    67106711                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67166717
    67176718/* Line 1806 of yacc.c  */
    6718 #line 1169 "parser.yy"
     6719#line 1172 "parser.yy"
    67196720    {
    67206721                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
     
    67266727
    67276728/* Line 1806 of yacc.c  */
    6728 #line 1180 "parser.yy"
     6729#line 1183 "parser.yy"
    67296730    {
    67306731                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67366737
    67376738/* Line 1806 of yacc.c  */
    6738 #line 1185 "parser.yy"
     6739#line 1188 "parser.yy"
    67396740    {
    67406741                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67466747
    67476748/* Line 1806 of yacc.c  */
    6748 #line 1190 "parser.yy"
     6749#line 1193 "parser.yy"
    67496750    {
    67506751                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67566757
    67576758/* Line 1806 of yacc.c  */
    6758 #line 1195 "parser.yy"
     6759#line 1198 "parser.yy"
    67596760    {
    67606761                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67666767
    67676768/* Line 1806 of yacc.c  */
    6768 #line 1200 "parser.yy"
     6769#line 1203 "parser.yy"
    67696770    {
    67706771                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    67766777
    67776778/* Line 1806 of yacc.c  */
    6778 #line 1209 "parser.yy"
     6779#line 1212 "parser.yy"
    67796780    {
    67806781                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
     
    67866787
    67876788/* Line 1806 of yacc.c  */
    6788 #line 1214 "parser.yy"
     6789#line 1217 "parser.yy"
    67896790    {
    67906791                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
     
    67966797
    67976798/* Line 1806 of yacc.c  */
    6798 #line 1231 "parser.yy"
     6799#line 1234 "parser.yy"
    67996800    {
    68006801                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    68066807
    68076808/* Line 1806 of yacc.c  */
    6808 #line 1236 "parser.yy"
     6809#line 1239 "parser.yy"
    68096810    {
    68106811                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    68166817
    68176818/* Line 1806 of yacc.c  */
    6818 #line 1258 "parser.yy"
     6819#line 1261 "parser.yy"
    68196820    { (yyval.decl) = 0; }
    68206821    break;
     
    68236824
    68246825/* Line 1806 of yacc.c  */
    6825 #line 1270 "parser.yy"
     6826#line 1273 "parser.yy"
    68266827    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68276828    break;
     
    68306831
    68316832/* Line 1806 of yacc.c  */
    6832 #line 1281 "parser.yy"
     6833#line 1284 "parser.yy"
    68336834    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    68346835    break;
     
    68376838
    68386839/* Line 1806 of yacc.c  */
    6839 #line 1283 "parser.yy"
     6840#line 1286 "parser.yy"
    68406841    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    68416842    break;
     
    68446845
    68456846/* Line 1806 of yacc.c  */
    6846 #line 1285 "parser.yy"
     6847#line 1288 "parser.yy"
    68476848    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    68486849    break;
     
    68516852
    68526853/* Line 1806 of yacc.c  */
    6853 #line 1287 "parser.yy"
     6854#line 1290 "parser.yy"
    68546855    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    68556856    break;
     
    68586859
    68596860/* Line 1806 of yacc.c  */
    6860 #line 1289 "parser.yy"
     6861#line 1292 "parser.yy"
    68616862    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    68626863    break;
     
    68656866
    68666867/* Line 1806 of yacc.c  */
    6867 #line 1291 "parser.yy"
     6868#line 1294 "parser.yy"
    68686869    {
    68696870                        typedefTable.enterScope();
     
    68746875
    68756876/* Line 1806 of yacc.c  */
    6876 #line 1295 "parser.yy"
     6877#line 1298 "parser.yy"
    68776878    {
    68786879                        typedefTable.leaveScope();
     
    68846885
    68856886/* Line 1806 of yacc.c  */
    6886 #line 1304 "parser.yy"
     6887#line 1307 "parser.yy"
    68876888    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68886889    break;
     
    68916892
    68926893/* Line 1806 of yacc.c  */
    6893 #line 1306 "parser.yy"
     6894#line 1309 "parser.yy"
    68946895    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68956896    break;
     
    68986899
    68996900/* Line 1806 of yacc.c  */
    6900 #line 1317 "parser.yy"
     6901#line 1320 "parser.yy"
    69016902    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69026903    break;
     
    69056906
    69066907/* Line 1806 of yacc.c  */
    6907 #line 1326 "parser.yy"
     6908#line 1329 "parser.yy"
    69086909    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    69096910    break;
     
    69126913
    69136914/* Line 1806 of yacc.c  */
    6914 #line 1328 "parser.yy"
     6915#line 1331 "parser.yy"
    69156916    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    69166917    break;
     
    69196920
    69206921/* Line 1806 of yacc.c  */
    6921 #line 1330 "parser.yy"
     6922#line 1333 "parser.yy"
    69226923    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    69236924    break;
     
    69266927
    69276928/* Line 1806 of yacc.c  */
    6928 #line 1332 "parser.yy"
     6929#line 1335 "parser.yy"
    69296930    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    69306931    break;
     
    69336934
    69346935/* Line 1806 of yacc.c  */
    6935 #line 1334 "parser.yy"
     6936#line 1337 "parser.yy"
    69366937    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    69376938    break;
     
    69406941
    69416942/* Line 1806 of yacc.c  */
    6942 #line 1336 "parser.yy"
     6943#line 1339 "parser.yy"
    69436944    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    69446945    break;
     
    69476948
    69486949/* Line 1806 of yacc.c  */
    6949 #line 1338 "parser.yy"
     6950#line 1341 "parser.yy"
    69506951    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
    69516952    break;
     
    69546955
    69556956/* Line 1806 of yacc.c  */
    6956 #line 1340 "parser.yy"
     6957#line 1343 "parser.yy"
    69576958    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    69586959    break;
     
    69616962
    69626963/* Line 1806 of yacc.c  */
    6963 #line 1345 "parser.yy"
     6964#line 1348 "parser.yy"
    69646965    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    69656966    break;
     
    69686969
    69696970/* Line 1806 of yacc.c  */
    6970 #line 1347 "parser.yy"
     6971#line 1350 "parser.yy"
    69716972    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    69726973    break;
     
    69756976
    69766977/* Line 1806 of yacc.c  */
    6977 #line 1349 "parser.yy"
     6978#line 1352 "parser.yy"
    69786979    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    69796980    break;
     
    69826983
    69836984/* Line 1806 of yacc.c  */
    6984 #line 1351 "parser.yy"
     6985#line 1354 "parser.yy"
    69856986    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    69866987    break;
     
    69896990
    69906991/* Line 1806 of yacc.c  */
    6991 #line 1353 "parser.yy"
     6992#line 1356 "parser.yy"
    69926993    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
    69936994    break;
     
    69966997
    69976998/* Line 1806 of yacc.c  */
    6998 #line 1355 "parser.yy"
     6999#line 1358 "parser.yy"
    69997000    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
    70007001    break;
     
    70037004
    70047005/* Line 1806 of yacc.c  */
    7005 #line 1357 "parser.yy"
     7006#line 1360 "parser.yy"
    70067007    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
    70077008    break;
     
    70107011
    70117012/* Line 1806 of yacc.c  */
    7012 #line 1359 "parser.yy"
     7013#line 1362 "parser.yy"
    70137014    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
    70147015    break;
     
    70177018
    70187019/* Line 1806 of yacc.c  */
    7019 #line 1361 "parser.yy"
     7020#line 1364 "parser.yy"
    70207021    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    70217022    break;
     
    70247025
    70257026/* Line 1806 of yacc.c  */
    7026 #line 1363 "parser.yy"
     7027#line 1366 "parser.yy"
    70277028    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    70287029    break;
     
    70317032
    70327033/* Line 1806 of yacc.c  */
    7033 #line 1365 "parser.yy"
     7034#line 1368 "parser.yy"
    70347035    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
    70357036    break;
     
    70387039
    70397040/* Line 1806 of yacc.c  */
    7040 #line 1367 "parser.yy"
     7041#line 1370 "parser.yy"
    70417042    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
    70427043    break;
     
    70457046
    70467047/* Line 1806 of yacc.c  */
    7047 #line 1369 "parser.yy"
     7048#line 1372 "parser.yy"
    70487049    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    70497050    break;
     
    70527053
    70537054/* Line 1806 of yacc.c  */
    7054 #line 1376 "parser.yy"
     7055#line 1379 "parser.yy"
    70557056    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    70567057    break;
     
    70597060
    70607061/* Line 1806 of yacc.c  */
    7061 #line 1378 "parser.yy"
     7062#line 1381 "parser.yy"
    70627063    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    70637064    break;
     
    70667067
    70677068/* Line 1806 of yacc.c  */
    7068 #line 1380 "parser.yy"
     7069#line 1383 "parser.yy"
    70697070    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    70707071    break;
     
    70737074
    70747075/* Line 1806 of yacc.c  */
    7075 #line 1382 "parser.yy"
     7076#line 1385 "parser.yy"
    70767077    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    70777078    break;
     
    70807081
    70817082/* Line 1806 of yacc.c  */
    7082 #line 1388 "parser.yy"
     7083#line 1391 "parser.yy"
    70837084    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    70847085    break;
     
    70877088
    70887089/* Line 1806 of yacc.c  */
    7089 #line 1395 "parser.yy"
     7090#line 1398 "parser.yy"
    70907091    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    70917092    break;
     
    70947095
    70957096/* Line 1806 of yacc.c  */
    7096 #line 1397 "parser.yy"
     7097#line 1400 "parser.yy"
    70977098    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    70987099    break;
     
    71017102
    71027103/* Line 1806 of yacc.c  */
    7103 #line 1399 "parser.yy"
     7104#line 1402 "parser.yy"
    71047105    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    71057106    break;
     
    71087109
    71097110/* Line 1806 of yacc.c  */
    7110 #line 1404 "parser.yy"
     7111#line 1407 "parser.yy"
    71117112    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    71127113    break;
     
    71157116
    71167117/* Line 1806 of yacc.c  */
    7117 #line 1406 "parser.yy"
     7118#line 1409 "parser.yy"
    71187119    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    71197120    break;
     
    71227123
    71237124/* Line 1806 of yacc.c  */
    7124 #line 1408 "parser.yy"
     7125#line 1411 "parser.yy"
    71257126    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    71267127    break;
     
    71297130
    71307131/* Line 1806 of yacc.c  */
    7131 #line 1410 "parser.yy"
     7132#line 1413 "parser.yy"
    71327133    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    71337134    break;
     
    71367137
    71377138/* Line 1806 of yacc.c  */
    7138 #line 1416 "parser.yy"
     7139#line 1419 "parser.yy"
    71397140    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    71407141    break;
     
    71437144
    71447145/* Line 1806 of yacc.c  */
    7145 #line 1418 "parser.yy"
     7146#line 1421 "parser.yy"
    71467147    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    71477148    break;
     
    71507151
    71517152/* Line 1806 of yacc.c  */
    7152 #line 1420 "parser.yy"
     7153#line 1423 "parser.yy"
    71537154    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    71547155    break;
     
    71577158
    71587159/* Line 1806 of yacc.c  */
    7159 #line 1426 "parser.yy"
     7160#line 1429 "parser.yy"
    71607161    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    71617162    break;
     
    71647165
    71657166/* Line 1806 of yacc.c  */
    7166 #line 1428 "parser.yy"
     7167#line 1431 "parser.yy"
    71677168    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    71687169    break;
     
    71717172
    71727173/* Line 1806 of yacc.c  */
    7173 #line 1434 "parser.yy"
     7174#line 1437 "parser.yy"
    71747175    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    71757176    break;
     
    71787179
    71797180/* Line 1806 of yacc.c  */
    7180 #line 1436 "parser.yy"
     7181#line 1439 "parser.yy"
    71817182    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    71827183    break;
     
    71857186
    71867187/* Line 1806 of yacc.c  */
    7187 #line 1438 "parser.yy"
     7188#line 1441 "parser.yy"
    71887189    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    71897190    break;
     
    71927193
    71937194/* Line 1806 of yacc.c  */
    7194 #line 1443 "parser.yy"
     7195#line 1446 "parser.yy"
    71957196    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    71967197    break;
     
    71997200
    72007201/* Line 1806 of yacc.c  */
    7201 #line 1445 "parser.yy"
     7202#line 1448 "parser.yy"
    72027203    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    72037204    break;
     
    72067207
    72077208/* Line 1806 of yacc.c  */
    7208 #line 1447 "parser.yy"
     7209#line 1450 "parser.yy"
    72097210    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    72107211    break;
     
    72137214
    72147215/* Line 1806 of yacc.c  */
    7215 #line 1457 "parser.yy"
     7216#line 1460 "parser.yy"
    72167217    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
    72177218    break;
     
    72207221
    72217222/* Line 1806 of yacc.c  */
    7222 #line 1459 "parser.yy"
     7223#line 1462 "parser.yy"
    72237224    {
    72247225                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    72307231
    72317232/* Line 1806 of yacc.c  */
    7232 #line 1464 "parser.yy"
     7233#line 1467 "parser.yy"
    72337234    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    72347235    break;
     
    72377238
    72387239/* Line 1806 of yacc.c  */
    7239 #line 1466 "parser.yy"
     7240#line 1469 "parser.yy"
    72407241    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
    72417242    break;
     
    72447245
    72457246/* Line 1806 of yacc.c  */
    7246 #line 1468 "parser.yy"
     7247#line 1471 "parser.yy"
    72477248    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    72487249    break;
     
    72517252
    72527253/* Line 1806 of yacc.c  */
    7253 #line 1470 "parser.yy"
     7254#line 1473 "parser.yy"
    72547255    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    72557256    break;
     
    72587259
    72597260/* Line 1806 of yacc.c  */
    7260 #line 1475 "parser.yy"
     7261#line 1478 "parser.yy"
    72617262    { (yyval.aggKey) = DeclarationNode::Struct; }
    72627263    break;
     
    72657266
    72667267/* Line 1806 of yacc.c  */
    7267 #line 1477 "parser.yy"
     7268#line 1480 "parser.yy"
    72687269    { (yyval.aggKey) = DeclarationNode::Union; }
    72697270    break;
     
    72727273
    72737274/* Line 1806 of yacc.c  */
    7274 #line 1482 "parser.yy"
     7275#line 1485 "parser.yy"
    72757276    { (yyval.decl) = 0; }
    72767277    break;
     
    72797280
    72807281/* Line 1806 of yacc.c  */
    7281 #line 1484 "parser.yy"
     7282#line 1487 "parser.yy"
    72827283    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    72837284    break;
     
    72867287
    72877288/* Line 1806 of yacc.c  */
    7288 #line 1490 "parser.yy"
     7289#line 1493 "parser.yy"
    72897290    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    72907291    break;
     
    72937294
    72947295/* Line 1806 of yacc.c  */
    7295 #line 1493 "parser.yy"
     7296#line 1496 "parser.yy"
    72967297    {   // mark all fields in list
    72977298                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    73047305
    73057306/* Line 1806 of yacc.c  */
    7306 #line 1503 "parser.yy"
     7307#line 1506 "parser.yy"
    73077308    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    73087309    break;
     
    73117312
    73127313/* Line 1806 of yacc.c  */
    7313 #line 1505 "parser.yy"
     7314#line 1508 "parser.yy"
    73147315    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    73157316    break;
     
    73187319
    73197320/* Line 1806 of yacc.c  */
    7320 #line 1507 "parser.yy"
     7321#line 1510 "parser.yy"
    73217322    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    73227323    break;
     
    73257326
    73267327/* Line 1806 of yacc.c  */
    7327 #line 1512 "parser.yy"
     7328#line 1515 "parser.yy"
    73287329    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73297330    break;
     
    73327333
    73337334/* Line 1806 of yacc.c  */
    7334 #line 1514 "parser.yy"
     7335#line 1517 "parser.yy"
    73357336    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    73367337    break;
     
    73397340
    73407341/* Line 1806 of yacc.c  */
    7341 #line 1519 "parser.yy"
     7342#line 1522 "parser.yy"
    73427343    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    73437344    break;
     
    73467347
    73477348/* Line 1806 of yacc.c  */
    7348 #line 1521 "parser.yy"
     7349#line 1524 "parser.yy"
    73497350    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    73507351    break;
    73517352
    73527353  case 388:
    7353 
    7354 /* Line 1806 of yacc.c  */
    7355 #line 1524 "parser.yy"
    7356     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    7357     break;
    7358 
    7359   case 389:
    73607354
    73617355/* Line 1806 of yacc.c  */
     
    73647358    break;
    73657359
     7360  case 389:
     7361
     7362/* Line 1806 of yacc.c  */
     7363#line 1530 "parser.yy"
     7364    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     7365    break;
     7366
    73667367  case 391:
    73677368
    73687369/* Line 1806 of yacc.c  */
    7369 #line 1533 "parser.yy"
     7370#line 1536 "parser.yy"
    73707371    { (yyval.en) = 0; }
    73717372    break;
     
    73747375
    73757376/* Line 1806 of yacc.c  */
    7376 #line 1535 "parser.yy"
     7377#line 1538 "parser.yy"
    73777378    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    73787379    break;
     
    73817382
    73827383/* Line 1806 of yacc.c  */
    7383 #line 1540 "parser.yy"
     7384#line 1543 "parser.yy"
    73847385    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    73857386    break;
     
    73887389
    73897390/* Line 1806 of yacc.c  */
    7390 #line 1549 "parser.yy"
     7391#line 1552 "parser.yy"
    73917392    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
    73927393    break;
     
    73957396
    73967397/* Line 1806 of yacc.c  */
    7397 #line 1551 "parser.yy"
     7398#line 1554 "parser.yy"
    73987399    {
    73997400                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    74057406
    74067407/* Line 1806 of yacc.c  */
    7407 #line 1556 "parser.yy"
     7408#line 1559 "parser.yy"
    74087409    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    74097410    break;
     
    74127413
    74137414/* Line 1806 of yacc.c  */
    7414 #line 1558 "parser.yy"
     7415#line 1561 "parser.yy"
    74157416    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    74167417    break;
     
    74197420
    74207421/* Line 1806 of yacc.c  */
    7421 #line 1563 "parser.yy"
     7422#line 1566 "parser.yy"
    74227423    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    74237424    break;
     
    74267427
    74277428/* Line 1806 of yacc.c  */
    7428 #line 1565 "parser.yy"
     7429#line 1568 "parser.yy"
    74297430    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    74307431    break;
     
    74337434
    74347435/* Line 1806 of yacc.c  */
    7435 #line 1570 "parser.yy"
     7436#line 1573 "parser.yy"
    74367437    { (yyval.en) = 0; }
    74377438    break;
     
    74407441
    74417442/* Line 1806 of yacc.c  */
    7442 #line 1572 "parser.yy"
     7443#line 1575 "parser.yy"
    74437444    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    74447445    break;
     
    74477448
    74487449/* Line 1806 of yacc.c  */
    7449 #line 1579 "parser.yy"
     7450#line 1582 "parser.yy"
    74507451    { (yyval.decl) = 0; }
    74517452    break;
     
    74547455
    74557456/* Line 1806 of yacc.c  */
    7456 #line 1587 "parser.yy"
     7457#line 1590 "parser.yy"
    74577458    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74587459    break;
     
    74617462
    74627463/* Line 1806 of yacc.c  */
    7463 #line 1589 "parser.yy"
     7464#line 1592 "parser.yy"
    74647465    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    74657466    break;
     
    74687469
    74697470/* Line 1806 of yacc.c  */
    7470 #line 1591 "parser.yy"
     7471#line 1594 "parser.yy"
    74717472    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    74727473    break;
     
    74757476
    74767477/* Line 1806 of yacc.c  */
    7477 #line 1599 "parser.yy"
     7478#line 1602 "parser.yy"
    74787479    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74797480    break;
     
    74827483
    74837484/* Line 1806 of yacc.c  */
    7484 #line 1601 "parser.yy"
     7485#line 1604 "parser.yy"
    74857486    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    74867487    break;
     
    74897490
    74907491/* Line 1806 of yacc.c  */
    7491 #line 1603 "parser.yy"
     7492#line 1606 "parser.yy"
    74927493    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    74937494    break;
     
    74967497
    74977498/* Line 1806 of yacc.c  */
    7498 #line 1609 "parser.yy"
     7499#line 1612 "parser.yy"
    74997500    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    75007501    break;
     
    75037504
    75047505/* Line 1806 of yacc.c  */
    7505 #line 1614 "parser.yy"
     7506#line 1617 "parser.yy"
    75067507    { (yyval.decl) = 0; }
    75077508    break;
     
    75107511
    75117512/* Line 1806 of yacc.c  */
    7512 #line 1621 "parser.yy"
     7513#line 1624 "parser.yy"
    75137514    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    75147515    break;
     
    75177518
    75187519/* Line 1806 of yacc.c  */
    7519 #line 1628 "parser.yy"
     7520#line 1631 "parser.yy"
    75207521    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    75217522    break;
     
    75247525
    75257526/* Line 1806 of yacc.c  */
    7526 #line 1630 "parser.yy"
     7527#line 1633 "parser.yy"
    75277528    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    75287529    break;
    75297530
    75307531  case 425:
    7531 
    7532 /* Line 1806 of yacc.c  */
    7533 #line 1639 "parser.yy"
    7534     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    7535     break;
    7536 
    7537   case 426:
    75387532
    75397533/* Line 1806 of yacc.c  */
     
    75427536    break;
    75437537
     7538  case 426:
     7539
     7540/* Line 1806 of yacc.c  */
     7541#line 1645 "parser.yy"
     7542    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     7543    break;
     7544
    75447545  case 427:
    75457546
    75467547/* Line 1806 of yacc.c  */
    7547 #line 1644 "parser.yy"
     7548#line 1647 "parser.yy"
    75487549    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    75497550    break;
     
    75527553
    75537554/* Line 1806 of yacc.c  */
    7554 #line 1654 "parser.yy"
     7555#line 1657 "parser.yy"
    75557556    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75567557    break;
     
    75597560
    75607561/* Line 1806 of yacc.c  */
    7561 #line 1660 "parser.yy"
     7562#line 1663 "parser.yy"
    75627563    {
    75637564                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    75697570
    75707571/* Line 1806 of yacc.c  */
    7571 #line 1665 "parser.yy"
     7572#line 1668 "parser.yy"
    75727573    {
    75737574                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    75797580
    75807581/* Line 1806 of yacc.c  */
    7581 #line 1674 "parser.yy"
     7582#line 1677 "parser.yy"
    75827583    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    75837584    break;
     
    75867587
    75877588/* Line 1806 of yacc.c  */
    7588 #line 1683 "parser.yy"
     7589#line 1686 "parser.yy"
    75897590    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    75907591    break;
     
    75937594
    75947595/* Line 1806 of yacc.c  */
    7595 #line 1685 "parser.yy"
     7596#line 1688 "parser.yy"
    75967597    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    75977598    break;
     
    76007601
    76017602/* Line 1806 of yacc.c  */
    7602 #line 1710 "parser.yy"
     7603#line 1713 "parser.yy"
    76037604    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    76047605    break;
     
    76077608
    76087609/* Line 1806 of yacc.c  */
    7609 #line 1718 "parser.yy"
     7610#line 1721 "parser.yy"
    76107611    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    76117612    break;
     
    76147615
    76157616/* Line 1806 of yacc.c  */
    7616 #line 1723 "parser.yy"
     7617#line 1726 "parser.yy"
    76177618    { (yyval.in) = 0; }
    76187619    break;
     
    76217622
    76227623/* Line 1806 of yacc.c  */
    7623 #line 1725 "parser.yy"
     7624#line 1728 "parser.yy"
    76247625    { (yyval.in) = (yyvsp[(2) - (2)].in); }
    76257626    break;
     
    76287629
    76297630/* Line 1806 of yacc.c  */
    7630 #line 1727 "parser.yy"
     7631#line 1730 "parser.yy"
    76317632    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    76327633    break;
     
    76357636
    76367637/* Line 1806 of yacc.c  */
    7637 #line 1731 "parser.yy"
     7638#line 1734 "parser.yy"
    76387639    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    76397640    break;
     
    76427643
    76437644/* Line 1806 of yacc.c  */
    7644 #line 1732 "parser.yy"
     7645#line 1735 "parser.yy"
    76457646    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    76467647    break;
     
    76497650
    76507651/* Line 1806 of yacc.c  */
    7651 #line 1737 "parser.yy"
     7652#line 1740 "parser.yy"
    76527653    { (yyval.in) = 0; }
    76537654    break;
     
    76567657
    76577658/* Line 1806 of yacc.c  */
    7658 #line 1739 "parser.yy"
     7659#line 1742 "parser.yy"
    76597660    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    76607661    break;
     
    76637664
    76647665/* Line 1806 of yacc.c  */
    7665 #line 1740 "parser.yy"
     7666#line 1743 "parser.yy"
    76667667    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
    76677668    break;
     
    76707671
    76717672/* Line 1806 of yacc.c  */
    7672 #line 1742 "parser.yy"
     7673#line 1745 "parser.yy"
    76737674    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    76747675    break;
     
    76777678
    76787679/* Line 1806 of yacc.c  */
    7679 #line 1758 "parser.yy"
     7680#line 1761 "parser.yy"
    76807681    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (2)].tok) ); }
    76817682    break;
     
    76847685
    76857686/* Line 1806 of yacc.c  */
    7686 #line 1764 "parser.yy"
     7687#line 1767 "parser.yy"
    76877688    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) )); }
    76887689    break;
     
    76917692
    76927693/* Line 1806 of yacc.c  */
    7693 #line 1772 "parser.yy"
     7694#line 1775 "parser.yy"
    76947695    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); }
    76957696    break;
     
    76987699
    76997700/* Line 1806 of yacc.c  */
    7700 #line 1774 "parser.yy"
     7701#line 1777 "parser.yy"
    77017702    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(2) - (2)].tok) ) ); }
    77027703    break;
     
    77057706
    77067707/* Line 1806 of yacc.c  */
    7707 #line 1777 "parser.yy"
     7708#line 1780 "parser.yy"
    77087709    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    77097710    break;
     
    77127713
    77137714/* Line 1806 of yacc.c  */
    7714 #line 1779 "parser.yy"
     7715#line 1782 "parser.yy"
    77157716    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    77167717    break;
     
    77197720
    77207721/* Line 1806 of yacc.c  */
    7721 #line 1781 "parser.yy"
    7722     { (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 ); }
    77237724    break;
    77247725
     
    77267727
    77277728/* Line 1806 of yacc.c  */
    7728 #line 1783 "parser.yy"
     7729#line 1786 "parser.yy"
    77297730    { (yyval.en) = new DesignatorNode( (yyvsp[(4) - (6)].en) ); }
    77307731    break;
     
    77337734
    77347735/* Line 1806 of yacc.c  */
    7735 #line 1807 "parser.yy"
     7736#line 1810 "parser.yy"
    77367737    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    77377738    break;
     
    77407741
    77417742/* Line 1806 of yacc.c  */
    7742 #line 1809 "parser.yy"
     7743#line 1812 "parser.yy"
    77437744    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    77447745    break;
     
    77477748
    77487749/* Line 1806 of yacc.c  */
    7749 #line 1811 "parser.yy"
     7750#line 1814 "parser.yy"
    77507751    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    77517752    break;
     
    77547755
    77557756/* Line 1806 of yacc.c  */
    7756 #line 1817 "parser.yy"
     7757#line 1820 "parser.yy"
    77577758    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    77587759    break;
     
    77617762
    77627763/* Line 1806 of yacc.c  */
    7763 #line 1819 "parser.yy"
     7764#line 1822 "parser.yy"
    77647765    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    77657766    break;
     
    77687769
    77697770/* Line 1806 of yacc.c  */
    7770 #line 1824 "parser.yy"
     7771#line 1827 "parser.yy"
    77717772    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    77727773    break;
     
    77757776
    77767777/* Line 1806 of yacc.c  */
    7777 #line 1830 "parser.yy"
     7778#line 1833 "parser.yy"
    77787779    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    77797780    break;
     
    77827783
    77837784/* Line 1806 of yacc.c  */
    7784 #line 1835 "parser.yy"
     7785#line 1838 "parser.yy"
    77857786    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    77867787    break;
     
    77897790
    77907791/* Line 1806 of yacc.c  */
    7791 #line 1837 "parser.yy"
     7792#line 1840 "parser.yy"
    77927793    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    77937794    break;
     
    77967797
    77977798/* Line 1806 of yacc.c  */
    7798 #line 1843 "parser.yy"
     7799#line 1846 "parser.yy"
    77997800    { (yyval.tclass) = DeclarationNode::Type; }
    78007801    break;
     
    78037804
    78047805/* Line 1806 of yacc.c  */
    7805 #line 1845 "parser.yy"
     7806#line 1848 "parser.yy"
    78067807    { (yyval.tclass) = DeclarationNode::Ftype; }
    78077808    break;
     
    78107811
    78117812/* Line 1806 of yacc.c  */
    7812 #line 1847 "parser.yy"
     7813#line 1850 "parser.yy"
    78137814    { (yyval.tclass) = DeclarationNode::Dtype; }
    78147815    break;
     
    78177818
    78187819/* Line 1806 of yacc.c  */
    7819 #line 1852 "parser.yy"
     7820#line 1855 "parser.yy"
    78207821    { (yyval.decl) = 0; }
    78217822    break;
     
    78247825
    78257826/* Line 1806 of yacc.c  */
    7826 #line 1854 "parser.yy"
     7827#line 1857 "parser.yy"
    78277828    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    78287829    break;
     
    78317832
    78327833/* Line 1806 of yacc.c  */
    7833 #line 1859 "parser.yy"
     7834#line 1862 "parser.yy"
    78347835    {
    78357836                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
     
    78417842
    78427843/* Line 1806 of yacc.c  */
    7843 #line 1864 "parser.yy"
     7844#line 1867 "parser.yy"
    78447845    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    78457846    break;
     
    78487849
    78497850/* Line 1806 of yacc.c  */
    7850 #line 1866 "parser.yy"
     7851#line 1869 "parser.yy"
    78517852    { (yyval.decl) = 0; }
    78527853    break;
     
    78557856
    78567857/* Line 1806 of yacc.c  */
    7857 #line 1871 "parser.yy"
     7858#line 1874 "parser.yy"
    78587859    { (yyval.en) = new TypeValueNode( (yyvsp[(1) - (1)].decl) ); }
    78597860    break;
     
    78627863
    78637864/* Line 1806 of yacc.c  */
    7864 #line 1874 "parser.yy"
     7865#line 1877 "parser.yy"
    78657866    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new TypeValueNode( (yyvsp[(3) - (3)].decl) ))); }
    78667867    break;
     
    78697870
    78707871/* Line 1806 of yacc.c  */
    7871 #line 1876 "parser.yy"
     7872#line 1879 "parser.yy"
    78727873    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    78737874    break;
     
    78767877
    78777878/* Line 1806 of yacc.c  */
    7878 #line 1881 "parser.yy"
     7879#line 1884 "parser.yy"
    78797880    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    78807881    break;
     
    78837884
    78847885/* Line 1806 of yacc.c  */
    7885 #line 1883 "parser.yy"
     7886#line 1886 "parser.yy"
    78867887    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    78877888    break;
     
    78907891
    78917892/* Line 1806 of yacc.c  */
    7892 #line 1885 "parser.yy"
     7893#line 1888 "parser.yy"
    78937894    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    78947895    break;
     
    78977898
    78987899/* Line 1806 of yacc.c  */
    7899 #line 1890 "parser.yy"
     7900#line 1893 "parser.yy"
    79007901    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    79017902    break;
     
    79047905
    79057906/* Line 1806 of yacc.c  */
    7906 #line 1892 "parser.yy"
     7907#line 1895 "parser.yy"
    79077908    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    79087909    break;
     
    79117912
    79127913/* Line 1806 of yacc.c  */
    7913 #line 1897 "parser.yy"
     7914#line 1900 "parser.yy"
    79147915    {
    79157916                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
     
    79217922
    79227923/* Line 1806 of yacc.c  */
    7923 #line 1902 "parser.yy"
     7924#line 1905 "parser.yy"
    79247925    {
    79257926                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
     
    79317932
    79327933/* Line 1806 of yacc.c  */
    7933 #line 1910 "parser.yy"
     7934#line 1913 "parser.yy"
    79347935    {
    79357936                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
     
    79417942
    79427943/* Line 1806 of yacc.c  */
    7943 #line 1915 "parser.yy"
     7944#line 1918 "parser.yy"
    79447945    {
    79457946                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
     
    79517952
    79527953/* Line 1806 of yacc.c  */
    7953 #line 1920 "parser.yy"
     7954#line 1923 "parser.yy"
    79547955    {
    79557956                        typedefTable.leaveTrait();
     
    79627963
    79637964/* Line 1806 of yacc.c  */
    7964 #line 1930 "parser.yy"
     7965#line 1933 "parser.yy"
    79657966    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    79667967    break;
     
    79697970
    79707971/* Line 1806 of yacc.c  */
    7971 #line 1940 "parser.yy"
     7972#line 1943 "parser.yy"
    79727973    {
    79737974                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    79797980
    79807981/* Line 1806 of yacc.c  */
    7981 #line 1945 "parser.yy"
     7982#line 1948 "parser.yy"
    79827983    {
    79837984                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    79897990
    79907991/* Line 1806 of yacc.c  */
    7991 #line 1950 "parser.yy"
     7992#line 1953 "parser.yy"
    79927993    {
    79937994                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    79998000
    80008001/* Line 1806 of yacc.c  */
    8001 #line 1958 "parser.yy"
     8002#line 1961 "parser.yy"
    80028003    {
    80038004                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    80098010
    80108011/* Line 1806 of yacc.c  */
    8011 #line 1963 "parser.yy"
     8012#line 1966 "parser.yy"
    80128013    {
    80138014                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    80198020
    80208021/* Line 1806 of yacc.c  */
    8021 #line 1973 "parser.yy"
     8022#line 1976 "parser.yy"
    80228023    {}
    80238024    break;
     
    80268027
    80278028/* Line 1806 of yacc.c  */
    8028 #line 1975 "parser.yy"
     8029#line 1978 "parser.yy"
    80298030    {
    80308031                        if ( theTree ) {
     
    80398040
    80408041/* Line 1806 of yacc.c  */
    8041 #line 1987 "parser.yy"
     8042#line 1990 "parser.yy"
    80428043    { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    80438044    break;
     
    80468047
    80478048/* Line 1806 of yacc.c  */
    8048 #line 1992 "parser.yy"
     8049#line 1995 "parser.yy"
    80498050    { (yyval.decl) = 0; }
    80508051    break;
     
    80538054
    80548055/* Line 1806 of yacc.c  */
    8055 #line 2000 "parser.yy"
     8056#line 2003 "parser.yy"
    80568057    {}
    80578058    break;
     
    80608061
    80618062/* Line 1806 of yacc.c  */
    8062 #line 2002 "parser.yy"
     8063#line 2005 "parser.yy"
    80638064    {
    80648065                        linkageStack.push( linkage );
     
    80708071
    80718072/* Line 1806 of yacc.c  */
    8072 #line 2007 "parser.yy"
     8073#line 2010 "parser.yy"
    80738074    {
    80748075                        linkage = linkageStack.top();
     
    80818082
    80828083/* Line 1806 of yacc.c  */
    8083 #line 2013 "parser.yy"
     8084#line 2016 "parser.yy"
    80848085    {   // mark all fields in list
    80858086                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    80928093
    80938094/* Line 1806 of yacc.c  */
    8094 #line 2028 "parser.yy"
     8095#line 2031 "parser.yy"
    80958096    {
    80968097                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81038104
    81048105/* Line 1806 of yacc.c  */
    8105 #line 2034 "parser.yy"
     8106#line 2037 "parser.yy"
    81068107    {
    81078108                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81148115
    81158116/* Line 1806 of yacc.c  */
    8116 #line 2043 "parser.yy"
     8117#line 2046 "parser.yy"
    81178118    {
    81188119                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81258126
    81268127/* Line 1806 of yacc.c  */
    8127 #line 2049 "parser.yy"
     8128#line 2052 "parser.yy"
    81288129    {
    81298130                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81368137
    81378138/* Line 1806 of yacc.c  */
    8138 #line 2055 "parser.yy"
     8139#line 2058 "parser.yy"
    81398140    {
    81408141                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81478148
    81488149/* Line 1806 of yacc.c  */
    8149 #line 2061 "parser.yy"
     8150#line 2064 "parser.yy"
    81508151    {
    81518152                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81588159
    81598160/* Line 1806 of yacc.c  */
    8160 #line 2067 "parser.yy"
     8161#line 2070 "parser.yy"
    81618162    {
    81628163                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81698170
    81708171/* Line 1806 of yacc.c  */
    8171 #line 2075 "parser.yy"
     8172#line 2078 "parser.yy"
    81728173    {
    81738174                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81808181
    81818182/* Line 1806 of yacc.c  */
    8182 #line 2081 "parser.yy"
     8183#line 2084 "parser.yy"
    81838184    {
    81848185                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    81918192
    81928193/* Line 1806 of yacc.c  */
    8193 #line 2089 "parser.yy"
     8194#line 2092 "parser.yy"
    81948195    {
    81958196                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    82028203
    82038204/* Line 1806 of yacc.c  */
    8204 #line 2095 "parser.yy"
     8205#line 2098 "parser.yy"
    82058206    {
    82068207                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    82138214
    82148215/* Line 1806 of yacc.c  */
    8215 #line 2110 "parser.yy"
    8216     { (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) ) ); }
    82178218    break;
    82188219
     
    82208221
    82218222/* Line 1806 of yacc.c  */
    8222 #line 2120 "parser.yy"
     8223#line 2123 "parser.yy"
    82238224    { (yyval.decl) = 0; }
    82248225    break;
     
    82278228
    82288229/* Line 1806 of yacc.c  */
    8229 #line 2127 "parser.yy"
     8230#line 2130 "parser.yy"
    82308231    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    82318232    break;
     
    82348235
    82358236/* Line 1806 of yacc.c  */
    8236 #line 2133 "parser.yy"
     8237#line 2136 "parser.yy"
    82378238    { (yyval.decl) = 0; }
    82388239    break;
    82398240
    82408241  case 560:
    8241 
    8242 /* Line 1806 of yacc.c  */
    8243 #line 2148 "parser.yy"
    8244     {}
    8245     break;
    8246 
    8247   case 561:
    8248 
    8249 /* Line 1806 of yacc.c  */
    8250 #line 2149 "parser.yy"
    8251     {}
    8252     break;
    8253 
    8254   case 562:
    8255 
    8256 /* Line 1806 of yacc.c  */
    8257 #line 2150 "parser.yy"
    8258     {}
    8259     break;
    8260 
    8261   case 563:
    82628242
    82638243/* Line 1806 of yacc.c  */
     
    82668246    break;
    82678247
     8248  case 561:
     8249
     8250/* Line 1806 of yacc.c  */
     8251#line 2152 "parser.yy"
     8252    {}
     8253    break;
     8254
     8255  case 562:
     8256
     8257/* Line 1806 of yacc.c  */
     8258#line 2153 "parser.yy"
     8259    {}
     8260    break;
     8261
     8262  case 563:
     8263
     8264/* Line 1806 of yacc.c  */
     8265#line 2154 "parser.yy"
     8266    {}
     8267    break;
     8268
    82688269  case 564:
    8269 
    8270 /* Line 1806 of yacc.c  */
    8271 #line 2186 "parser.yy"
    8272     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8273     break;
    8274 
    8275   case 566:
    82768270
    82778271/* Line 1806 of yacc.c  */
     
    82808274    break;
    82818275
     8276  case 566:
     8277
     8278/* Line 1806 of yacc.c  */
     8279#line 2192 "parser.yy"
     8280    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8281    break;
     8282
    82828283  case 567:
    82838284
    82848285/* Line 1806 of yacc.c  */
    8285 #line 2191 "parser.yy"
     8286#line 2194 "parser.yy"
    82868287    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82878288    break;
     
    82908291
    82918292/* Line 1806 of yacc.c  */
    8292 #line 2196 "parser.yy"
     8293#line 2199 "parser.yy"
    82938294    {
    82948295                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    83008301
    83018302/* Line 1806 of yacc.c  */
    8302 #line 2201 "parser.yy"
     8303#line 2204 "parser.yy"
    83038304    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83048305    break;
     
    83078308
    83088309/* Line 1806 of yacc.c  */
    8309 #line 2206 "parser.yy"
     8310#line 2209 "parser.yy"
    83108311    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    83118312    break;
     
    83148315
    83158316/* Line 1806 of yacc.c  */
    8316 #line 2208 "parser.yy"
     8317#line 2211 "parser.yy"
    83178318    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    83188319    break;
     
    83218322
    83228323/* Line 1806 of yacc.c  */
    8323 #line 2210 "parser.yy"
     8324#line 2213 "parser.yy"
    83248325    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83258326    break;
     
    83288329
    83298330/* Line 1806 of yacc.c  */
    8330 #line 2215 "parser.yy"
     8331#line 2218 "parser.yy"
    83318332    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    83328333    break;
     
    83358336
    83368337/* Line 1806 of yacc.c  */
    8337 #line 2217 "parser.yy"
     8338#line 2220 "parser.yy"
    83388339    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83398340    break;
     
    83428343
    83438344/* Line 1806 of yacc.c  */
    8344 #line 2219 "parser.yy"
     8345#line 2222 "parser.yy"
    83458346    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83468347    break;
     
    83498350
    83508351/* Line 1806 of yacc.c  */
    8351 #line 2221 "parser.yy"
     8352#line 2224 "parser.yy"
    83528353    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83538354    break;
     
    83568357
    83578358/* Line 1806 of yacc.c  */
    8358 #line 2226 "parser.yy"
     8359#line 2229 "parser.yy"
    83598360    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83608361    break;
     
    83638364
    83648365/* Line 1806 of yacc.c  */
    8365 #line 2228 "parser.yy"
     8366#line 2231 "parser.yy"
    83668367    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83678368    break;
    83688369
    83698370  case 579:
    8370 
    8371 /* Line 1806 of yacc.c  */
    8372 #line 2237 "parser.yy"
    8373     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8374     break;
    8375 
    8376   case 581:
    83778371
    83788372/* Line 1806 of yacc.c  */
     
    83818375    break;
    83828376
     8377  case 581:
     8378
     8379/* Line 1806 of yacc.c  */
     8380#line 2243 "parser.yy"
     8381    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8382    break;
     8383
    83838384  case 582:
    83848385
    83858386/* Line 1806 of yacc.c  */
    8386 #line 2245 "parser.yy"
     8387#line 2248 "parser.yy"
    83878388    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    83888389    break;
     
    83918392
    83928393/* Line 1806 of yacc.c  */
    8393 #line 2247 "parser.yy"
     8394#line 2250 "parser.yy"
    83948395    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83958396    break;
     
    83988399
    83998400/* Line 1806 of yacc.c  */
    8400 #line 2249 "parser.yy"
     8401#line 2252 "parser.yy"
    84018402    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84028403    break;
     
    84058406
    84068407/* Line 1806 of yacc.c  */
    8407 #line 2254 "parser.yy"
     8408#line 2257 "parser.yy"
    84088409    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    84098410    break;
     
    84128413
    84138414/* Line 1806 of yacc.c  */
    8414 #line 2256 "parser.yy"
     8415#line 2259 "parser.yy"
    84158416    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84168417    break;
     
    84198420
    84208421/* Line 1806 of yacc.c  */
    8421 #line 2258 "parser.yy"
     8422#line 2261 "parser.yy"
    84228423    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84238424    break;
     
    84268427
    84278428/* Line 1806 of yacc.c  */
    8428 #line 2263 "parser.yy"
     8429#line 2266 "parser.yy"
    84298430    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84308431    break;
     
    84338434
    84348435/* Line 1806 of yacc.c  */
    8435 #line 2265 "parser.yy"
     8436#line 2268 "parser.yy"
    84368437    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84378438    break;
     
    84408441
    84418442/* Line 1806 of yacc.c  */
    8442 #line 2267 "parser.yy"
     8443#line 2270 "parser.yy"
    84438444    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84448445    break;
     
    84478448
    84488449/* Line 1806 of yacc.c  */
    8449 #line 2282 "parser.yy"
     8450#line 2285 "parser.yy"
    84508451    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    84518452    break;
     
    84548455
    84558456/* Line 1806 of yacc.c  */
    8456 #line 2284 "parser.yy"
     8457#line 2287 "parser.yy"
    84578458    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    84588459    break;
     
    84618462
    84628463/* Line 1806 of yacc.c  */
    8463 #line 2286 "parser.yy"
     8464#line 2289 "parser.yy"
    84648465    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84658466    break;
     
    84688469
    84698470/* Line 1806 of yacc.c  */
    8470 #line 2291 "parser.yy"
     8471#line 2294 "parser.yy"
    84718472    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    84728473    break;
     
    84758476
    84768477/* Line 1806 of yacc.c  */
    8477 #line 2293 "parser.yy"
     8478#line 2296 "parser.yy"
    84788479    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84798480    break;
     
    84828483
    84838484/* Line 1806 of yacc.c  */
    8484 #line 2295 "parser.yy"
     8485#line 2298 "parser.yy"
    84858486    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84868487    break;
     
    84898490
    84908491/* Line 1806 of yacc.c  */
    8491 #line 2300 "parser.yy"
     8492#line 2303 "parser.yy"
    84928493    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84938494    break;
     
    84968497
    84978498/* Line 1806 of yacc.c  */
    8498 #line 2302 "parser.yy"
     8499#line 2305 "parser.yy"
    84998500    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85008501    break;
     
    85038504
    85048505/* Line 1806 of yacc.c  */
    8505 #line 2304 "parser.yy"
     8506#line 2307 "parser.yy"
    85068507    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85078508    break;
    85088509
    85098510  case 603:
    8510 
    8511 /* Line 1806 of yacc.c  */
    8512 #line 2319 "parser.yy"
    8513     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8514     break;
    8515 
    8516   case 605:
    85178511
    85188512/* Line 1806 of yacc.c  */
     
    85218515    break;
    85228516
     8517  case 605:
     8518
     8519/* Line 1806 of yacc.c  */
     8520#line 2325 "parser.yy"
     8521    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8522    break;
     8523
    85238524  case 606:
    85248525
    85258526/* Line 1806 of yacc.c  */
    8526 #line 2324 "parser.yy"
     8527#line 2327 "parser.yy"
    85278528    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85288529    break;
     
    85318532
    85328533/* Line 1806 of yacc.c  */
    8533 #line 2330 "parser.yy"
     8534#line 2333 "parser.yy"
    85348535    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85358536    break;
     
    85388539
    85398540/* Line 1806 of yacc.c  */
    8540 #line 2335 "parser.yy"
     8541#line 2338 "parser.yy"
    85418542    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    85428543    break;
     
    85458546
    85468547/* Line 1806 of yacc.c  */
    8547 #line 2337 "parser.yy"
     8548#line 2340 "parser.yy"
    85488549    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    85498550    break;
     
    85528553
    85538554/* Line 1806 of yacc.c  */
    8554 #line 2339 "parser.yy"
     8555#line 2342 "parser.yy"
    85558556    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85568557    break;
     
    85598560
    85608561/* Line 1806 of yacc.c  */
    8561 #line 2344 "parser.yy"
     8562#line 2347 "parser.yy"
    85628563    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    85638564    break;
     
    85668567
    85678568/* Line 1806 of yacc.c  */
    8568 #line 2346 "parser.yy"
     8569#line 2349 "parser.yy"
    85698570    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85708571    break;
     
    85738574
    85748575/* Line 1806 of yacc.c  */
    8575 #line 2348 "parser.yy"
     8576#line 2351 "parser.yy"
    85768577    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85778578    break;
     
    85808581
    85818582/* Line 1806 of yacc.c  */
    8582 #line 2350 "parser.yy"
     8583#line 2353 "parser.yy"
    85838584    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85848585    break;
     
    85878588
    85888589/* Line 1806 of yacc.c  */
    8589 #line 2355 "parser.yy"
     8590#line 2358 "parser.yy"
    85908591    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    85918592    break;
     
    85948595
    85958596/* Line 1806 of yacc.c  */
    8596 #line 2357 "parser.yy"
     8597#line 2360 "parser.yy"
    85978598    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85988599    break;
     
    86018602
    86028603/* Line 1806 of yacc.c  */
    8603 #line 2359 "parser.yy"
     8604#line 2362 "parser.yy"
    86048605    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86058606    break;
    86068607
    86078608  case 619:
    8608 
    8609 /* Line 1806 of yacc.c  */
    8610 #line 2369 "parser.yy"
    8611     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8612     break;
    8613 
    8614   case 621:
    86158609
    86168610/* Line 1806 of yacc.c  */
     
    86198613    break;
    86208614
     8615  case 621:
     8616
     8617/* Line 1806 of yacc.c  */
     8618#line 2375 "parser.yy"
     8619    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8620    break;
     8621
    86218622  case 622:
    86228623
    86238624/* Line 1806 of yacc.c  */
    8624 #line 2374 "parser.yy"
     8625#line 2377 "parser.yy"
    86258626    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86268627    break;
     
    86298630
    86308631/* Line 1806 of yacc.c  */
    8631 #line 2379 "parser.yy"
     8632#line 2382 "parser.yy"
    86328633    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    86338634    break;
     
    86368637
    86378638/* Line 1806 of yacc.c  */
    8638 #line 2381 "parser.yy"
     8639#line 2384 "parser.yy"
    86398640    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    86408641    break;
     
    86438644
    86448645/* Line 1806 of yacc.c  */
    8645 #line 2383 "parser.yy"
     8646#line 2386 "parser.yy"
    86468647    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86478648    break;
     
    86508651
    86518652/* Line 1806 of yacc.c  */
    8652 #line 2388 "parser.yy"
     8653#line 2391 "parser.yy"
    86538654    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    86548655    break;
     
    86578658
    86588659/* Line 1806 of yacc.c  */
    8659 #line 2390 "parser.yy"
     8660#line 2393 "parser.yy"
    86608661    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86618662    break;
     
    86648665
    86658666/* Line 1806 of yacc.c  */
    8666 #line 2392 "parser.yy"
     8667#line 2395 "parser.yy"
    86678668    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86688669    break;
     
    86718672
    86728673/* Line 1806 of yacc.c  */
    8673 #line 2394 "parser.yy"
     8674#line 2397 "parser.yy"
    86748675    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86758676    break;
     
    86788679
    86798680/* Line 1806 of yacc.c  */
    8680 #line 2399 "parser.yy"
     8681#line 2402 "parser.yy"
    86818682    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    86828683    break;
     
    86858686
    86868687/* Line 1806 of yacc.c  */
    8687 #line 2401 "parser.yy"
     8688#line 2404 "parser.yy"
    86888689    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    86898690    break;
     
    86928693
    86938694/* Line 1806 of yacc.c  */
    8694 #line 2403 "parser.yy"
     8695#line 2406 "parser.yy"
    86958696    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86968697    break;
    86978698
    86988699  case 633:
    8699 
    8700 /* Line 1806 of yacc.c  */
    8701 #line 2434 "parser.yy"
    8702     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8703     break;
    8704 
    8705   case 635:
    87068700
    87078701/* Line 1806 of yacc.c  */
     
    87108704    break;
    87118705
     8706  case 635:
     8707
     8708/* Line 1806 of yacc.c  */
     8709#line 2440 "parser.yy"
     8710    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8711    break;
     8712
    87128713  case 636:
    87138714
    87148715/* Line 1806 of yacc.c  */
    8715 #line 2439 "parser.yy"
     8716#line 2442 "parser.yy"
    87168717    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87178718    break;
     
    87208721
    87218722/* Line 1806 of yacc.c  */
    8722 #line 2444 "parser.yy"
     8723#line 2447 "parser.yy"
    87238724    {
    87248725                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    87308731
    87318732/* Line 1806 of yacc.c  */
    8732 #line 2449 "parser.yy"
     8733#line 2452 "parser.yy"
    87338734    {
    87348735                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    87408741
    87418742/* Line 1806 of yacc.c  */
    8742 #line 2457 "parser.yy"
     8743#line 2460 "parser.yy"
    87438744    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    87448745    break;
     
    87478748
    87488749/* Line 1806 of yacc.c  */
    8749 #line 2459 "parser.yy"
     8750#line 2462 "parser.yy"
    87508751    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    87518752    break;
     
    87548755
    87558756/* Line 1806 of yacc.c  */
    8756 #line 2461 "parser.yy"
     8757#line 2464 "parser.yy"
    87578758    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87588759    break;
     
    87618762
    87628763/* Line 1806 of yacc.c  */
    8763 #line 2466 "parser.yy"
     8764#line 2469 "parser.yy"
    87648765    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    87658766    break;
     
    87688769
    87698770/* Line 1806 of yacc.c  */
    8770 #line 2468 "parser.yy"
     8771#line 2471 "parser.yy"
    87718772    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87728773    break;
     
    87758776
    87768777/* Line 1806 of yacc.c  */
    8777 #line 2473 "parser.yy"
     8778#line 2476 "parser.yy"
    87788779    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    87798780    break;
     
    87828783
    87838784/* Line 1806 of yacc.c  */
    8784 #line 2475 "parser.yy"
     8785#line 2478 "parser.yy"
    87858786    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87868787    break;
     
    87898790
    87908791/* Line 1806 of yacc.c  */
    8791 #line 2490 "parser.yy"
     8792#line 2493 "parser.yy"
    87928793    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87938794    break;
     
    87968797
    87978798/* Line 1806 of yacc.c  */
    8798 #line 2492 "parser.yy"
     8799#line 2495 "parser.yy"
    87998800    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    88008801    break;
     
    88038804
    88048805/* Line 1806 of yacc.c  */
    8805 #line 2497 "parser.yy"
     8806#line 2500 "parser.yy"
    88068807    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    88078808    break;
     
    88108811
    88118812/* Line 1806 of yacc.c  */
    8812 #line 2499 "parser.yy"
     8813#line 2502 "parser.yy"
    88138814    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    88148815    break;
     
    88178818
    88188819/* Line 1806 of yacc.c  */
    8819 #line 2501 "parser.yy"
     8820#line 2504 "parser.yy"
    88208821    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    88218822    break;
     
    88248825
    88258826/* Line 1806 of yacc.c  */
    8826 #line 2503 "parser.yy"
     8827#line 2506 "parser.yy"
    88278828    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    88288829    break;
     
    88318832
    88328833/* Line 1806 of yacc.c  */
    8833 #line 2505 "parser.yy"
     8834#line 2508 "parser.yy"
    88348835    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88358836    break;
     
    88388839
    88398840/* Line 1806 of yacc.c  */
    8840 #line 2511 "parser.yy"
     8841#line 2514 "parser.yy"
    88418842    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    88428843    break;
     
    88458846
    88468847/* Line 1806 of yacc.c  */
    8847 #line 2513 "parser.yy"
     8848#line 2516 "parser.yy"
    88488849    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    88498850    break;
     
    88528853
    88538854/* Line 1806 of yacc.c  */
    8854 #line 2515 "parser.yy"
     8855#line 2518 "parser.yy"
    88558856    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88568857    break;
     
    88598860
    88608861/* Line 1806 of yacc.c  */
    8861 #line 2520 "parser.yy"
     8862#line 2523 "parser.yy"
    88628863    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    88638864    break;
     
    88668867
    88678868/* Line 1806 of yacc.c  */
    8868 #line 2522 "parser.yy"
     8869#line 2525 "parser.yy"
    88698870    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    88708871    break;
     
    88738874
    88748875/* Line 1806 of yacc.c  */
    8875 #line 2524 "parser.yy"
     8876#line 2527 "parser.yy"
    88768877    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88778878    break;
     
    88808881
    88818882/* Line 1806 of yacc.c  */
    8882 #line 2530 "parser.yy"
     8883#line 2533 "parser.yy"
    88838884    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    88848885    break;
     
    88878888
    88888889/* Line 1806 of yacc.c  */
    8889 #line 2532 "parser.yy"
     8890#line 2535 "parser.yy"
    88908891    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    88918892    break;
     
    88948895
    88958896/* Line 1806 of yacc.c  */
    8896 #line 2538 "parser.yy"
     8897#line 2541 "parser.yy"
    88978898    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    88988899    break;
     
    89018902
    89028903/* Line 1806 of yacc.c  */
    8903 #line 2540 "parser.yy"
     8904#line 2543 "parser.yy"
    89048905    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    89058906    break;
     
    89088909
    89098910/* Line 1806 of yacc.c  */
    8910 #line 2542 "parser.yy"
     8911#line 2545 "parser.yy"
    89118912    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    89128913    break;
     
    89158916
    89168917/* Line 1806 of yacc.c  */
    8917 #line 2544 "parser.yy"
     8918#line 2547 "parser.yy"
    89188919    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    89198920    break;
     
    89228923
    89238924/* Line 1806 of yacc.c  */
    8924 #line 2559 "parser.yy"
     8925#line 2562 "parser.yy"
    89258926    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    89268927    break;
     
    89298930
    89308931/* Line 1806 of yacc.c  */
    8931 #line 2561 "parser.yy"
     8932#line 2564 "parser.yy"
    89328933    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    89338934    break;
     
    89368937
    89378938/* Line 1806 of yacc.c  */
    8938 #line 2566 "parser.yy"
     8939#line 2569 "parser.yy"
    89398940    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    89408941    break;
     
    89438944
    89448945/* Line 1806 of yacc.c  */
    8945 #line 2568 "parser.yy"
     8946#line 2571 "parser.yy"
    89468947    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    89478948    break;
     
    89508951
    89518952/* Line 1806 of yacc.c  */
    8952 #line 2570 "parser.yy"
     8953#line 2573 "parser.yy"
    89538954    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    89548955    break;
     
    89578958
    89588959/* Line 1806 of yacc.c  */
    8959 #line 2572 "parser.yy"
     8960#line 2575 "parser.yy"
    89608961    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    89618962    break;
     
    89648965
    89658966/* Line 1806 of yacc.c  */
    8966 #line 2574 "parser.yy"
     8967#line 2577 "parser.yy"
    89678968    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89688969    break;
     
    89718972
    89728973/* Line 1806 of yacc.c  */
    8973 #line 2580 "parser.yy"
     8974#line 2583 "parser.yy"
    89748975    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    89758976    break;
     
    89788979
    89798980/* Line 1806 of yacc.c  */
    8980 #line 2582 "parser.yy"
     8981#line 2585 "parser.yy"
    89818982    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    89828983    break;
     
    89858986
    89868987/* Line 1806 of yacc.c  */
    8987 #line 2584 "parser.yy"
     8988#line 2587 "parser.yy"
    89888989    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89898990    break;
     
    89928993
    89938994/* Line 1806 of yacc.c  */
    8994 #line 2589 "parser.yy"
     8995#line 2592 "parser.yy"
    89958996    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    89968997    break;
     
    89999000
    90009001/* Line 1806 of yacc.c  */
    9001 #line 2591 "parser.yy"
     9002#line 2594 "parser.yy"
    90029003    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    90039004    break;
     
    90069007
    90079008/* Line 1806 of yacc.c  */
    9008 #line 2593 "parser.yy"
     9009#line 2596 "parser.yy"
    90099010    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    90109011    break;
     
    90139014
    90149015/* Line 1806 of yacc.c  */
    9015 #line 2600 "parser.yy"
     9016#line 2603 "parser.yy"
    90169017    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    90179018    break;
     
    90209021
    90219022/* Line 1806 of yacc.c  */
    9022 #line 2611 "parser.yy"
     9023#line 2614 "parser.yy"
    90239024    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    90249025    break;
     
    90279028
    90289029/* Line 1806 of yacc.c  */
    9029 #line 2614 "parser.yy"
     9030#line 2617 "parser.yy"
    90309031    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    90319032    break;
     
    90349035
    90359036/* Line 1806 of yacc.c  */
    9036 #line 2616 "parser.yy"
     9037#line 2619 "parser.yy"
    90379038    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    90389039    break;
     
    90419042
    90429043/* Line 1806 of yacc.c  */
    9043 #line 2619 "parser.yy"
     9044#line 2622 "parser.yy"
    90449045    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    90459046    break;
     
    90489049
    90499050/* Line 1806 of yacc.c  */
    9050 #line 2621 "parser.yy"
     9051#line 2624 "parser.yy"
    90519052    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    90529053    break;
     
    90559056
    90569057/* Line 1806 of yacc.c  */
    9057 #line 2623 "parser.yy"
     9058#line 2626 "parser.yy"
    90589059    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    90599060    break;
     
    90629063
    90639064/* Line 1806 of yacc.c  */
    9064 #line 2637 "parser.yy"
     9065#line 2640 "parser.yy"
    90659066    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    90669067    break;
     
    90699070
    90709071/* Line 1806 of yacc.c  */
    9071 #line 2639 "parser.yy"
     9072#line 2642 "parser.yy"
    90729073    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    90739074    break;
     
    90769077
    90779078/* Line 1806 of yacc.c  */
    9078 #line 2644 "parser.yy"
     9079#line 2647 "parser.yy"
    90799080    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    90809081    break;
     
    90839084
    90849085/* Line 1806 of yacc.c  */
    9085 #line 2646 "parser.yy"
     9086#line 2649 "parser.yy"
    90869087    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    90879088    break;
     
    90909091
    90919092/* Line 1806 of yacc.c  */
    9092 #line 2648 "parser.yy"
     9093#line 2651 "parser.yy"
    90939094    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    90949095    break;
     
    90979098
    90989099/* Line 1806 of yacc.c  */
    9099 #line 2650 "parser.yy"
     9100#line 2653 "parser.yy"
    91009101    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    91019102    break;
     
    91049105
    91059106/* Line 1806 of yacc.c  */
    9106 #line 2652 "parser.yy"
     9107#line 2655 "parser.yy"
    91079108    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    91089109    break;
     
    91119112
    91129113/* Line 1806 of yacc.c  */
    9113 #line 2658 "parser.yy"
     9114#line 2661 "parser.yy"
    91149115    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    91159116    break;
     
    91189119
    91199120/* Line 1806 of yacc.c  */
    9120 #line 2660 "parser.yy"
     9121#line 2663 "parser.yy"
    91219122    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    91229123    break;
     
    91259126
    91269127/* Line 1806 of yacc.c  */
    9127 #line 2662 "parser.yy"
     9128#line 2665 "parser.yy"
    91289129    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    91299130    break;
     
    91329133
    91339134/* Line 1806 of yacc.c  */
    9134 #line 2667 "parser.yy"
     9135#line 2670 "parser.yy"
    91359136    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    91369137    break;
     
    91399140
    91409141/* Line 1806 of yacc.c  */
    9141 #line 2669 "parser.yy"
     9142#line 2672 "parser.yy"
    91429143    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    91439144    break;
     
    91469147
    91479148/* Line 1806 of yacc.c  */
    9148 #line 2679 "parser.yy"
     9149#line 2682 "parser.yy"
    91499150    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    91509151    break;
     
    91539154
    91549155/* Line 1806 of yacc.c  */
    9155 #line 2689 "parser.yy"
     9156#line 2692 "parser.yy"
    91569157    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91579158    break;
     
    91609161
    91619162/* Line 1806 of yacc.c  */
    9162 #line 2691 "parser.yy"
     9163#line 2694 "parser.yy"
    91639164    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91649165    break;
     
    91679168
    91689169/* Line 1806 of yacc.c  */
    9169 #line 2693 "parser.yy"
     9170#line 2696 "parser.yy"
    91709171    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91719172    break;
     
    91749175
    91759176/* Line 1806 of yacc.c  */
    9176 #line 2695 "parser.yy"
     9177#line 2698 "parser.yy"
    91779178    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91789179    break;
     
    91819182
    91829183/* Line 1806 of yacc.c  */
    9183 #line 2697 "parser.yy"
     9184#line 2700 "parser.yy"
    91849185    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91859186    break;
     
    91889189
    91899190/* Line 1806 of yacc.c  */
    9190 #line 2699 "parser.yy"
     9191#line 2702 "parser.yy"
    91919192    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91929193    break;
     
    91959196
    91969197/* Line 1806 of yacc.c  */
    9197 #line 2706 "parser.yy"
     9198#line 2709 "parser.yy"
    91989199    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    91999200    break;
     
    92029203
    92039204/* Line 1806 of yacc.c  */
    9204 #line 2708 "parser.yy"
     9205#line 2711 "parser.yy"
    92059206    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    92069207    break;
     
    92099210
    92109211/* Line 1806 of yacc.c  */
    9211 #line 2710 "parser.yy"
     9212#line 2713 "parser.yy"
    92129213    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    92139214    break;
     
    92169217
    92179218/* Line 1806 of yacc.c  */
    9218 #line 2712 "parser.yy"
     9219#line 2715 "parser.yy"
    92199220    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    92209221    break;
     
    92239224
    92249225/* Line 1806 of yacc.c  */
    9225 #line 2714 "parser.yy"
     9226#line 2717 "parser.yy"
    92269227    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    92279228    break;
     
    92309231
    92319232/* Line 1806 of yacc.c  */
    9232 #line 2716 "parser.yy"
     9233#line 2719 "parser.yy"
    92339234    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    92349235    break;
     
    92379238
    92389239/* Line 1806 of yacc.c  */
    9239 #line 2718 "parser.yy"
     9240#line 2721 "parser.yy"
    92409241    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    92419242    break;
     
    92449245
    92459246/* Line 1806 of yacc.c  */
    9246 #line 2720 "parser.yy"
     9247#line 2723 "parser.yy"
    92479248    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    92489249    break;
     
    92519252
    92529253/* Line 1806 of yacc.c  */
    9253 #line 2722 "parser.yy"
     9254#line 2725 "parser.yy"
    92549255    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    92559256    break;
     
    92589259
    92599260/* Line 1806 of yacc.c  */
    9260 #line 2724 "parser.yy"
     9261#line 2727 "parser.yy"
    92619262    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    92629263    break;
     
    92659266
    92669267/* Line 1806 of yacc.c  */
    9267 #line 2729 "parser.yy"
     9268#line 2732 "parser.yy"
    92689269    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    92699270    break;
     
    92729273
    92739274/* Line 1806 of yacc.c  */
    9274 #line 2731 "parser.yy"
     9275#line 2734 "parser.yy"
    92759276    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    92769277    break;
     
    92799280
    92809281/* Line 1806 of yacc.c  */
    9281 #line 2736 "parser.yy"
     9282#line 2739 "parser.yy"
    92829283    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
    92839284    break;
     
    92869287
    92879288/* Line 1806 of yacc.c  */
    9288 #line 2738 "parser.yy"
     9289#line 2741 "parser.yy"
    92899290    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
    92909291    break;
     
    92939294
    92949295/* Line 1806 of yacc.c  */
    9295 #line 2765 "parser.yy"
     9296#line 2768 "parser.yy"
    92969297    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    92979298    break;
     
    93009301
    93019302/* Line 1806 of yacc.c  */
    9302 #line 2776 "parser.yy"
     9303#line 2779 "parser.yy"
    93039304    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    93049305    break;
     
    93079308
    93089309/* Line 1806 of yacc.c  */
    9309 #line 2778 "parser.yy"
     9310#line 2781 "parser.yy"
    93109311    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    93119312    break;
     
    93149315
    93159316/* Line 1806 of yacc.c  */
    9316 #line 2780 "parser.yy"
     9317#line 2783 "parser.yy"
    93179318    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    93189319    break;
     
    93219322
    93229323/* Line 1806 of yacc.c  */
    9323 #line 2782 "parser.yy"
     9324#line 2785 "parser.yy"
    93249325    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    93259326    break;
     
    93289329
    93299330/* Line 1806 of yacc.c  */
    9330 #line 2784 "parser.yy"
     9331#line 2787 "parser.yy"
    93319332    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    93329333    break;
     
    93359336
    93369337/* Line 1806 of yacc.c  */
    9337 #line 2786 "parser.yy"
     9338#line 2789 "parser.yy"
    93389339    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    93399340    break;
     
    93429343
    93439344/* Line 1806 of yacc.c  */
    9344 #line 2793 "parser.yy"
     9345#line 2796 "parser.yy"
    93459346    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    93469347    break;
     
    93499350
    93509351/* Line 1806 of yacc.c  */
    9351 #line 2795 "parser.yy"
     9352#line 2798 "parser.yy"
    93529353    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    93539354    break;
     
    93569357
    93579358/* Line 1806 of yacc.c  */
    9358 #line 2797 "parser.yy"
     9359#line 2800 "parser.yy"
    93599360    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    93609361    break;
     
    93639364
    93649365/* Line 1806 of yacc.c  */
    9365 #line 2799 "parser.yy"
     9366#line 2802 "parser.yy"
    93669367    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    93679368    break;
     
    93709371
    93719372/* Line 1806 of yacc.c  */
    9372 #line 2801 "parser.yy"
     9373#line 2804 "parser.yy"
    93739374    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    93749375    break;
     
    93779378
    93789379/* Line 1806 of yacc.c  */
    9379 #line 2803 "parser.yy"
     9380#line 2806 "parser.yy"
    93809381    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    93819382    break;
     
    93849385
    93859386/* Line 1806 of yacc.c  */
    9386 #line 2808 "parser.yy"
     9387#line 2811 "parser.yy"
    93879388    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    93889389    break;
     
    93919392
    93929393/* Line 1806 of yacc.c  */
    9393 #line 2813 "parser.yy"
     9394#line 2816 "parser.yy"
    93949395    { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); }
    93959396    break;
     
    93989399
    93999400/* Line 1806 of yacc.c  */
    9400 #line 2815 "parser.yy"
     9401#line 2818 "parser.yy"
    94019402    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    94029403    break;
     
    94059406
    94069407/* Line 1806 of yacc.c  */
    9407 #line 2817 "parser.yy"
     9408#line 2820 "parser.yy"
    94089409    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    94099410    break;
     
    94129413
    94139414/* Line 1806 of yacc.c  */
    9414 #line 2841 "parser.yy"
     9415#line 2844 "parser.yy"
    94159416    { (yyval.en) = 0; }
    94169417    break;
     
    94199420
    94209421/* Line 1806 of yacc.c  */
    9421 #line 2843 "parser.yy"
     9422#line 2846 "parser.yy"
    94229423    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    94239424    break;
     
    94269427
    94279428/* Line 1806 of yacc.c  */
    9428 #line 9429 "Parser/parser.cc"
     9429#line 9430 "Parser/parser.cc"
    94299430      default: break;
    94309431    }
     
    96579658
    96589659/* Line 2067 of yacc.c  */
    9659 #line 2846 "parser.yy"
     9660#line 2849 "parser.yy"
    96609661
    96619662// ----end of grammar----
  • src/Parser/parser.yy

    rb87e2b6 r51e076e  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug  4 16:56:28 2016
    13 // Update Count     : 1694
     12// Last Modified On : Fri Aug  5 08:15:57 2016
     13// Update Count     : 1721
    1414//
    1515
     
    356356                // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
    357357                // equivalent to the old x[i,j].
    358                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Index ), $1, $4 ); }
     358                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Index, $1, $4 ) ); }
    359359        | postfix_expression '(' argument_expression_list ')'
    360360                { $$ = new CompositeExprNode( $1, $3 ); }
     
    368368        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
    369369        | postfix_expression ICR
    370                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::IncrPost ), $1 ); }
     370                { $$ = new CompositeExprNode2( build_opr1( OperatorNode::IncrPost, $1 ) ); }
    371371        | postfix_expression DECR
    372                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::DecrPost ), $1 ); }
     372                { $$ = new CompositeExprNode2( build_opr1( OperatorNode::DecrPost, $1 ) ); }
    373373        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
    374374                { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); }
     
    431431        | EXTENSION cast_expression                                                     // GCC
    432432                { $$ = $2->set_extension( true ); }
    433         | ptrref_operator cast_expression                                       // CFA
    434         { $$ = $1 == OperatorNode::AddressOf ? (ExpressionNode*) new CompositeExprNode2( build_addressOf( $2 ) ) : (ExpressionNode*)new CompositeExprNode( new OperatorNode ( $1 ), $2 ); }
    435433                // '*' ('&') is separated from unary_operator because of shift/reduce conflict in:
    436434                //              { * X; }         // dereference X
    437435                //              { * int X; } // CFA declaration of pointer to int
     436        | ptrref_operator cast_expression                                       // CFA
     437                { $$ = $1 == OperatorNode::AddressOf ? (ExpressionNode*) new CompositeExprNode2( build_addressOf( $2 ) )
     438                                                                                        : (ExpressionNode*)new CompositeExprNode( new OperatorNode ( $1 ), $2 ); }
    438439        | unary_operator cast_expression
    439440                { $$ = new CompositeExprNode( $1, $2 ); }
    440441        | ICR unary_expression
    441                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Incr ), $2 ); }
     442                { $$ = new CompositeExprNode2( build_opr1( OperatorNode::Incr, $2 ) ); }
    442443        | DECR unary_expression
    443                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Decr ), $2 ); }
     444                { $$ = new CompositeExprNode2( build_opr1( OperatorNode::Decr, $2 ) ); }
    444445        | SIZEOF unary_expression
    445446                { $$ = new CompositeExprNode2( build_sizeOf( $2 ) ); }
     
    449450                { $$ = new CompositeExprNode2( build_offsetOf( new TypeValueNode( $3 ), new VarRefNode( $5 ) ) ); }
    450451        | ATTR_IDENTIFIER
    451                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 )); }
     452                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ) ); }
    452453        | ATTR_IDENTIFIER '(' type_name ')'
    453                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), new TypeValueNode( $3 )); }
     454                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), new TypeValueNode( $3 ) ); }
    454455        | ATTR_IDENTIFIER '(' argument_expression ')'
    455456                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Attr ), new VarRefNode( $1 ), $3 ); }
     
    487488        cast_expression
    488489        | multiplicative_expression '*' cast_expression
    489                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Mul ), $1, $3 ); }
     490                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Mul, $1, $3 ) ); }
    490491        | multiplicative_expression '/' cast_expression
    491                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Div ), $1, $3 ); }
     492                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Div, $1, $3 ) ); }
    492493        | multiplicative_expression '%' cast_expression
    493                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Mod ), $1, $3 ); }
     494                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Mod, $1, $3 ) ); }
    494495        ;
    495496
     
    497498        multiplicative_expression
    498499        | additive_expression '+' multiplicative_expression
    499                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Plus ), $1, $3 ); }
     500                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Plus, $1, $3 ) ); }
    500501        | additive_expression '-' multiplicative_expression
    501                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Minus ), $1, $3 ); }
     502                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Minus, $1, $3 ) ); }
    502503        ;
    503504
     
    505506        additive_expression
    506507        | shift_expression LS additive_expression
    507                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LShift ), $1, $3 ); }
     508                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LShift, $1, $3 ) ); }
    508509        | shift_expression RS additive_expression
    509                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::RShift ), $1, $3 ); }
     510                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::RShift, $1, $3 ) ); }
    510511        ;
    511512
     
    513514        shift_expression
    514515        | relational_expression '<' shift_expression
    515                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LThan ), $1, $3 ); }
     516                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LThan, $1, $3 ) ); }
    516517        | relational_expression '>' shift_expression
    517                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::GThan ), $1, $3 ); }
     518                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::GThan, $1, $3 ) ); }
    518519        | relational_expression LE shift_expression
    519                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LEThan ), $1, $3 ); }
     520                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::LEThan, $1, $3 ) ); }
    520521        | relational_expression GE shift_expression
    521                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::GEThan ), $1, $3 ); }
     522                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::GEThan, $1, $3 ) ); }
    522523        ;
    523524
     
    525526        relational_expression
    526527        | equality_expression EQ relational_expression
    527                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Eq ), $1, $3 ); }
     528                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Eq, $1, $3 ) ); }
    528529        | equality_expression NE relational_expression
    529                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Neq ), $1, $3 ); }
     530                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Neq, $1, $3 ) ); }
    530531        ;
    531532
     
    533534        equality_expression
    534535        | AND_expression '&' equality_expression
    535                 { $$ =new CompositeExprNode( new OperatorNode( OperatorNode::BitAnd ), $1, $3 ); }
     536                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::BitAnd, $1, $3 ) ); }
    536537        ;
    537538
     
    539540        AND_expression
    540541        | exclusive_OR_expression '^' AND_expression
    541                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Xor ), $1, $3 ); }
     542                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Xor, $1, $3 ) ); }
    542543        ;
    543544
     
    545546        exclusive_OR_expression
    546547        | inclusive_OR_expression '|' exclusive_OR_expression
    547                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::BitOr ), $1, $3 ); }
     548                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::BitOr, $1, $3 ) ); }
    548549        ;
    549550
     
    551552        inclusive_OR_expression
    552553        | logical_AND_expression ANDAND inclusive_OR_expression
    553                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::And ), $1, $3 ); }
     554                { $$ = new CompositeExprNode2( build_and_or( $1, $3, true ) ); }
    554555        ;
    555556
     
    557558        logical_AND_expression
    558559        | logical_OR_expression OROR logical_AND_expression
    559                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Or ), $1, $3 ); }
     560                { $$ = new CompositeExprNode2( build_and_or( $1, $3, false ) ); }
    560561        ;
    561562
     
    563564        logical_OR_expression
    564565        | logical_OR_expression '?' comma_expression ':' conditional_expression
    565                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*$1, *$3, *$5 ) ) ); }
     566                { $$ = new CompositeExprNode2( build_cond( $1, $3, $5 ) ); }
    566567        | logical_OR_expression '?' /* empty */ ':' conditional_expression // GCC, omitted first operand
    567                 { $$=new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), $1, $4 ); }
     568                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::NCond ), $1, $4 ); }
    568569        | logical_OR_expression '?' comma_expression ':' tuple // CFA, tuple expression
    569                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Cond ), (ExpressionNode *)mkList( (*$1, *$3, *$5 ) ) ); }
     570                { $$ = new CompositeExprNode2( build_cond( $1, $3, $5 ) ); }
    570571        ;
    571572
     
    578579        conditional_expression
    579580        | unary_expression '=' assignment_expression
    580                 { $$ =new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $3 ); }
     581                { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $3 ); }
    581582        | unary_expression assignment_operator assignment_expression
    582                 { $$ =new CompositeExprNode( $2, $1, $3 ); }
     583                { $$ = new CompositeExprNode( $2, $1, $3 ); }
    583584        | tuple assignment_opt                                                          // CFA, tuple expression
    584585                { $$ = ( $2 == 0 ) ? $1 : new CompositeExprNode( new OperatorNode( OperatorNode::Assign ), $1, $2 ); }
     
    626627        assignment_expression
    627628        | comma_expression ',' assignment_expression    // { $$ = (ExpressionNode *)$1->add_to_list( $3 ); }
    628                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Comma ), $1, $3 ); }
     629        //{ $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Comma ), $1, $3 ); }
     630                { $$ = new CompositeExprNode2( build_comma( $1, $3 ) ); }
    629631        ;
    630632
     
    738740        constant_expression                                                     { $$ = $1; }
    739741        | constant_expression ELLIPSIS constant_expression      // GCC, subrange
    740                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), $1, $3 ); }
     742                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Range, $1, $3 ) ); }
    741743        | subrange                                                                                      // CFA, subrange
    742744        ;
     
    17791781                { $$ = new DesignatorNode( $3, true ); }
    17801782        | '[' push constant_expression ELLIPSIS constant_expression pop ']' // GCC, multiple array elements
    1781                 { $$ = new DesignatorNode( new CompositeExprNode( new OperatorNode( OperatorNode::Range ), $3, $5 ), true ); }
     1783                { $$ = new DesignatorNode( new CompositeExprNode2( build_opr2( OperatorNode::Range, $3, $5 ) ), true ); }
    17821784        | '.' '[' push field_list pop ']'                                       // CFA, tuple field selector
    17831785                { $$ = new DesignatorNode( $4 ); }
     
    21082110subrange:
    21092111        constant_expression '~' constant_expression                     // CFA, integer subrange
    2110                 { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::Range ), $1, $3 ); }
     2112                { $$ = new CompositeExprNode2( build_opr2( OperatorNode::Range, $1, $3 ) ); }
    21112113        ;
    21122114
Note: See TracChangeset for help on using the changeset viewer.