Changeset d9e2280


Ignore:
Timestamp:
Aug 5, 2016, 3:56:24 PM (5 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
35f9114
Parents:
71a3593
Message:

even more more refactoring of parser code

Location:
src
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/ExpressionNode.cc

    r71a3593 rd9e2280  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 11:39:25 2016
    13 // Update Count     : 391
     12// Last Modified On : Fri Aug  5 15:07:19 2016
     13// Update Count     : 409
    1414//
    1515
     
    238238//##############################################################################
    239239
    240 static const char *opName[] = {
    241         "TupleC", "Comma", "TupleFieldSel", // "TuplePFieldSel", // n-adic
    242         // triadic
    243         "Cond", "NCond",
     240static const char *OperName[] = {
    244241        // diadic
    245242        "SizeOf", "AlignOf", "OffsetOf", "Attr", "?+?", "?-?", "?*?", "?/?", "?%?", "||", "&&",
    246243        "?|?", "?&?", "?^?", "Cast", "?<<?", "?>>?", "?<?", "?>?", "?<=?", "?>=?", "?==?", "?!=?",
    247244        "?=?", "?*=?", "?/=?", "?%=?", "?+=?", "?-=?", "?<<=?", "?>>=?", "?&=?", "?^=?", "?|=?",
    248         "?[?]", "FieldSel", "PFieldSel", "...",
     245        "?[?]", "...",
    249246        // monadic
    250247        "+?", "-?", "AddressOf", "*?", "!?", "~?", "++?", "?++", "--?", "?--", "&&"
    251248};
    252249
    253 OperatorNode::OperatorNode( Type t ) : type( t ) {}
    254 
    255 OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) {
    256 }
    257 
    258 OperatorNode::~OperatorNode() {}
    259 
    260 OperatorNode::Type OperatorNode::get_type( void ) const {
    261         return type;
    262 }
    263 
    264 void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
    265         printDesignation( os );
    266         os << opName[ type ] << ' ';
    267 }
    268 
    269 void OperatorNode::print( std::ostream &os, int indent ) const{
    270         printDesignation( os );
    271         os << string( indent, ' ' ) << "Operator: " << opName[type] << endl;
    272         return;
    273 }
    274 
    275 const char *OperatorNode::get_typename( void ) const{
    276         return opName[ type ];
    277 }
    278 
    279 //##############################################################################
    280 
    281 CompositeExprNode::CompositeExprNode() : ExpressionNode(), function( 0 ), arguments( 0 ) {
    282 }
    283 
    284 CompositeExprNode::CompositeExprNode( const string *name_ ) : ExpressionNode( name_ ), function( 0 ), arguments( 0 ) {
    285 }
    286 
    287 CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *args ):
    288         function( f ), arguments( args ) {
    289 }
    290 
    291 CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 ):
    292         function( f ), arguments( arg1 ) {
    293         arguments->set_link( arg2 );
    294 }
    295 
    296 CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : ExpressionNode( other ), function( maybeClone( other.function ) ), arguments( 0 ) {
    297         ParseNode *cur = other.arguments;
    298         while ( cur ) {
    299                 if ( arguments ) {
    300                         arguments->set_link( cur->clone() );
    301                 } else {
    302                         arguments = ( ExpressionNode*)cur->clone();
    303                 } // if
    304                 cur = cur->get_link();
    305         }
    306 }
    307 
    308 CompositeExprNode::~CompositeExprNode() {
    309         delete function;
    310         delete arguments;
    311 }
    312 
     250//##############################################################################
     251
     252CompositeExprNode::CompositeExprNode( Expression *expr ) : expr( expr ) {}
     253CompositeExprNode::CompositeExprNode( const CompositeExprNode &other ) : expr( other.expr->clone() ) {}
     254CompositeExprNode::~CompositeExprNode() { delete expr; }
     255void CompositeExprNode::print( std::ostream &, int indent ) const { assert( false ); }
     256void CompositeExprNode::printOneLine( std::ostream &, int indent ) const { assert( false ); }
    313257
    314258Expression *build_cast( TypeValueNode * arg, ExpressionNode *expr_node ) {
     
    369313}
    370314
    371 Expression *build_unary_val( OperatorNode::Type op, ExpressionNode *expr_node ) {
     315Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ) {
    372316        std::list<Expression *> args;
    373317        args.push_back( maybeBuild<Expression>(expr_node) );
    374         return new UntypedExpr( new NameExpr( opName[ op ] ), args );
    375 }
    376 Expression *build_unary_ptr( OperatorNode::Type op, ExpressionNode *expr_node ) {
     318        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
     319}
     320Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) {
    377321        std::list<Expression *> args;
    378322        args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node) ) );
    379         return new UntypedExpr( new NameExpr( opName[ op ] ), args );
    380 }
    381 Expression *build_binary_val( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
     323        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
     324}
     325Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
    382326        std::list<Expression *> args;
    383327        args.push_back( maybeBuild<Expression>(expr_node1) );
    384328        args.push_back( maybeBuild<Expression>(expr_node2) );
    385         return new UntypedExpr( new NameExpr( opName[ op ] ), args );
    386 }
    387 Expression *build_binary_ptr( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
     329        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
     330}
     331Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
    388332        std::list<Expression *> args;
    389333        args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node1) ) );
    390334        args.push_back( maybeBuild<Expression>(expr_node2) );
    391         return new UntypedExpr( new NameExpr( opName[ op ] ), args );
     335        return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
    392336}
    393337
     
    421365}
    422366
    423 CompositeExprNode2::CompositeExprNode2( Expression *expr ) : expr( expr ) {}
    424 CompositeExprNode2::CompositeExprNode2( const CompositeExprNode2 &other ) : expr( other.expr->clone() ) {}
    425 CompositeExprNode2::~CompositeExprNode2() { delete expr; }
    426 void CompositeExprNode2::print( std::ostream &, int indent ) const { assert( false ); }
    427 void CompositeExprNode2::printOneLine( std::ostream &, int indent ) const { assert( false ); }
    428 
    429 
    430 Expression *CompositeExprNode::build() const {
    431         OperatorNode *op;
    432         std::list<Expression *> args;
    433 
    434         buildList( get_args(), args );
    435 
    436         if ( ! ( op = dynamic_cast<OperatorNode *>( function ) ) ) { // function as opposed to operator
    437                 return new UntypedExpr( maybeBuild<Expression>(function), args, maybeBuild< Expression >( get_argName() ));
    438         } // if
    439 
    440         assert( ((void)"CompositeExprNode::build", false) );
    441         return nullptr;
    442 }
    443 
    444 void CompositeExprNode::printOneLine( std::ostream &os, int indent ) const {
    445         printDesignation( os );
    446         os << "( ";
    447         function->printOneLine( os, indent );
    448         for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
    449                 cur->printOneLine( os, indent );
    450         } // for
    451         os << ") ";
    452 }
    453 
    454 void CompositeExprNode::print( std::ostream &os, int indent ) const {
    455         printDesignation( os );
    456         os << string( indent, ' ' ) << "Application of: " << endl;
    457         function->print( os, indent + ParseNode::indent_by );
    458 
    459         os << string( indent, ' ' ) ;
    460         if ( arguments ) {
    461                 os << "... on arguments: " << endl;
    462                 arguments->printList( os, indent + ParseNode::indent_by );
    463         } else
    464                 os << "... on no arguments: " << endl;
    465 }
    466 
    467 void CompositeExprNode::set_function( ExpressionNode *f ) {
    468         function = f;
    469 }
    470 
    471 void CompositeExprNode::set_args( ExpressionNode *args ) {
    472         arguments = args;
    473 }
    474 
    475 ExpressionNode *CompositeExprNode::get_function( void ) const {
    476         return function;
    477 }
    478 
    479 ExpressionNode *CompositeExprNode::get_args( void ) const {
    480         return arguments;
    481 }
    482 
    483 void CompositeExprNode::add_arg( ExpressionNode *arg ) {
    484         if ( arguments )
    485                 arguments->set_link( arg );
    486         else
    487                 set_args( arg );
     367Expression *build_range( ExpressionNode * low, ExpressionNode *high ) {
     368        Expression *low_cexpr = maybeBuild<Expression>( low );
     369        Expression *high_cexpr = maybeBuild<Expression>( high );
     370        return new RangeExpr( low_cexpr, high_cexpr );
    488371}
    489372
     
    676559}
    677560
    678 ExpressionNode *flattenCommas( ExpressionNode *list ) {
    679         if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( list ) ) {
    680                 OperatorNode *op;
    681                 if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) ) {
    682                         if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
    683                                 composite->add_arg( next );
    684                         return flattenCommas( composite->get_args() );
    685                 } // if
    686         } // if
    687 
    688         if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
    689                 list->set_next( flattenCommas( next ) );
    690 
    691         return list;
    692 }
    693 
    694 ExpressionNode *tupleContents( ExpressionNode *tuple ) {
    695         if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {
    696                 OperatorNode *op = 0;
    697                 if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) )
    698                         return composite->get_args();
    699         } // if
    700         return tuple;
    701 }
    702 
    703561// Local Variables: //
    704562// tab-width: 4 //
  • src/Parser/ParseNode.h

    r71a3593 rd9e2280  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 11:42:50 2016
    13 // Update Count     : 293
     12// Last Modified On : Fri Aug  5 13:40:15 2016
     13// Update Count     : 307
    1414//
    1515
     
    193193};
    194194
    195 class OperatorNode : public ExpressionNode {
    196   public:
    197         enum Type { TupleC, Comma, TupleFieldSel, // n-adic
    198                                 // triadic
    199                                 Cond, NCond,
    200                                 // diadic
    201                                 SizeOf, AlignOf, OffsetOf, Attr, Plus, Minus, Mul, Div, Mod, Or, And,
    202                                 BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
    203                                 Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
    204                                 Index, FieldSel, PFieldSel, Range,
    205                                 // monadic
    206                                 UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
    207                                 Ctor, Dtor,
    208         };
    209 
    210         OperatorNode( Type t );
    211         OperatorNode( const OperatorNode &other );
    212         virtual ~OperatorNode();
    213 
    214         virtual OperatorNode *clone() const { return new OperatorNode( *this ); }
    215 
    216         Type get_type() const;
    217         const char *get_typename() const;
    218 
    219         virtual void print( std::ostream &, int indent = 0) const;
    220         virtual void printOneLine( std::ostream &, int indent = 0) const;
    221 
    222         virtual Expression *build() const { return 0; }
    223   private:
    224         Type type;
     195enum class OperKinds {
     196        // diadic
     197        SizeOf, AlignOf, OffsetOf, Attr, Plus, Minus, Mul, Div, Mod, Or, And,
     198        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq,
     199        Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, ERAssn, OrAssn,
     200        Index, Range,
     201        // monadic
     202        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
     203        Ctor, Dtor,
    225204};
    226205
     
    234213Expression *build_and( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
    235214Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind );
    236 Expression *build_unary_val( OperatorNode::Type op, ExpressionNode *expr_node );
    237 Expression *build_unary_ptr( OperatorNode::Type op, ExpressionNode *expr_node );
    238 Expression *build_binary_val( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
    239 Expression *build_binary_ptr( OperatorNode::Type op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     215Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node );
     216Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node );
     217Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     218Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
    240219Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 );
    241220Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 );
     
    243222Expression *build_tuple( ExpressionNode * expr = 0 );
    244223Expression *build_func( ExpressionNode * function, ExpressionNode * expr );
    245 
    246 class CompositeExprNode2 : public ExpressionNode {
    247   public:
    248         CompositeExprNode2( Expression *expr );
    249         CompositeExprNode2( const CompositeExprNode2 &other );
    250         virtual ~CompositeExprNode2();
    251 
    252         virtual CompositeExprNode2 *clone() const { return new CompositeExprNode2( *this ); }
     224Expression *build_range( ExpressionNode * low, ExpressionNode *high );
     225
     226class CompositeExprNode : public ExpressionNode {
     227  public:
     228        CompositeExprNode( Expression *expr );
     229        CompositeExprNode( const CompositeExprNode &other );
     230        virtual ~CompositeExprNode();
     231
     232        virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
    253233        virtual Expression *build() const { return expr->clone(); }
    254234
     
    257237  private:
    258238        Expression *expr;
    259 };
    260 
    261 class CompositeExprNode : public ExpressionNode {
    262   public:
    263         CompositeExprNode();
    264         CompositeExprNode( const std::string * );
    265         CompositeExprNode( ExpressionNode *f, ExpressionNode *args = 0 );
    266         CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 );
    267         CompositeExprNode( const CompositeExprNode &other );
    268         virtual ~CompositeExprNode();
    269 
    270         virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
    271         virtual Expression *build() const;
    272 
    273         virtual void print( std::ostream &, int indent = 0) const;
    274         virtual void printOneLine( std::ostream &, int indent = 0) const;
    275 
    276         void set_function( ExpressionNode * );
    277         void set_args( ExpressionNode * );
    278 
    279         void add_arg( ExpressionNode * );
    280 
    281         ExpressionNode *get_function() const;
    282         ExpressionNode *get_args() const;
    283   private:
    284         ExpressionNode *function;
    285         ExpressionNode *arguments;
    286239};
    287240
     
    636589void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
    637590
    638 // in ExpressionNode.cc
    639 ExpressionNode *flattenCommas( ExpressionNode *list );
    640 ExpressionNode *tupleContents( ExpressionNode *tuple );
    641 
    642591#endif // PARSENODE_H
    643592
  • src/Parser/parser.cc

    r71a3593 rd9e2280  
    354354        LabelNode *label;
    355355        InitializerNode *in;
    356         OperatorNode::Type op;
     356        OperKinds op;
    357357        bool flag;
    358358
     
    10261026     517,   519,   524,   525,   527,   529,   531,   536,   537,   539,
    10271027     544,   545,   550,   551,   556,   557,   562,   563,   568,   569,
    1028      574,   575,   577,   579,   584,   589,   590,   592,   598,   599,
    1029      603,   604,   605,   606,   607,   608,   609,   610,   611,   612,
    1030      613,   619,   621,   623,   625,   630,   631,   636,   637,   643,
    1031      644,   650,   651,   652,   653,   654,   655,   656,   657,   658,
    1032      667,   674,   676,   686,   687,   692,   694,   700,   702,   706,
    1033      707,   712,   717,   720,   722,   724,   734,   736,   747,   748,
    1034      750,   754,   756,   760,   761,   766,   767,   771,   776,   777,
    1035      781,   783,   789,   790,   794,   796,   798,   800,   806,   807,
    1036      811,   813,   818,   820,   822,   827,   829,   834,   836,   840,
    1037      843,   847,   850,   854,   856,   860,   862,   869,   871,   873,
    1038      882,   884,   886,   888,   890,   895,   897,   899,   901,   906,
    1039      919,   920,   925,   927,   932,   936,   938,   940,   942,   944,
    1040      950,   951,   957,   958,   962,   963,   968,   970,   976,   977,
    1041      979,   984,   986,   993,   995,   999,  1000,  1005,  1007,  1011,
    1042     1012,  1016,  1018,  1022,  1023,  1027,  1028,  1032,  1033,  1048,
    1043     1049,  1050,  1051,  1052,  1056,  1061,  1068,  1078,  1083,  1088,
    1044     1096,  1101,  1106,  1111,  1116,  1124,  1146,  1151,  1158,  1160,
    1045     1167,  1172,  1177,  1188,  1193,  1198,  1203,  1208,  1217,  1222,
    1046     1230,  1231,  1232,  1233,  1239,  1244,  1252,  1253,  1254,  1255,
    1047     1259,  1260,  1261,  1262,  1267,  1268,  1277,  1278,  1283,  1284,
    1048     1289,  1291,  1293,  1295,  1297,  1300,  1299,  1311,  1312,  1314,
    1049     1324,  1325,  1330,  1334,  1336,  1338,  1340,  1342,  1344,  1346,
    1050     1348,  1353,  1355,  1357,  1359,  1361,  1363,  1365,  1367,  1369,
    1051     1371,  1373,  1375,  1377,  1383,  1384,  1386,  1388,  1390,  1395,
    1052     1396,  1402,  1403,  1405,  1407,  1412,  1414,  1416,  1418,  1423,
    1053     1424,  1426,  1428,  1433,  1434,  1436,  1441,  1442,  1444,  1446,
    1054     1451,  1453,  1455,  1460,  1461,  1465,  1467,  1473,  1472,  1476,
    1055     1478,  1483,  1485,  1491,  1492,  1497,  1498,  1500,  1501,  1510,
    1056     1511,  1513,  1515,  1520,  1522,  1528,  1529,  1531,  1534,  1537,
    1057     1542,  1543,  1548,  1553,  1557,  1559,  1565,  1564,  1571,  1573,
    1058     1579,  1580,  1588,  1589,  1593,  1594,  1595,  1597,  1599,  1606,
    1059     1607,  1609,  1611,  1616,  1617,  1623,  1624,  1628,  1629,  1634,
    1060     1635,  1636,  1638,  1646,  1647,  1649,  1652,  1654,  1658,  1659,
    1061     1660,  1662,  1664,  1668,  1673,  1681,  1682,  1691,  1693,  1698,
    1062     1699,  1700,  1704,  1705,  1706,  1710,  1711,  1712,  1716,  1717,
    1063     1718,  1723,  1724,  1725,  1726,  1732,  1733,  1735,  1740,  1741,
    1064     1746,  1747,  1748,  1749,  1750,  1765,  1766,  1771,  1772,  1780,
    1065     1782,  1784,  1787,  1789,  1791,  1814,  1815,  1817,  1819,  1824,
    1066     1825,  1827,  1832,  1837,  1838,  1844,  1843,  1847,  1851,  1853,
    1067     1855,  1861,  1862,  1867,  1872,  1874,  1879,  1881,  1882,  1884,
    1068     1889,  1891,  1893,  1898,  1900,  1905,  1910,  1918,  1924,  1923,
    1069     1937,  1938,  1943,  1944,  1948,  1953,  1958,  1966,  1971,  1982,
    1070     1983,  1994,  1995,  2001,  2002,  2006,  2007,  2008,  2011,  2010,
    1071     2021,  2030,  2036,  2042,  2051,  2057,  2063,  2069,  2075,  2083,
    1072     2089,  2097,  2103,  2112,  2113,  2114,  2118,  2122,  2124,  2129,
    1073     2130,  2134,  2135,  2140,  2146,  2147,  2150,  2152,  2153,  2157,
    1074     2158,  2159,  2160,  2194,  2196,  2197,  2199,  2204,  2209,  2214,
    1075     2216,  2218,  2223,  2225,  2227,  2229,  2234,  2236,  2245,  2247,
    1076     2248,  2253,  2255,  2257,  2262,  2264,  2266,  2271,  2273,  2275,
    1077     2284,  2285,  2286,  2290,  2292,  2294,  2299,  2301,  2303,  2308,
    1078     2310,  2312,  2327,  2329,  2330,  2332,  2337,  2338,  2343,  2345,
    1079     2347,  2352,  2354,  2356,  2358,  2363,  2365,  2367,  2377,  2379,
    1080     2380,  2382,  2387,  2389,  2391,  2396,  2398,  2400,  2402,  2407,
    1081     2409,  2411,  2442,  2444,  2445,  2447,  2452,  2457,  2465,  2467,
    1082     2469,  2474,  2476,  2481,  2483,  2497,  2498,  2500,  2505,  2507,
    1083     2509,  2511,  2513,  2518,  2519,  2521,  2523,  2528,  2530,  2532,
    1084     2538,  2540,  2542,  2546,  2548,  2550,  2552,  2566,  2567,  2569,
    1085     2574,  2576,  2578,  2580,  2582,  2587,  2588,  2590,  2592,  2597,
    1086     2599,  2601,  2607,  2608,  2610,  2619,  2622,  2624,  2627,  2629,
    1087     2631,  2644,  2645,  2647,  2652,  2654,  2656,  2658,  2660,  2665,
    1088     2666,  2668,  2670,  2675,  2677,  2685,  2686,  2687,  2692,  2693,
    1089     2697,  2699,  2701,  2703,  2705,  2707,  2714,  2716,  2718,  2720,
    1090     2722,  2724,  2726,  2728,  2730,  2732,  2737,  2739,  2741,  2746,
    1091     2772,  2773,  2775,  2779,  2780,  2784,  2786,  2788,  2790,  2792,
    1092     2794,  2801,  2803,  2805,  2807,  2809,  2811,  2816,  2821,  2823,
    1093     2825,  2843,  2845,  2850,  2851
     1028     574,   575,   578,   580,   585,   590,   591,   593,   599,   600,
     1029     604,   605,   606,   607,   608,   609,   610,   611,   612,   613,
     1030     614,   620,   622,   624,   626,   631,   632,   637,   638,   644,
     1031     645,   651,   652,   653,   654,   655,   656,   657,   658,   659,
     1032     669,   676,   678,   688,   689,   694,   696,   702,   704,   708,
     1033     709,   714,   719,   722,   724,   726,   736,   738,   749,   750,
     1034     752,   756,   758,   762,   763,   768,   769,   773,   778,   779,
     1035     783,   785,   791,   792,   796,   798,   800,   802,   808,   809,
     1036     813,   815,   820,   822,   824,   829,   831,   836,   838,   842,
     1037     845,   849,   852,   856,   858,   862,   864,   871,   873,   875,
     1038     884,   886,   888,   890,   892,   897,   899,   901,   903,   908,
     1039     921,   922,   927,   929,   934,   938,   940,   942,   944,   946,
     1040     952,   953,   959,   960,   964,   965,   970,   972,   978,   979,
     1041     981,   986,   988,   995,   997,  1001,  1002,  1007,  1009,  1013,
     1042    1014,  1018,  1020,  1024,  1025,  1029,  1030,  1034,  1035,  1050,
     1043    1051,  1052,  1053,  1054,  1058,  1063,  1070,  1080,  1085,  1090,
     1044    1098,  1103,  1108,  1113,  1118,  1126,  1148,  1153,  1160,  1162,
     1045    1169,  1174,  1179,  1190,  1195,  1200,  1205,  1210,  1219,  1224,
     1046    1232,  1233,  1234,  1235,  1241,  1246,  1254,  1255,  1256,  1257,
     1047    1261,  1262,  1263,  1264,  1269,  1270,  1279,  1280,  1285,  1286,
     1048    1291,  1293,  1295,  1297,  1299,  1302,  1301,  1313,  1314,  1316,
     1049    1326,  1327,  1332,  1336,  1338,  1340,  1342,  1344,  1346,  1348,
     1050    1350,  1355,  1357,  1359,  1361,  1363,  1365,  1367,  1369,  1371,
     1051    1373,  1375,  1377,  1379,  1385,  1386,  1388,  1390,  1392,  1397,
     1052    1398,  1404,  1405,  1407,  1409,  1414,  1416,  1418,  1420,  1425,
     1053    1426,  1428,  1430,  1435,  1436,  1438,  1443,  1444,  1446,  1448,
     1054    1453,  1455,  1457,  1462,  1463,  1467,  1469,  1475,  1474,  1478,
     1055    1480,  1485,  1487,  1493,  1494,  1499,  1500,  1502,  1503,  1512,
     1056    1513,  1515,  1517,  1522,  1524,  1530,  1531,  1533,  1536,  1539,
     1057    1544,  1545,  1550,  1555,  1559,  1561,  1567,  1566,  1573,  1575,
     1058    1581,  1582,  1590,  1591,  1595,  1596,  1597,  1599,  1601,  1608,
     1059    1609,  1611,  1613,  1618,  1619,  1625,  1626,  1630,  1631,  1636,
     1060    1637,  1638,  1640,  1648,  1649,  1651,  1654,  1656,  1660,  1661,
     1061    1662,  1664,  1666,  1670,  1675,  1683,  1684,  1693,  1695,  1700,
     1062    1701,  1702,  1706,  1707,  1708,  1712,  1713,  1714,  1718,  1719,
     1063    1720,  1725,  1726,  1727,  1728,  1734,  1735,  1737,  1742,  1743,
     1064    1748,  1749,  1750,  1751,  1752,  1767,  1768,  1773,  1774,  1782,
     1065    1784,  1786,  1789,  1791,  1793,  1816,  1817,  1819,  1821,  1826,
     1066    1827,  1829,  1834,  1839,  1840,  1846,  1845,  1849,  1853,  1855,
     1067    1857,  1863,  1864,  1869,  1874,  1876,  1881,  1883,  1884,  1886,
     1068    1891,  1893,  1895,  1900,  1902,  1907,  1912,  1920,  1926,  1925,
     1069    1939,  1940,  1945,  1946,  1950,  1955,  1960,  1968,  1973,  1984,
     1070    1985,  1996,  1997,  2003,  2004,  2008,  2009,  2010,  2013,  2012,
     1071    2023,  2032,  2038,  2044,  2053,  2059,  2065,  2071,  2077,  2085,
     1072    2091,  2099,  2105,  2114,  2115,  2116,  2120,  2124,  2126,  2131,
     1073    2132,  2136,  2137,  2142,  2148,  2149,  2152,  2154,  2155,  2159,
     1074    2160,  2161,  2162,  2196,  2198,  2199,  2201,  2206,  2211,  2216,
     1075    2218,  2220,  2225,  2227,  2229,  2231,  2236,  2238,  2247,  2249,
     1076    2250,  2255,  2257,  2259,  2264,  2266,  2268,  2273,  2275,  2277,
     1077    2286,  2287,  2288,  2292,  2294,  2296,  2301,  2303,  2305,  2310,
     1078    2312,  2314,  2329,  2331,  2332,  2334,  2339,  2340,  2345,  2347,
     1079    2349,  2354,  2356,  2358,  2360,  2365,  2367,  2369,  2379,  2381,
     1080    2382,  2384,  2389,  2391,  2393,  2398,  2400,  2402,  2404,  2409,
     1081    2411,  2413,  2444,  2446,  2447,  2449,  2454,  2459,  2467,  2469,
     1082    2471,  2476,  2478,  2483,  2485,  2499,  2500,  2502,  2507,  2509,
     1083    2511,  2513,  2515,  2520,  2521,  2523,  2525,  2530,  2532,  2534,
     1084    2540,  2542,  2544,  2548,  2550,  2552,  2554,  2568,  2569,  2571,
     1085    2576,  2578,  2580,  2582,  2584,  2589,  2590,  2592,  2594,  2599,
     1086    2601,  2603,  2609,  2610,  2612,  2621,  2624,  2626,  2629,  2631,
     1087    2633,  2646,  2647,  2649,  2654,  2656,  2658,  2660,  2662,  2667,
     1088    2668,  2670,  2672,  2677,  2679,  2687,  2688,  2689,  2694,  2695,
     1089    2699,  2701,  2703,  2705,  2707,  2709,  2716,  2718,  2720,  2722,
     1090    2724,  2726,  2728,  2730,  2732,  2734,  2739,  2741,  2743,  2748,
     1091    2774,  2775,  2777,  2781,  2782,  2786,  2788,  2790,  2792,  2794,
     1092    2796,  2803,  2805,  2807,  2809,  2811,  2813,  2818,  2823,  2825,
     1093    2827,  2845,  2847,  2852,  2853
    10941094};
    10951095#endif
     
    50745074/* Line 1806 of yacc.c  */
    50755075#line 357 "parser.yy"
    5076     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
     5076    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
    50775077    break;
    50785078
     
    50815081/* Line 1806 of yacc.c  */
    50825082#line 359 "parser.yy"
    5083     { (yyval.en) = new CompositeExprNode2( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
     5083    { (yyval.en) = new CompositeExprNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
    50845084    break;
    50855085
     
    50885088/* Line 1806 of yacc.c  */
    50895089#line 363 "parser.yy"
    5090     { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
     5090    { (yyval.en) = new CompositeExprNode( build_fieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
    50915091    break;
    50925092
     
    50955095/* Line 1806 of yacc.c  */
    50965096#line 366 "parser.yy"
    5097     { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
     5097    { (yyval.en) = new CompositeExprNode( build_pfieldSel( (yyvsp[(1) - (3)].en), new VarRefNode( (yyvsp[(3) - (3)].tok) ) ) ); }
    50985098    break;
    50995099
     
    51025102/* Line 1806 of yacc.c  */
    51035103#line 369 "parser.yy"
    5104     { (yyval.en) = new CompositeExprNode2( build_unary_ptr( OperatorNode::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
     5104    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
    51055105    break;
    51065106
     
    51095109/* Line 1806 of yacc.c  */
    51105110#line 371 "parser.yy"
    5111     { (yyval.en) = new CompositeExprNode2( build_unary_ptr( OperatorNode::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
     5111    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
    51125112    break;
    51135113
     
    51265126                        Token fn;
    51275127                        fn.str = new std::string( "?{}" ); // location undefined
    5128                         (yyval.en) = new CompositeExprNode2( build_func( new VarRefNode( fn ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_link( (yyvsp[(3) - (4)].en) ) ) );
     5128                        (yyval.en) = new CompositeExprNode( build_func( new VarRefNode( fn ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_link( (yyvsp[(3) - (4)].en) ) ) );
    51295129                }
    51305130    break;
     
    51625162/* Line 1806 of yacc.c  */
    51635163#line 400 "parser.yy"
    5164     { (yyval.en) = (yyvsp[(9) - (9)].en)->set_argName( new CompositeExprNode2( build_tuple( (ExpressionNode *)(yyvsp[(3) - (9)].en)->set_link( (yyvsp[(5) - (9)].en) ) ) ) ); }
     5164    { (yyval.en) = (yyvsp[(9) - (9)].en)->set_argName( new CompositeExprNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (9)].en)->set_link( (yyvsp[(5) - (9)].en) ) ) ) ); }
    51655165    break;
    51665166
     
    51835183/* Line 1806 of yacc.c  */
    51845184#line 414 "parser.yy"
    5185     { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
     5185    { (yyval.en) = new CompositeExprNode( build_fieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
    51865186    break;
    51875187
     
    51905190/* Line 1806 of yacc.c  */
    51915191#line 416 "parser.yy"
    5192     { (yyval.en) = new CompositeExprNode2( build_fieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
     5192    { (yyval.en) = new CompositeExprNode( build_fieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
    51935193    break;
    51945194
     
    51975197/* Line 1806 of yacc.c  */
    51985198#line 418 "parser.yy"
    5199     { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
     5199    { (yyval.en) = new CompositeExprNode( build_pfieldSel( (yyvsp[(3) - (3)].en), new VarRefNode( (yyvsp[(1) - (3)].tok) ) ) ); }
    52005200    break;
    52015201
     
    52045204/* Line 1806 of yacc.c  */
    52055205#line 420 "parser.yy"
    5206     { (yyval.en) = new CompositeExprNode2( build_pfieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
     5206    { (yyval.en) = new CompositeExprNode( build_pfieldSel( (yyvsp[(5) - (7)].en), new VarRefNode( (yyvsp[(1) - (7)].tok) ) ) ); }
    52075207    break;
    52085208
     
    52345234    {
    52355235                        switch ( (yyvsp[(1) - (2)].op) ) {
    5236                           case OperatorNode::AddressOf:
    5237                                 (yyval.en) = new CompositeExprNode2( build_addressOf( (yyvsp[(2) - (2)].en) ) );
     5236                          case OperKinds::AddressOf:
     5237                                (yyval.en) = new CompositeExprNode( build_addressOf( (yyvsp[(2) - (2)].en) ) );
    52385238                                break;
    5239                           case OperatorNode::PointTo:
    5240                                 (yyval.en) = new CompositeExprNode2( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) );
     5239                          case OperKinds::PointTo:
     5240                                (yyval.en) = new CompositeExprNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) );
    52415241                                break;
    52425242                          default:
     
    52505250/* Line 1806 of yacc.c  */
    52515251#line 450 "parser.yy"
    5252     { (yyval.en) = new CompositeExprNode2( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
     5252    { (yyval.en) = new CompositeExprNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
    52535253    break;
    52545254
     
    52575257/* Line 1806 of yacc.c  */
    52585258#line 452 "parser.yy"
    5259     { (yyval.en) = new CompositeExprNode2( build_unary_ptr( OperatorNode::Incr, (yyvsp[(2) - (2)].en) ) ); }
     5259    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
    52605260    break;
    52615261
     
    52645264/* Line 1806 of yacc.c  */
    52655265#line 454 "parser.yy"
    5266     { (yyval.en) = new CompositeExprNode2( build_unary_ptr( OperatorNode::Decr, (yyvsp[(2) - (2)].en) ) ); }
     5266    { (yyval.en) = new CompositeExprNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
    52675267    break;
    52685268
     
    52715271/* Line 1806 of yacc.c  */
    52725272#line 456 "parser.yy"
    5273     { (yyval.en) = new CompositeExprNode2( build_sizeOf( (yyvsp[(2) - (2)].en) ) ); }
     5273    { (yyval.en) = new CompositeExprNode( build_sizeOf( (yyvsp[(2) - (2)].en) ) ); }
    52745274    break;
    52755275
     
    52785278/* Line 1806 of yacc.c  */
    52795279#line 458 "parser.yy"
    5280     { (yyval.en) = new CompositeExprNode2( build_sizeOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
     5280    { (yyval.en) = new CompositeExprNode( build_sizeOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    52815281    break;
    52825282
     
    52855285/* Line 1806 of yacc.c  */
    52865286#line 460 "parser.yy"
    5287     { (yyval.en) = new CompositeExprNode2( build_offsetOf( new TypeValueNode( (yyvsp[(3) - (6)].decl) ), new VarRefNode( (yyvsp[(5) - (6)].tok) ) ) ); }
     5287    { (yyval.en) = new CompositeExprNode( build_offsetOf( new TypeValueNode( (yyvsp[(3) - (6)].decl) ), new VarRefNode( (yyvsp[(5) - (6)].tok) ) ) ); }
    52885288    break;
    52895289
     
    52925292/* Line 1806 of yacc.c  */
    52935293#line 462 "parser.yy"
    5294     { (yyval.en) = new CompositeExprNode2( build_attr( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ) ); }
     5294    { (yyval.en) = new CompositeExprNode( build_attr( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ) ); }
    52955295    break;
    52965296
     
    52995299/* Line 1806 of yacc.c  */
    53005300#line 464 "parser.yy"
    5301     { (yyval.en) = new CompositeExprNode2( build_attr( new VarRefNode( (yyvsp[(1) - (4)].tok) ), new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
     5301    { (yyval.en) = new CompositeExprNode( build_attr( new VarRefNode( (yyvsp[(1) - (4)].tok) ), new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    53025302    break;
    53035303
     
    53065306/* Line 1806 of yacc.c  */
    53075307#line 466 "parser.yy"
    5308     { (yyval.en) = new CompositeExprNode2( build_attr( new VarRefNode( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
     5308    { (yyval.en) = new CompositeExprNode( build_attr( new VarRefNode( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
    53095309    break;
    53105310
     
    53135313/* Line 1806 of yacc.c  */
    53145314#line 468 "parser.yy"
    5315     { (yyval.en) = new CompositeExprNode2( build_alignOf( (yyvsp[(2) - (2)].en) ) ); }
     5315    { (yyval.en) = new CompositeExprNode( build_alignOf( (yyvsp[(2) - (2)].en) ) ); }
    53165316    break;
    53175317
     
    53205320/* Line 1806 of yacc.c  */
    53215321#line 470 "parser.yy"
    5322     { (yyval.en) = new CompositeExprNode2( build_alignOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
     5322    { (yyval.en) = new CompositeExprNode( build_alignOf( new TypeValueNode( (yyvsp[(3) - (4)].decl) ) ) ); }
    53235323    break;
    53245324
     
    53275327/* Line 1806 of yacc.c  */
    53285328#line 476 "parser.yy"
    5329     { (yyval.op) = OperatorNode::PointTo; }
     5329    { (yyval.op) = OperKinds::PointTo; }
    53305330    break;
    53315331
     
    53345334/* Line 1806 of yacc.c  */
    53355335#line 477 "parser.yy"
    5336     { (yyval.op) = OperatorNode::AddressOf; }
     5336    { (yyval.op) = OperKinds::AddressOf; }
    53375337    break;
    53385338
     
    53415341/* Line 1806 of yacc.c  */
    53425342#line 483 "parser.yy"
    5343     { (yyval.op) = OperatorNode::UnPlus; }
     5343    { (yyval.op) = OperKinds::UnPlus; }
    53445344    break;
    53455345
     
    53485348/* Line 1806 of yacc.c  */
    53495349#line 484 "parser.yy"
    5350     { (yyval.op) = OperatorNode::UnMinus; }
     5350    { (yyval.op) = OperKinds::UnMinus; }
    53515351    break;
    53525352
     
    53555355/* Line 1806 of yacc.c  */
    53565356#line 485 "parser.yy"
    5357     { (yyval.op) = OperatorNode::Neg; }
     5357    { (yyval.op) = OperKinds::Neg; }
    53585358    break;
    53595359
     
    53625362/* Line 1806 of yacc.c  */
    53635363#line 486 "parser.yy"
    5364     { (yyval.op) = OperatorNode::BitNeg; }
     5364    { (yyval.op) = OperKinds::BitNeg; }
    53655365    break;
    53665366
     
    53695369/* Line 1806 of yacc.c  */
    53705370#line 492 "parser.yy"
    5371     { (yyval.en) = new CompositeExprNode2( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
     5371    { (yyval.en) = new CompositeExprNode( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
    53725372    break;
    53735373
     
    53765376/* Line 1806 of yacc.c  */
    53775377#line 494 "parser.yy"
    5378     { (yyval.en) = new CompositeExprNode2( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
     5378    { (yyval.en) = new CompositeExprNode( build_cast( new TypeValueNode( (yyvsp[(2) - (4)].decl) ), (yyvsp[(4) - (4)].en) ) ); }
    53795379    break;
    53805380
     
    53835383/* Line 1806 of yacc.c  */
    53845384#line 500 "parser.yy"
    5385     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5385    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53865386    break;
    53875387
     
    53905390/* Line 1806 of yacc.c  */
    53915391#line 502 "parser.yy"
    5392     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5392    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53935393    break;
    53945394
     
    53975397/* Line 1806 of yacc.c  */
    53985398#line 504 "parser.yy"
    5399     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5399    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54005400    break;
    54015401
     
    54045404/* Line 1806 of yacc.c  */
    54055405#line 510 "parser.yy"
    5406     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5406    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54075407    break;
    54085408
     
    54115411/* Line 1806 of yacc.c  */
    54125412#line 512 "parser.yy"
    5413     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5413    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54145414    break;
    54155415
     
    54185418/* Line 1806 of yacc.c  */
    54195419#line 518 "parser.yy"
    5420     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5420    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54215421    break;
    54225422
     
    54255425/* Line 1806 of yacc.c  */
    54265426#line 520 "parser.yy"
    5427     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5427    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54285428    break;
    54295429
     
    54325432/* Line 1806 of yacc.c  */
    54335433#line 526 "parser.yy"
    5434     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5434    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54355435    break;
    54365436
     
    54395439/* Line 1806 of yacc.c  */
    54405440#line 528 "parser.yy"
    5441     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5441    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54425442    break;
    54435443
     
    54465446/* Line 1806 of yacc.c  */
    54475447#line 530 "parser.yy"
    5448     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5448    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54495449    break;
    54505450
     
    54535453/* Line 1806 of yacc.c  */
    54545454#line 532 "parser.yy"
    5455     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5455    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54565456    break;
    54575457
     
    54605460/* Line 1806 of yacc.c  */
    54615461#line 538 "parser.yy"
    5462     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5462    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54635463    break;
    54645464
     
    54675467/* Line 1806 of yacc.c  */
    54685468#line 540 "parser.yy"
    5469     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5469    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54705470    break;
    54715471
     
    54745474/* Line 1806 of yacc.c  */
    54755475#line 546 "parser.yy"
    5476     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5476    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54775477    break;
    54785478
     
    54815481/* Line 1806 of yacc.c  */
    54825482#line 552 "parser.yy"
    5483     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5483    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54845484    break;
    54855485
     
    54885488/* Line 1806 of yacc.c  */
    54895489#line 558 "parser.yy"
    5490     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5490    { (yyval.en) = new CompositeExprNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54915491    break;
    54925492
     
    54955495/* Line 1806 of yacc.c  */
    54965496#line 564 "parser.yy"
    5497     { (yyval.en) = new CompositeExprNode2( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
     5497    { (yyval.en) = new CompositeExprNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
    54985498    break;
    54995499
     
    55025502/* Line 1806 of yacc.c  */
    55035503#line 570 "parser.yy"
    5504     { (yyval.en) = new CompositeExprNode2( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
     5504    { (yyval.en) = new CompositeExprNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
    55055505    break;
    55065506
     
    55095509/* Line 1806 of yacc.c  */
    55105510#line 576 "parser.yy"
    5511     { (yyval.en) = new CompositeExprNode2( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     5511    { (yyval.en) = new CompositeExprNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    55125512    break;
    55135513
     
    55155515
    55165516/* Line 1806 of yacc.c  */
    5517 #line 578 "parser.yy"
    5518     { (yyval.en) = new CompositeExprNode2( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
     5517#line 579 "parser.yy"
     5518    { (yyval.en) = new CompositeExprNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
    55195519    break;
    55205520
     
    55225522
    55235523/* Line 1806 of yacc.c  */
    5524 #line 580 "parser.yy"
    5525     { (yyval.en) = new CompositeExprNode2( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     5524#line 581 "parser.yy"
     5525    { (yyval.en) = new CompositeExprNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    55265526    break;
    55275527
     
    55295529
    55305530/* Line 1806 of yacc.c  */
    5531 #line 591 "parser.yy"
    5532     { (yyval.en) = new CompositeExprNode2( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5531#line 592 "parser.yy"
     5532    { (yyval.en) = new CompositeExprNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    55335533    break;
    55345534
     
    55365536
    55375537/* Line 1806 of yacc.c  */
    5538 #line 593 "parser.yy"
    5539     { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new CompositeExprNode2( build_binary_ptr( OperatorNode::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
     5538#line 594 "parser.yy"
     5539    { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new CompositeExprNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
    55405540    break;
    55415541
     
    55435543
    55445544/* Line 1806 of yacc.c  */
    5545 #line 598 "parser.yy"
     5545#line 599 "parser.yy"
    55465546    { (yyval.en) = new NullExprNode; }
    55475547    break;
     
    55505550
    55515551/* Line 1806 of yacc.c  */
    5552 #line 603 "parser.yy"
    5553     { (yyval.op) = OperatorNode::Assign; }
     5552#line 604 "parser.yy"
     5553    { (yyval.op) = OperKinds::Assign; }
    55545554    break;
    55555555
     
    55575557
    55585558/* Line 1806 of yacc.c  */
    5559 #line 604 "parser.yy"
    5560     { (yyval.op) = OperatorNode::MulAssn; }
     5559#line 605 "parser.yy"
     5560    { (yyval.op) = OperKinds::MulAssn; }
    55615561    break;
    55625562
     
    55645564
    55655565/* Line 1806 of yacc.c  */
    5566 #line 605 "parser.yy"
    5567     { (yyval.op) = OperatorNode::DivAssn; }
     5566#line 606 "parser.yy"
     5567    { (yyval.op) = OperKinds::DivAssn; }
    55685568    break;
    55695569
     
    55715571
    55725572/* Line 1806 of yacc.c  */
    5573 #line 606 "parser.yy"
    5574     { (yyval.op) = OperatorNode::ModAssn; }
     5573#line 607 "parser.yy"
     5574    { (yyval.op) = OperKinds::ModAssn; }
    55755575    break;
    55765576
     
    55785578
    55795579/* Line 1806 of yacc.c  */
    5580 #line 607 "parser.yy"
    5581     { (yyval.op) = OperatorNode::PlusAssn; }
     5580#line 608 "parser.yy"
     5581    { (yyval.op) = OperKinds::PlusAssn; }
    55825582    break;
    55835583
     
    55855585
    55865586/* Line 1806 of yacc.c  */
    5587 #line 608 "parser.yy"
    5588     { (yyval.op) = OperatorNode::MinusAssn; }
     5587#line 609 "parser.yy"
     5588    { (yyval.op) = OperKinds::MinusAssn; }
    55895589    break;
    55905590
     
    55925592
    55935593/* Line 1806 of yacc.c  */
    5594 #line 609 "parser.yy"
    5595     { (yyval.op) = OperatorNode::LSAssn; }
     5594#line 610 "parser.yy"
     5595    { (yyval.op) = OperKinds::LSAssn; }
    55965596    break;
    55975597
     
    55995599
    56005600/* Line 1806 of yacc.c  */
    5601 #line 610 "parser.yy"
    5602     { (yyval.op) = OperatorNode::RSAssn; }
     5601#line 611 "parser.yy"
     5602    { (yyval.op) = OperKinds::RSAssn; }
    56035603    break;
    56045604
     
    56065606
    56075607/* Line 1806 of yacc.c  */
    5608 #line 611 "parser.yy"
    5609     { (yyval.op) = OperatorNode::AndAssn; }
     5608#line 612 "parser.yy"
     5609    { (yyval.op) = OperKinds::AndAssn; }
    56105610    break;
    56115611
     
    56135613
    56145614/* Line 1806 of yacc.c  */
    5615 #line 612 "parser.yy"
    5616     { (yyval.op) = OperatorNode::ERAssn; }
     5615#line 613 "parser.yy"
     5616    { (yyval.op) = OperKinds::ERAssn; }
    56175617    break;
    56185618
     
    56205620
    56215621/* Line 1806 of yacc.c  */
    5622 #line 613 "parser.yy"
    5623     { (yyval.op) = OperatorNode::OrAssn; }
     5622#line 614 "parser.yy"
     5623    { (yyval.op) = OperKinds::OrAssn; }
    56245624    break;
    56255625
     
    56275627
    56285628/* Line 1806 of yacc.c  */
    5629 #line 620 "parser.yy"
    5630     { (yyval.en) = new CompositeExprNode2( build_tuple() ); }
     5629#line 621 "parser.yy"
     5630    { (yyval.en) = new CompositeExprNode( build_tuple() ); }
    56315631    break;
    56325632
     
    56345634
    56355635/* Line 1806 of yacc.c  */
    5636 #line 622 "parser.yy"
    5637     { (yyval.en) = new CompositeExprNode2( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
     5636#line 623 "parser.yy"
     5637    { (yyval.en) = new CompositeExprNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
    56385638    break;
    56395639
     
    56415641
    56425642/* Line 1806 of yacc.c  */
    5643 #line 624 "parser.yy"
    5644     { (yyval.en) = new CompositeExprNode2( build_tuple( (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ) ); }
     5643#line 625 "parser.yy"
     5644    { (yyval.en) = new CompositeExprNode( build_tuple( (ExpressionNode *)(new NullExprNode)->set_link( (yyvsp[(4) - (6)].en) ) ) ); }
    56455645    break;
    56465646
     
    56485648
    56495649/* Line 1806 of yacc.c  */
    5650 #line 626 "parser.yy"
    5651     { (yyval.en) = new CompositeExprNode2( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( (yyvsp[(5) - (7)].en) ) ) ); }
     5650#line 627 "parser.yy"
     5651    { (yyval.en) = new CompositeExprNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( (yyvsp[(5) - (7)].en) ) ) ); }
    56525652    break;
    56535653
     
    56555655
    56565656/* Line 1806 of yacc.c  */
    5657 #line 632 "parser.yy"
     5657#line 633 "parser.yy"
    56585658    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    56595659    break;
     
    56625662
    56635663/* Line 1806 of yacc.c  */
    5664 #line 638 "parser.yy"
    5665     { (yyval.en) = new CompositeExprNode2( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5664#line 639 "parser.yy"
     5665    { (yyval.en) = new CompositeExprNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56665666    break;
    56675667
     
    56695669
    56705670/* Line 1806 of yacc.c  */
    5671 #line 643 "parser.yy"
     5671#line 644 "parser.yy"
    56725672    { (yyval.en) = 0; }
    56735673    break;
     
    56765676
    56775677/* Line 1806 of yacc.c  */
    5678 #line 652 "parser.yy"
     5678#line 653 "parser.yy"
    56795679    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    56805680    break;
     
    56835683
    56845684/* Line 1806 of yacc.c  */
    5685 #line 659 "parser.yy"
     5685#line 660 "parser.yy"
    56865686    {
    5687                         Token fn; fn.str = new std::string( "^?{}" ); // location undefined
    5688                         (yyval.sn) = new StatementNode( StatementNode::Exp, new CompositeExprNode2( build_func( new VarRefNode( fn ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_link( (yyvsp[(4) - (6)].en) ) ) ), 0 );
     5687                        Token fn;
     5688                        fn.str = new std::string( "^?{}" ); // location undefined
     5689                        (yyval.sn) = new StatementNode( StatementNode::Exp, new CompositeExprNode( build_func( new VarRefNode( fn ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_link( (yyvsp[(4) - (6)].en) ) ) ), 0 );
    56895690                }
    56905691    break;
     
    56935694
    56945695/* Line 1806 of yacc.c  */
    5695 #line 668 "parser.yy"
     5696#line 670 "parser.yy"
    56965697    {
    56975698                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
     
    57025703
    57035704/* Line 1806 of yacc.c  */
    5704 #line 675 "parser.yy"
     5705#line 677 "parser.yy"
    57055706    { (yyval.sn) = new CompoundStmtNode( (StatementNode *)0 ); }
    57065707    break;
     
    57095710
    57105711/* Line 1806 of yacc.c  */
    5711 #line 682 "parser.yy"
     5712#line 684 "parser.yy"
    57125713    { (yyval.sn) = new CompoundStmtNode( (yyvsp[(5) - (7)].sn) ); }
    57135714    break;
     
    57165717
    57175718/* Line 1806 of yacc.c  */
    5718 #line 688 "parser.yy"
     5719#line 690 "parser.yy"
    57195720    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    57205721    break;
     
    57235724
    57245725/* Line 1806 of yacc.c  */
    5725 #line 693 "parser.yy"
     5726#line 695 "parser.yy"
    57265727    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57275728    break;
     
    57305731
    57315732/* Line 1806 of yacc.c  */
    5732 #line 695 "parser.yy"
     5733#line 697 "parser.yy"
    57335734    {   // mark all fields in list
    57345735                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    57415742
    57425743/* Line 1806 of yacc.c  */
    5743 #line 701 "parser.yy"
     5744#line 703 "parser.yy"
    57445745    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57455746    break;
     
    57485749
    57495750/* Line 1806 of yacc.c  */
    5750 #line 708 "parser.yy"
     5751#line 710 "parser.yy"
    57515752    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    57525753    break;
     
    57555756
    57565757/* Line 1806 of yacc.c  */
    5757 #line 713 "parser.yy"
     5758#line 715 "parser.yy"
    57585759    { (yyval.sn) = new StatementNode( StatementNode::Exp, (yyvsp[(1) - (2)].en), 0 ); }
    57595760    break;
     
    57625763
    57635764/* Line 1806 of yacc.c  */
    5764 #line 719 "parser.yy"
     5765#line 721 "parser.yy"
    57655766    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    57665767    break;
     
    57695770
    57705771/* Line 1806 of yacc.c  */
    5771 #line 721 "parser.yy"
     5772#line 723 "parser.yy"
    57725773    { (yyval.sn) = new StatementNode( StatementNode::If, (yyvsp[(3) - (7)].en), (StatementNode *)mkList((*(yyvsp[(5) - (7)].sn), *(yyvsp[(7) - (7)].sn) )) ); }
    57735774    break;
     
    57765777
    57775778/* Line 1806 of yacc.c  */
    5778 #line 723 "parser.yy"
     5779#line 725 "parser.yy"
    57795780    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    57805781    break;
     
    57835784
    57845785/* Line 1806 of yacc.c  */
    5785 #line 725 "parser.yy"
     5786#line 727 "parser.yy"
    57865787    {
    57875788                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     
    57985799
    57995800/* Line 1806 of yacc.c  */
    5800 #line 735 "parser.yy"
     5801#line 737 "parser.yy"
    58015802    { (yyval.sn) = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    58025803    break;
     
    58055806
    58065807/* Line 1806 of yacc.c  */
    5807 #line 737 "parser.yy"
     5808#line 739 "parser.yy"
    58085809    {
    58095810                        StatementNode *sw = new StatementNode( StatementNode::Switch, (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) );
     
    58155816
    58165817/* Line 1806 of yacc.c  */
    5817 #line 747 "parser.yy"
     5818#line 749 "parser.yy"
    58185819    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    58195820    break;
     
    58225823
    58235824/* Line 1806 of yacc.c  */
    5824 #line 749 "parser.yy"
    5825     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Range, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5825#line 751 "parser.yy"
     5826    { (yyval.en) = new CompositeExprNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    58265827    break;
    58275828
     
    58295830
    58305831/* Line 1806 of yacc.c  */
    5831 #line 754 "parser.yy"
     5832#line 756 "parser.yy"
    58325833    { (yyval.sn) = new StatementNode( StatementNode::Case, (yyvsp[(1) - (1)].en), 0 ); }
    58335834    break;
     
    58365837
    58375838/* Line 1806 of yacc.c  */
    5838 #line 756 "parser.yy"
     5839#line 758 "parser.yy"
    58395840    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode( StatementNode::Case, (yyvsp[(3) - (3)].en), 0 ) ) ); }
    58405841    break;
     
    58435844
    58445845/* Line 1806 of yacc.c  */
    5845 #line 760 "parser.yy"
     5846#line 762 "parser.yy"
    58465847    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    58475848    break;
     
    58505851
    58515852/* Line 1806 of yacc.c  */
    5852 #line 761 "parser.yy"
     5853#line 763 "parser.yy"
    58535854    { (yyval.sn) = new StatementNode( StatementNode::Default ); }
    58545855    break;
     
    58575858
    58585859/* Line 1806 of yacc.c  */
    5859 #line 767 "parser.yy"
     5860#line 769 "parser.yy"
    58605861    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
    58615862    break;
     
    58645865
    58655866/* Line 1806 of yacc.c  */
    5866 #line 771 "parser.yy"
     5867#line 773 "parser.yy"
    58675868    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    58685869    break;
     
    58715872
    58725873/* Line 1806 of yacc.c  */
    5873 #line 776 "parser.yy"
     5874#line 778 "parser.yy"
    58745875    { (yyval.sn) = 0; }
    58755876    break;
     
    58785879
    58795880/* Line 1806 of yacc.c  */
    5880 #line 782 "parser.yy"
     5881#line 784 "parser.yy"
    58815882    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    58825883    break;
     
    58855886
    58865887/* Line 1806 of yacc.c  */
    5887 #line 784 "parser.yy"
     5888#line 786 "parser.yy"
    58885889    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    58895890    break;
     
    58925893
    58935894/* Line 1806 of yacc.c  */
    5894 #line 789 "parser.yy"
     5895#line 791 "parser.yy"
    58955896    { (yyval.sn) = 0; }
    58965897    break;
     
    58995900
    59005901/* Line 1806 of yacc.c  */
    5901 #line 795 "parser.yy"
     5902#line 797 "parser.yy"
    59025903    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    59035904    break;
     
    59065907
    59075908/* Line 1806 of yacc.c  */
    5908 #line 797 "parser.yy"
     5909#line 799 "parser.yy"
    59095910    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
    59105911    break;
     
    59135914
    59145915/* Line 1806 of yacc.c  */
    5915 #line 799 "parser.yy"
     5916#line 801 "parser.yy"
    59165917    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    59175918    break;
     
    59205921
    59215922/* Line 1806 of yacc.c  */
    5922 #line 801 "parser.yy"
     5923#line 803 "parser.yy"
    59235924    { (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) ) ) ) ) ) ); }
    59245925    break;
     
    59275928
    59285929/* Line 1806 of yacc.c  */
    5929 #line 806 "parser.yy"
     5930#line 808 "parser.yy"
    59305931    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    59315932    break;
    59325933
    59335934  case 180:
    5934 
    5935 /* Line 1806 of yacc.c  */
    5936 #line 812 "parser.yy"
    5937     { (yyval.sn) = 0; }
    5938     break;
    5939 
    5940   case 181:
    59415935
    59425936/* Line 1806 of yacc.c  */
     
    59455939    break;
    59465940
     5941  case 181:
     5942
     5943/* Line 1806 of yacc.c  */
     5944#line 816 "parser.yy"
     5945    { (yyval.sn) = 0; }
     5946    break;
     5947
    59475948  case 182:
    59485949
    59495950/* Line 1806 of yacc.c  */
    5950 #line 819 "parser.yy"
     5951#line 821 "parser.yy"
    59515952    { (yyval.sn) = new StatementNode( StatementNode::While, (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ); }
    59525953    break;
     
    59555956
    59565957/* Line 1806 of yacc.c  */
    5957 #line 821 "parser.yy"
     5958#line 823 "parser.yy"
    59585959    { (yyval.sn) = new StatementNode( StatementNode::Do, (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ); }
    59595960    break;
     
    59625963
    59635964/* Line 1806 of yacc.c  */
    5964 #line 823 "parser.yy"
     5965#line 825 "parser.yy"
    59655966    { (yyval.sn) = new StatementNode( StatementNode::For, (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].sn) ); }
    59665967    break;
     
    59695970
    59705971/* Line 1806 of yacc.c  */
    5971 #line 828 "parser.yy"
     5972#line 830 "parser.yy"
    59725973    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    59735974    break;
     
    59765977
    59775978/* Line 1806 of yacc.c  */
    5978 #line 830 "parser.yy"
     5979#line 832 "parser.yy"
    59795980    { (yyval.en) = new ForCtlExprNode( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    59805981    break;
     
    59835984
    59845985/* Line 1806 of yacc.c  */
    5985 #line 835 "parser.yy"
     5986#line 837 "parser.yy"
    59865987    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(2) - (3)].tok) ); }
    59875988    break;
     
    59905991
    59915992/* Line 1806 of yacc.c  */
    5992 #line 839 "parser.yy"
     5993#line 841 "parser.yy"
    59935994    { (yyval.sn) = new StatementNode( StatementNode::Goto, (yyvsp[(3) - (4)].en) ); }
    59945995    break;
     
    59975998
    59985999/* Line 1806 of yacc.c  */
    5999 #line 842 "parser.yy"
     6000#line 844 "parser.yy"
    60006001    { (yyval.sn) = new StatementNode( StatementNode::Continue ); }
    60016002    break;
     
    60046005
    60056006/* Line 1806 of yacc.c  */
    6006 #line 846 "parser.yy"
     6007#line 848 "parser.yy"
    60076008    { (yyval.sn) = new StatementNode( StatementNode::Continue, (yyvsp[(2) - (3)].tok) ); }
    60086009    break;
     
    60116012
    60126013/* Line 1806 of yacc.c  */
    6013 #line 849 "parser.yy"
     6014#line 851 "parser.yy"
    60146015    { (yyval.sn) = new StatementNode( StatementNode::Break ); }
    60156016    break;
     
    60186019
    60196020/* Line 1806 of yacc.c  */
    6020 #line 853 "parser.yy"
     6021#line 855 "parser.yy"
    60216022    { (yyval.sn) = new StatementNode( StatementNode::Break, (yyvsp[(2) - (3)].tok) ); }
    60226023    break;
     
    60256026
    60266027/* Line 1806 of yacc.c  */
    6027 #line 855 "parser.yy"
     6028#line 857 "parser.yy"
    60286029    { (yyval.sn) = new StatementNode( StatementNode::Return, (yyvsp[(2) - (3)].en), 0 ); }
    60296030    break;
     
    60326033
    60336034/* Line 1806 of yacc.c  */
    6034 #line 857 "parser.yy"
     6035#line 859 "parser.yy"
    60356036    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    60366037    break;
     
    60396040
    60406041/* Line 1806 of yacc.c  */
    6041 #line 861 "parser.yy"
     6042#line 863 "parser.yy"
    60426043    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (3)].en), 0 ); }
    60436044    break;
     
    60466047
    60476048/* Line 1806 of yacc.c  */
    6048 #line 863 "parser.yy"
     6049#line 865 "parser.yy"
    60496050    { (yyval.sn) = new StatementNode( StatementNode::Throw, (yyvsp[(2) - (5)].en), 0 ); }
    60506051    break;
    60516052
    60526053  case 197:
    6053 
    6054 /* Line 1806 of yacc.c  */
    6055 #line 870 "parser.yy"
    6056     { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
    6057     break;
    6058 
    6059   case 198:
    60606054
    60616055/* Line 1806 of yacc.c  */
     
    60646058    break;
    60656059
     6060  case 198:
     6061
     6062/* Line 1806 of yacc.c  */
     6063#line 874 "parser.yy"
     6064    { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
     6065    break;
     6066
    60666067  case 199:
    60676068
    60686069/* Line 1806 of yacc.c  */
    6069 #line 874 "parser.yy"
     6070#line 876 "parser.yy"
    60706071    {
    60716072                        (yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) );
     
    60776078
    60786079/* Line 1806 of yacc.c  */
    6079 #line 885 "parser.yy"
     6080#line 887 "parser.yy"
    60806081    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    60816082    break;
     
    60846085
    60856086/* Line 1806 of yacc.c  */
    6086 #line 887 "parser.yy"
     6087#line 889 "parser.yy"
    60876088    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    60886089    break;
     
    60916092
    60926093/* Line 1806 of yacc.c  */
    6093 #line 889 "parser.yy"
     6094#line 891 "parser.yy"
    60946095    { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    60956096    break;
     
    60986099
    60996100/* Line 1806 of yacc.c  */
    6100 #line 891 "parser.yy"
     6101#line 893 "parser.yy"
    61016102    { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    61026103    break;
     
    61056106
    61066107/* Line 1806 of yacc.c  */
    6107 #line 896 "parser.yy"
     6108#line 898 "parser.yy"
    61086109    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    61096110    break;
     
    61126113
    61136114/* Line 1806 of yacc.c  */
    6114 #line 898 "parser.yy"
     6115#line 900 "parser.yy"
    61156116    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    61166117    break;
     
    61196120
    61206121/* Line 1806 of yacc.c  */
    6121 #line 900 "parser.yy"
     6122#line 902 "parser.yy"
    61226123    { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    61236124    break;
     
    61266127
    61276128/* Line 1806 of yacc.c  */
    6128 #line 902 "parser.yy"
     6129#line 904 "parser.yy"
    61296130    { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    61306131    break;
     
    61336134
    61346135/* Line 1806 of yacc.c  */
    6135 #line 907 "parser.yy"
     6136#line 909 "parser.yy"
    61366137    {
    61376138                        (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
     
    61436144
    61446145/* Line 1806 of yacc.c  */
    6145 #line 921 "parser.yy"
     6146#line 923 "parser.yy"
    61466147    {
    61476148                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61536154
    61546155/* Line 1806 of yacc.c  */
    6155 #line 926 "parser.yy"
     6156#line 928 "parser.yy"
    61566157    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    61576158    break;
     
    61606161
    61616162/* Line 1806 of yacc.c  */
    6162 #line 928 "parser.yy"
     6163#line 930 "parser.yy"
    61636164    {
    61646165                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61706171
    61716172/* Line 1806 of yacc.c  */
    6172 #line 937 "parser.yy"
     6173#line 939 "parser.yy"
    61736174    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
    61746175    break;
     
    61776178
    61786179/* Line 1806 of yacc.c  */
    6179 #line 939 "parser.yy"
     6180#line 941 "parser.yy"
    61806181    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
    61816182    break;
     
    61846185
    61856186/* Line 1806 of yacc.c  */
    6186 #line 941 "parser.yy"
     6187#line 943 "parser.yy"
    61876188    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
    61886189    break;
     
    61916192
    61926193/* Line 1806 of yacc.c  */
    6193 #line 943 "parser.yy"
     6194#line 945 "parser.yy"
    61946195    { (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) ); }
    61956196    break;
     
    61986199
    61996200/* Line 1806 of yacc.c  */
    6200 #line 945 "parser.yy"
     6201#line 947 "parser.yy"
    62016202    { (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) ); }
    62026203    break;
     
    62056206
    62066207/* Line 1806 of yacc.c  */
    6207 #line 950 "parser.yy"
     6208#line 952 "parser.yy"
    62086209    { (yyval.flag) = false; }
    62096210    break;
     
    62126213
    62136214/* Line 1806 of yacc.c  */
    6214 #line 952 "parser.yy"
     6215#line 954 "parser.yy"
    62156216    { (yyval.flag) = true; }
    62166217    break;
     
    62196220
    62206221/* Line 1806 of yacc.c  */
    6221 #line 957 "parser.yy"
     6222#line 959 "parser.yy"
    62226223    { (yyval.en) = 0; }
    62236224    break;
     
    62266227
    62276228/* Line 1806 of yacc.c  */
    6228 #line 964 "parser.yy"
     6229#line 966 "parser.yy"
    62296230    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
    62306231    break;
     
    62336234
    62346235/* Line 1806 of yacc.c  */
    6235 #line 969 "parser.yy"
     6236#line 971 "parser.yy"
    62366237    { (yyval.en) = new AsmExprNode( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ); }
    62376238    break;
     
    62406241
    62416242/* Line 1806 of yacc.c  */
    6242 #line 971 "parser.yy"
     6243#line 973 "parser.yy"
    62436244    { (yyval.en) = new AsmExprNode( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ); }
    62446245    break;
     
    62476248
    62486249/* Line 1806 of yacc.c  */
    6249 #line 976 "parser.yy"
     6250#line 978 "parser.yy"
    62506251    { (yyval.constant) = 0; }
    62516252    break;
     
    62546255
    62556256/* Line 1806 of yacc.c  */
    6256 #line 978 "parser.yy"
     6257#line 980 "parser.yy"
    62576258    { (yyval.constant) = (yyvsp[(1) - (1)].constant); }
    62586259    break;
     
    62616262
    62626263/* Line 1806 of yacc.c  */
    6263 #line 980 "parser.yy"
     6264#line 982 "parser.yy"
    62646265    { (yyval.constant) = (ConstantNode *)(yyvsp[(1) - (3)].constant)->set_link( (yyvsp[(3) - (3)].constant) ); }
    62656266    break;
     
    62686269
    62696270/* Line 1806 of yacc.c  */
    6270 #line 985 "parser.yy"
     6271#line 987 "parser.yy"
    62716272    { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
    62726273    break;
     
    62756276
    62766277/* Line 1806 of yacc.c  */
    6277 #line 987 "parser.yy"
     6278#line 989 "parser.yy"
    62786279    { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
    62796280    break;
     
    62826283
    62836284/* Line 1806 of yacc.c  */
    6284 #line 994 "parser.yy"
     6285#line 996 "parser.yy"
    62856286    { (yyval.decl) = 0; }
    62866287    break;
     
    62896290
    62906291/* Line 1806 of yacc.c  */
    6291 #line 1001 "parser.yy"
     6292#line 1003 "parser.yy"
    62926293    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    62936294    break;
     
    62966297
    62976298/* Line 1806 of yacc.c  */
    6298 #line 1006 "parser.yy"
     6299#line 1008 "parser.yy"
    62996300    { (yyval.decl) = 0; }
    63006301    break;
     
    63036304
    63046305/* Line 1806 of yacc.c  */
    6305 #line 1013 "parser.yy"
     6306#line 1015 "parser.yy"
    63066307    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    63076308    break;
     
    63106311
    63116312/* Line 1806 of yacc.c  */
    6312 #line 1027 "parser.yy"
     6313#line 1029 "parser.yy"
    63136314    {}
    63146315    break;
     
    63176318
    63186319/* Line 1806 of yacc.c  */
    6319 #line 1028 "parser.yy"
     6320#line 1030 "parser.yy"
    63206321    {}
    63216322    break;
     
    63246325
    63256326/* Line 1806 of yacc.c  */
    6326 #line 1057 "parser.yy"
     6327#line 1059 "parser.yy"
    63276328    {
    63286329                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63346335
    63356336/* Line 1806 of yacc.c  */
    6336 #line 1064 "parser.yy"
     6337#line 1066 "parser.yy"
    63376338    {
    63386339                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63446345
    63456346/* Line 1806 of yacc.c  */
    6346 #line 1069 "parser.yy"
     6347#line 1071 "parser.yy"
    63476348    {
    63486349                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
     
    63546355
    63556356/* Line 1806 of yacc.c  */
    6356 #line 1079 "parser.yy"
     6357#line 1081 "parser.yy"
    63576358    {
    63586359                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63646365
    63656366/* Line 1806 of yacc.c  */
    6366 #line 1084 "parser.yy"
     6367#line 1086 "parser.yy"
    63676368    {
    63686369                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63746375
    63756376/* Line 1806 of yacc.c  */
    6376 #line 1089 "parser.yy"
     6377#line 1091 "parser.yy"
    63776378    {
    63786379                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
     
    63846385
    63856386/* Line 1806 of yacc.c  */
    6386 #line 1097 "parser.yy"
     6387#line 1099 "parser.yy"
    63876388    {
    63886389                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63946395
    63956396/* Line 1806 of yacc.c  */
    6396 #line 1102 "parser.yy"
     6397#line 1104 "parser.yy"
    63976398    {
    63986399                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64046405
    64056406/* Line 1806 of yacc.c  */
    6406 #line 1107 "parser.yy"
     6407#line 1109 "parser.yy"
    64076408    {
    64086409                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64146415
    64156416/* Line 1806 of yacc.c  */
    6416 #line 1112 "parser.yy"
     6417#line 1114 "parser.yy"
    64176418    {
    64186419                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64246425
    64256426/* Line 1806 of yacc.c  */
    6426 #line 1117 "parser.yy"
     6427#line 1119 "parser.yy"
    64276428    {
    64286429                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    64346435
    64356436/* Line 1806 of yacc.c  */
    6436 #line 1125 "parser.yy"
     6437#line 1127 "parser.yy"
    64376438    {
    64386439                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
     
    64436444
    64446445/* Line 1806 of yacc.c  */
    6445 #line 1148 "parser.yy"
     6446#line 1150 "parser.yy"
    64466447    {
    64476448                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    64526453
    64536454/* Line 1806 of yacc.c  */
    6454 #line 1152 "parser.yy"
     6455#line 1154 "parser.yy"
    64556456    {
    64566457                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    64616462
    64626463/* Line 1806 of yacc.c  */
    6463 #line 1159 "parser.yy"
     6464#line 1161 "parser.yy"
    64646465    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    64656466    break;
     
    64686469
    64696470/* Line 1806 of yacc.c  */
    6470 #line 1163 "parser.yy"
     6471#line 1165 "parser.yy"
    64716472    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    64726473    break;
     
    64756476
    64766477/* Line 1806 of yacc.c  */
    6477 #line 1168 "parser.yy"
     6478#line 1170 "parser.yy"
    64786479    {
    64796480                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64856486
    64866487/* Line 1806 of yacc.c  */
    6487 #line 1173 "parser.yy"
     6488#line 1175 "parser.yy"
    64886489    {
    64896490                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64956496
    64966497/* Line 1806 of yacc.c  */
    6497 #line 1178 "parser.yy"
     6498#line 1180 "parser.yy"
    64986499    {
    64996500                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
     
    65056506
    65066507/* Line 1806 of yacc.c  */
    6507 #line 1189 "parser.yy"
     6508#line 1191 "parser.yy"
    65086509    {
    65096510                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65156516
    65166517/* Line 1806 of yacc.c  */
    6517 #line 1194 "parser.yy"
     6518#line 1196 "parser.yy"
    65186519    {
    65196520                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65256526
    65266527/* Line 1806 of yacc.c  */
    6527 #line 1199 "parser.yy"
     6528#line 1201 "parser.yy"
    65286529    {
    65296530                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65356536
    65366537/* Line 1806 of yacc.c  */
    6537 #line 1204 "parser.yy"
     6538#line 1206 "parser.yy"
    65386539    {
    65396540                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65456546
    65466547/* Line 1806 of yacc.c  */
    6547 #line 1209 "parser.yy"
     6548#line 1211 "parser.yy"
    65486549    {
    65496550                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65556556
    65566557/* Line 1806 of yacc.c  */
    6557 #line 1218 "parser.yy"
     6558#line 1220 "parser.yy"
    65586559    {
    65596560                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
     
    65656566
    65666567/* Line 1806 of yacc.c  */
    6567 #line 1223 "parser.yy"
     6568#line 1225 "parser.yy"
    65686569    {
    65696570                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
     
    65756576
    65766577/* Line 1806 of yacc.c  */
    6577 #line 1240 "parser.yy"
     6578#line 1242 "parser.yy"
    65786579    {
    65796580                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65856586
    65866587/* Line 1806 of yacc.c  */
    6587 #line 1245 "parser.yy"
     6588#line 1247 "parser.yy"
    65886589    {
    65896590                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65956596
    65966597/* Line 1806 of yacc.c  */
    6597 #line 1267 "parser.yy"
     6598#line 1269 "parser.yy"
    65986599    { (yyval.decl) = 0; }
    65996600    break;
     
    66026603
    66036604/* Line 1806 of yacc.c  */
    6604 #line 1279 "parser.yy"
     6605#line 1281 "parser.yy"
    66056606    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66066607    break;
     
    66096610
    66106611/* Line 1806 of yacc.c  */
    6611 #line 1290 "parser.yy"
     6612#line 1292 "parser.yy"
    66126613    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    66136614    break;
     
    66166617
    66176618/* Line 1806 of yacc.c  */
    6618 #line 1292 "parser.yy"
     6619#line 1294 "parser.yy"
    66196620    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    66206621    break;
     
    66236624
    66246625/* Line 1806 of yacc.c  */
    6625 #line 1294 "parser.yy"
     6626#line 1296 "parser.yy"
    66266627    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    66276628    break;
     
    66306631
    66316632/* Line 1806 of yacc.c  */
    6632 #line 1296 "parser.yy"
     6633#line 1298 "parser.yy"
    66336634    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    66346635    break;
     
    66376638
    66386639/* Line 1806 of yacc.c  */
    6639 #line 1298 "parser.yy"
     6640#line 1300 "parser.yy"
    66406641    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    66416642    break;
     
    66446645
    66456646/* Line 1806 of yacc.c  */
    6646 #line 1300 "parser.yy"
     6647#line 1302 "parser.yy"
    66476648    {
    66486649                        typedefTable.enterScope();
     
    66536654
    66546655/* Line 1806 of yacc.c  */
    6655 #line 1304 "parser.yy"
     6656#line 1306 "parser.yy"
    66566657    {
    66576658                        typedefTable.leaveScope();
     
    66636664
    66646665/* Line 1806 of yacc.c  */
    6665 #line 1313 "parser.yy"
     6666#line 1315 "parser.yy"
    66666667    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66676668    break;
     
    66706671
    66716672/* Line 1806 of yacc.c  */
    6672 #line 1315 "parser.yy"
     6673#line 1317 "parser.yy"
    66736674    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    66746675    break;
     
    66776678
    66786679/* Line 1806 of yacc.c  */
    6679 #line 1326 "parser.yy"
     6680#line 1328 "parser.yy"
    66806681    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66816682    break;
     
    66846685
    66856686/* Line 1806 of yacc.c  */
    6686 #line 1335 "parser.yy"
     6687#line 1337 "parser.yy"
    66876688    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    66886689    break;
     
    66916692
    66926693/* Line 1806 of yacc.c  */
    6693 #line 1337 "parser.yy"
     6694#line 1339 "parser.yy"
    66946695    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    66956696    break;
     
    66986699
    66996700/* Line 1806 of yacc.c  */
    6700 #line 1339 "parser.yy"
     6701#line 1341 "parser.yy"
    67016702    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    67026703    break;
     
    67056706
    67066707/* Line 1806 of yacc.c  */
    6707 #line 1341 "parser.yy"
     6708#line 1343 "parser.yy"
    67086709    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    67096710    break;
     
    67126713
    67136714/* Line 1806 of yacc.c  */
    6714 #line 1343 "parser.yy"
     6715#line 1345 "parser.yy"
    67156716    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    67166717    break;
     
    67196720
    67206721/* Line 1806 of yacc.c  */
    6721 #line 1345 "parser.yy"
     6722#line 1347 "parser.yy"
    67226723    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    67236724    break;
     
    67266727
    67276728/* Line 1806 of yacc.c  */
    6728 #line 1347 "parser.yy"
     6729#line 1349 "parser.yy"
    67296730    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
    67306731    break;
     
    67336734
    67346735/* Line 1806 of yacc.c  */
    6735 #line 1349 "parser.yy"
     6736#line 1351 "parser.yy"
    67366737    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    67376738    break;
     
    67406741
    67416742/* Line 1806 of yacc.c  */
    6742 #line 1354 "parser.yy"
     6743#line 1356 "parser.yy"
    67436744    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    67446745    break;
     
    67476748
    67486749/* Line 1806 of yacc.c  */
    6749 #line 1356 "parser.yy"
     6750#line 1358 "parser.yy"
    67506751    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    67516752    break;
     
    67546755
    67556756/* Line 1806 of yacc.c  */
    6756 #line 1358 "parser.yy"
     6757#line 1360 "parser.yy"
    67576758    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    67586759    break;
     
    67616762
    67626763/* Line 1806 of yacc.c  */
    6763 #line 1360 "parser.yy"
     6764#line 1362 "parser.yy"
    67646765    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    67656766    break;
     
    67686769
    67696770/* Line 1806 of yacc.c  */
    6770 #line 1362 "parser.yy"
     6771#line 1364 "parser.yy"
    67716772    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
    67726773    break;
     
    67756776
    67766777/* Line 1806 of yacc.c  */
    6777 #line 1364 "parser.yy"
     6778#line 1366 "parser.yy"
    67786779    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
    67796780    break;
     
    67826783
    67836784/* Line 1806 of yacc.c  */
    6784 #line 1366 "parser.yy"
     6785#line 1368 "parser.yy"
    67856786    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
    67866787    break;
     
    67896790
    67906791/* Line 1806 of yacc.c  */
    6791 #line 1368 "parser.yy"
     6792#line 1370 "parser.yy"
    67926793    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
    67936794    break;
     
    67966797
    67976798/* Line 1806 of yacc.c  */
    6798 #line 1370 "parser.yy"
     6799#line 1372 "parser.yy"
    67996800    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    68006801    break;
     
    68036804
    68046805/* Line 1806 of yacc.c  */
    6805 #line 1372 "parser.yy"
     6806#line 1374 "parser.yy"
    68066807    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    68076808    break;
     
    68106811
    68116812/* Line 1806 of yacc.c  */
    6812 #line 1374 "parser.yy"
     6813#line 1376 "parser.yy"
    68136814    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
    68146815    break;
     
    68176818
    68186819/* Line 1806 of yacc.c  */
    6819 #line 1376 "parser.yy"
     6820#line 1378 "parser.yy"
    68206821    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
    68216822    break;
     
    68246825
    68256826/* Line 1806 of yacc.c  */
    6826 #line 1378 "parser.yy"
     6827#line 1380 "parser.yy"
    68276828    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    68286829    break;
     
    68316832
    68326833/* Line 1806 of yacc.c  */
    6833 #line 1385 "parser.yy"
     6834#line 1387 "parser.yy"
    68346835    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68356836    break;
     
    68386839
    68396840/* Line 1806 of yacc.c  */
    6840 #line 1387 "parser.yy"
     6841#line 1389 "parser.yy"
    68416842    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68426843    break;
     
    68456846
    68466847/* Line 1806 of yacc.c  */
    6847 #line 1389 "parser.yy"
     6848#line 1391 "parser.yy"
    68486849    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68496850    break;
     
    68526853
    68536854/* Line 1806 of yacc.c  */
    6854 #line 1391 "parser.yy"
     6855#line 1393 "parser.yy"
    68556856    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    68566857    break;
     
    68596860
    68606861/* Line 1806 of yacc.c  */
    6861 #line 1397 "parser.yy"
     6862#line 1399 "parser.yy"
    68626863    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68636864    break;
     
    68666867
    68676868/* Line 1806 of yacc.c  */
    6868 #line 1404 "parser.yy"
     6869#line 1406 "parser.yy"
    68696870    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68706871    break;
     
    68736874
    68746875/* Line 1806 of yacc.c  */
    6875 #line 1406 "parser.yy"
     6876#line 1408 "parser.yy"
    68766877    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68776878    break;
     
    68806881
    68816882/* Line 1806 of yacc.c  */
    6882 #line 1408 "parser.yy"
     6883#line 1410 "parser.yy"
    68836884    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    68846885    break;
     
    68876888
    68886889/* Line 1806 of yacc.c  */
    6889 #line 1413 "parser.yy"
     6890#line 1415 "parser.yy"
    68906891    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    68916892    break;
     
    68946895
    68956896/* Line 1806 of yacc.c  */
    6896 #line 1415 "parser.yy"
     6897#line 1417 "parser.yy"
    68976898    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    68986899    break;
     
    69016902
    69026903/* Line 1806 of yacc.c  */
    6903 #line 1417 "parser.yy"
     6904#line 1419 "parser.yy"
    69046905    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    69056906    break;
     
    69086909
    69096910/* Line 1806 of yacc.c  */
    6910 #line 1419 "parser.yy"
     6911#line 1421 "parser.yy"
    69116912    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    69126913    break;
     
    69156916
    69166917/* Line 1806 of yacc.c  */
    6917 #line 1425 "parser.yy"
     6918#line 1427 "parser.yy"
    69186919    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69196920    break;
     
    69226923
    69236924/* Line 1806 of yacc.c  */
    6924 #line 1427 "parser.yy"
     6925#line 1429 "parser.yy"
    69256926    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69266927    break;
     
    69296930
    69306931/* Line 1806 of yacc.c  */
    6931 #line 1429 "parser.yy"
     6932#line 1431 "parser.yy"
    69326933    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    69336934    break;
     
    69366937
    69376938/* Line 1806 of yacc.c  */
    6938 #line 1435 "parser.yy"
     6939#line 1437 "parser.yy"
    69396940    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69406941    break;
     
    69436944
    69446945/* Line 1806 of yacc.c  */
    6945 #line 1437 "parser.yy"
     6946#line 1439 "parser.yy"
    69466947    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69476948    break;
     
    69506951
    69516952/* Line 1806 of yacc.c  */
    6952 #line 1443 "parser.yy"
     6953#line 1445 "parser.yy"
    69536954    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69546955    break;
     
    69576958
    69586959/* Line 1806 of yacc.c  */
    6959 #line 1445 "parser.yy"
     6960#line 1447 "parser.yy"
    69606961    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69616962    break;
     
    69646965
    69656966/* Line 1806 of yacc.c  */
    6966 #line 1447 "parser.yy"
     6967#line 1449 "parser.yy"
    69676968    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    69686969    break;
     
    69716972
    69726973/* Line 1806 of yacc.c  */
    6973 #line 1452 "parser.yy"
     6974#line 1454 "parser.yy"
    69746975    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    69756976    break;
     
    69786979
    69796980/* Line 1806 of yacc.c  */
    6980 #line 1454 "parser.yy"
     6981#line 1456 "parser.yy"
    69816982    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69826983    break;
     
    69856986
    69866987/* Line 1806 of yacc.c  */
    6987 #line 1456 "parser.yy"
     6988#line 1458 "parser.yy"
    69886989    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69896990    break;
     
    69926993
    69936994/* Line 1806 of yacc.c  */
    6994 #line 1466 "parser.yy"
     6995#line 1468 "parser.yy"
    69956996    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
    69966997    break;
     
    69997000
    70007001/* Line 1806 of yacc.c  */
    7001 #line 1468 "parser.yy"
     7002#line 1470 "parser.yy"
    70027003    {
    70037004                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    70097010
    70107011/* Line 1806 of yacc.c  */
    7011 #line 1473 "parser.yy"
     7012#line 1475 "parser.yy"
    70127013    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    70137014    break;
     
    70167017
    70177018/* Line 1806 of yacc.c  */
    7018 #line 1475 "parser.yy"
     7019#line 1477 "parser.yy"
    70197020    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
    70207021    break;
     
    70237024
    70247025/* Line 1806 of yacc.c  */
    7025 #line 1477 "parser.yy"
     7026#line 1479 "parser.yy"
    70267027    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    70277028    break;
     
    70307031
    70317032/* Line 1806 of yacc.c  */
    7032 #line 1479 "parser.yy"
     7033#line 1481 "parser.yy"
    70337034    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    70347035    break;
     
    70377038
    70387039/* Line 1806 of yacc.c  */
    7039 #line 1484 "parser.yy"
     7040#line 1486 "parser.yy"
    70407041    { (yyval.aggKey) = DeclarationNode::Struct; }
    70417042    break;
     
    70447045
    70457046/* Line 1806 of yacc.c  */
    7046 #line 1486 "parser.yy"
     7047#line 1488 "parser.yy"
    70477048    { (yyval.aggKey) = DeclarationNode::Union; }
    70487049    break;
     
    70517052
    70527053/* Line 1806 of yacc.c  */
    7053 #line 1491 "parser.yy"
     7054#line 1493 "parser.yy"
    70547055    { (yyval.decl) = 0; }
    70557056    break;
     
    70587059
    70597060/* Line 1806 of yacc.c  */
    7060 #line 1493 "parser.yy"
     7061#line 1495 "parser.yy"
    70617062    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    70627063    break;
     
    70657066
    70667067/* Line 1806 of yacc.c  */
    7067 #line 1499 "parser.yy"
     7068#line 1501 "parser.yy"
    70687069    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    70697070    break;
     
    70727073
    70737074/* Line 1806 of yacc.c  */
    7074 #line 1502 "parser.yy"
     7075#line 1504 "parser.yy"
    70757076    {   // mark all fields in list
    70767077                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    70837084
    70847085/* Line 1806 of yacc.c  */
    7085 #line 1512 "parser.yy"
     7086#line 1514 "parser.yy"
    70867087    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    70877088    break;
     
    70907091
    70917092/* Line 1806 of yacc.c  */
    7092 #line 1514 "parser.yy"
     7093#line 1516 "parser.yy"
    70937094    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    70947095    break;
     
    70977098
    70987099/* Line 1806 of yacc.c  */
    7099 #line 1516 "parser.yy"
     7100#line 1518 "parser.yy"
    71007101    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    71017102    break;
     
    71047105
    71057106/* Line 1806 of yacc.c  */
    7106 #line 1521 "parser.yy"
     7107#line 1523 "parser.yy"
    71077108    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    71087109    break;
     
    71117112
    71127113/* Line 1806 of yacc.c  */
    7113 #line 1523 "parser.yy"
     7114#line 1525 "parser.yy"
    71147115    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    71157116    break;
     
    71187119
    71197120/* Line 1806 of yacc.c  */
    7120 #line 1528 "parser.yy"
     7121#line 1530 "parser.yy"
    71217122    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    71227123    break;
     
    71257126
    71267127/* Line 1806 of yacc.c  */
    7127 #line 1530 "parser.yy"
     7128#line 1532 "parser.yy"
    71287129    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    71297130    break;
     
    71327133
    71337134/* Line 1806 of yacc.c  */
    7134 #line 1533 "parser.yy"
     7135#line 1535 "parser.yy"
    71357136    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    71367137    break;
     
    71397140
    71407141/* Line 1806 of yacc.c  */
    7141 #line 1536 "parser.yy"
     7142#line 1538 "parser.yy"
    71427143    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    71437144    break;
     
    71467147
    71477148/* Line 1806 of yacc.c  */
    7148 #line 1542 "parser.yy"
     7149#line 1544 "parser.yy"
    71497150    { (yyval.en) = 0; }
    71507151    break;
     
    71537154
    71547155/* Line 1806 of yacc.c  */
    7155 #line 1544 "parser.yy"
     7156#line 1546 "parser.yy"
    71567157    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    71577158    break;
     
    71607161
    71617162/* Line 1806 of yacc.c  */
    7162 #line 1549 "parser.yy"
     7163#line 1551 "parser.yy"
    71637164    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    71647165    break;
     
    71677168
    71687169/* Line 1806 of yacc.c  */
    7169 #line 1558 "parser.yy"
     7170#line 1560 "parser.yy"
    71707171    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
    71717172    break;
     
    71747175
    71757176/* Line 1806 of yacc.c  */
    7176 #line 1560 "parser.yy"
     7177#line 1562 "parser.yy"
    71777178    {
    71787179                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    71847185
    71857186/* Line 1806 of yacc.c  */
    7186 #line 1565 "parser.yy"
     7187#line 1567 "parser.yy"
    71877188    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    71887189    break;
     
    71917192
    71927193/* Line 1806 of yacc.c  */
    7193 #line 1567 "parser.yy"
     7194#line 1569 "parser.yy"
    71947195    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    71957196    break;
     
    71987199
    71997200/* Line 1806 of yacc.c  */
    7200 #line 1572 "parser.yy"
     7201#line 1574 "parser.yy"
    72017202    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    72027203    break;
     
    72057206
    72067207/* Line 1806 of yacc.c  */
    7207 #line 1574 "parser.yy"
     7208#line 1576 "parser.yy"
    72087209    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    72097210    break;
     
    72127213
    72137214/* Line 1806 of yacc.c  */
    7214 #line 1579 "parser.yy"
     7215#line 1581 "parser.yy"
    72157216    { (yyval.en) = 0; }
    72167217    break;
     
    72197220
    72207221/* Line 1806 of yacc.c  */
    7221 #line 1581 "parser.yy"
     7222#line 1583 "parser.yy"
    72227223    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    72237224    break;
     
    72267227
    72277228/* Line 1806 of yacc.c  */
    7228 #line 1588 "parser.yy"
     7229#line 1590 "parser.yy"
    72297230    { (yyval.decl) = 0; }
    72307231    break;
     
    72337234
    72347235/* Line 1806 of yacc.c  */
    7235 #line 1596 "parser.yy"
     7236#line 1598 "parser.yy"
    72367237    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72377238    break;
    72387239
    72397240  case 407:
    7240 
    7241 /* Line 1806 of yacc.c  */
    7242 #line 1598 "parser.yy"
    7243     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    7244     break;
    7245 
    7246   case 408:
    72477241
    72487242/* Line 1806 of yacc.c  */
     
    72517245    break;
    72527246
     7247  case 408:
     7248
     7249/* Line 1806 of yacc.c  */
     7250#line 1602 "parser.yy"
     7251    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     7252    break;
     7253
    72537254  case 410:
    7254 
    7255 /* Line 1806 of yacc.c  */
    7256 #line 1608 "parser.yy"
    7257     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7258     break;
    7259 
    7260   case 411:
    72617255
    72627256/* Line 1806 of yacc.c  */
     
    72657259    break;
    72667260
     7261  case 411:
     7262
     7263/* Line 1806 of yacc.c  */
     7264#line 1612 "parser.yy"
     7265    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7266    break;
     7267
    72677268  case 412:
    72687269
    72697270/* Line 1806 of yacc.c  */
    7270 #line 1612 "parser.yy"
     7271#line 1614 "parser.yy"
    72717272    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    72727273    break;
     
    72757276
    72767277/* Line 1806 of yacc.c  */
    7277 #line 1618 "parser.yy"
     7278#line 1620 "parser.yy"
    72787279    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72797280    break;
     
    72827283
    72837284/* Line 1806 of yacc.c  */
    7284 #line 1623 "parser.yy"
     7285#line 1625 "parser.yy"
    72857286    { (yyval.decl) = 0; }
    72867287    break;
     
    72897290
    72907291/* Line 1806 of yacc.c  */
    7291 #line 1630 "parser.yy"
     7292#line 1632 "parser.yy"
    72927293    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72937294    break;
    72947295
    72957296  case 421:
    7296 
    7297 /* Line 1806 of yacc.c  */
    7298 #line 1637 "parser.yy"
    7299     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7300     break;
    7301 
    7302   case 422:
    73037297
    73047298/* Line 1806 of yacc.c  */
     
    73077301    break;
    73087302
     7303  case 422:
     7304
     7305/* Line 1806 of yacc.c  */
     7306#line 1641 "parser.yy"
     7307    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7308    break;
     7309
    73097310  case 424:
    73107311
    73117312/* Line 1806 of yacc.c  */
    7312 #line 1648 "parser.yy"
     7313#line 1650 "parser.yy"
    73137314    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    73147315    break;
     
    73177318
    73187319/* Line 1806 of yacc.c  */
    7319 #line 1651 "parser.yy"
     7320#line 1653 "parser.yy"
    73207321    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    73217322    break;
     
    73247325
    73257326/* Line 1806 of yacc.c  */
    7326 #line 1653 "parser.yy"
     7327#line 1655 "parser.yy"
    73277328    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    73287329    break;
     
    73317332
    73327333/* Line 1806 of yacc.c  */
    7333 #line 1663 "parser.yy"
     7334#line 1665 "parser.yy"
    73347335    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    73357336    break;
     
    73387339
    73397340/* Line 1806 of yacc.c  */
    7340 #line 1669 "parser.yy"
     7341#line 1671 "parser.yy"
    73417342    {
    73427343                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73487349
    73497350/* Line 1806 of yacc.c  */
    7350 #line 1674 "parser.yy"
     7351#line 1676 "parser.yy"
    73517352    {
    73527353                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73587359
    73597360/* Line 1806 of yacc.c  */
    7360 #line 1683 "parser.yy"
     7361#line 1685 "parser.yy"
    73617362    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73627363    break;
     
    73657366
    73667367/* Line 1806 of yacc.c  */
    7367 #line 1692 "parser.yy"
     7368#line 1694 "parser.yy"
    73687369    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    73697370    break;
     
    73727373
    73737374/* Line 1806 of yacc.c  */
    7374 #line 1694 "parser.yy"
     7375#line 1696 "parser.yy"
    73757376    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    73767377    break;
     
    73797380
    73807381/* Line 1806 of yacc.c  */
    7381 #line 1719 "parser.yy"
     7382#line 1721 "parser.yy"
    73827383    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73837384    break;
     
    73867387
    73877388/* Line 1806 of yacc.c  */
    7388 #line 1727 "parser.yy"
     7389#line 1729 "parser.yy"
    73897390    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73907391    break;
     
    73937394
    73947395/* Line 1806 of yacc.c  */
    7395 #line 1732 "parser.yy"
     7396#line 1734 "parser.yy"
    73967397    { (yyval.in) = 0; }
    73977398    break;
     
    74007401
    74017402/* Line 1806 of yacc.c  */
    7402 #line 1734 "parser.yy"
     7403#line 1736 "parser.yy"
    74037404    { (yyval.in) = (yyvsp[(2) - (2)].in); }
    74047405    break;
     
    74077408
    74087409/* Line 1806 of yacc.c  */
    7409 #line 1736 "parser.yy"
     7410#line 1738 "parser.yy"
    74107411    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    74117412    break;
     
    74147415
    74157416/* Line 1806 of yacc.c  */
    7416 #line 1740 "parser.yy"
     7417#line 1742 "parser.yy"
    74177418    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    74187419    break;
     
    74217422
    74227423/* Line 1806 of yacc.c  */
    7423 #line 1741 "parser.yy"
     7424#line 1743 "parser.yy"
    74247425    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    74257426    break;
     
    74287429
    74297430/* Line 1806 of yacc.c  */
    7430 #line 1746 "parser.yy"
     7431#line 1748 "parser.yy"
    74317432    { (yyval.in) = 0; }
    74327433    break;
     
    74357436
    74367437/* Line 1806 of yacc.c  */
    7437 #line 1748 "parser.yy"
     7438#line 1750 "parser.yy"
    74387439    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    74397440    break;
     
    74427443
    74437444/* Line 1806 of yacc.c  */
    7444 #line 1749 "parser.yy"
     7445#line 1751 "parser.yy"
    74457446    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
    74467447    break;
     
    74497450
    74507451/* Line 1806 of yacc.c  */
    7451 #line 1751 "parser.yy"
     7452#line 1753 "parser.yy"
    74527453    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    74537454    break;
     
    74567457
    74577458/* Line 1806 of yacc.c  */
    7458 #line 1767 "parser.yy"
     7459#line 1769 "parser.yy"
    74597460    { (yyval.en) = new VarRefNode( (yyvsp[(1) - (2)].tok) ); }
    74607461    break;
     
    74637464
    74647465/* Line 1806 of yacc.c  */
    7465 #line 1773 "parser.yy"
     7466#line 1775 "parser.yy"
    74667467    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) )); }
    74677468    break;
     
    74707471
    74717472/* Line 1806 of yacc.c  */
    7472 #line 1781 "parser.yy"
     7473#line 1783 "parser.yy"
    74737474    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(1) - (1)].tok) ) ); }
    74747475    break;
     
    74777478
    74787479/* Line 1806 of yacc.c  */
    7479 #line 1783 "parser.yy"
     7480#line 1785 "parser.yy"
    74807481    { (yyval.en) = new DesignatorNode( new VarRefNode( (yyvsp[(2) - (2)].tok) ) ); }
    74817482    break;
    74827483
    74837484  case 471:
    7484 
    7485 /* Line 1806 of yacc.c  */
    7486 #line 1786 "parser.yy"
    7487     { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
    7488     break;
    7489 
    7490   case 472:
    74917485
    74927486/* Line 1806 of yacc.c  */
     
    74957489    break;
    74967490
     7491  case 472:
     7492
     7493/* Line 1806 of yacc.c  */
     7494#line 1790 "parser.yy"
     7495    { (yyval.en) = new DesignatorNode( (yyvsp[(3) - (5)].en), true ); }
     7496    break;
     7497
    74977498  case 473:
    74987499
    74997500/* Line 1806 of yacc.c  */
    7500 #line 1790 "parser.yy"
    7501     { (yyval.en) = new DesignatorNode( new CompositeExprNode2( build_binary_val( OperatorNode::Range, (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ), true ); }
     7501#line 1792 "parser.yy"
     7502    { (yyval.en) = new DesignatorNode( new CompositeExprNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ), true ); }
    75027503    break;
    75037504
     
    75057506
    75067507/* Line 1806 of yacc.c  */
    7507 #line 1792 "parser.yy"
     7508#line 1794 "parser.yy"
    75087509    { (yyval.en) = new DesignatorNode( (yyvsp[(4) - (6)].en) ); }
    75097510    break;
     
    75127513
    75137514/* Line 1806 of yacc.c  */
    7514 #line 1816 "parser.yy"
     7515#line 1818 "parser.yy"
    75157516    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75167517    break;
     
    75197520
    75207521/* Line 1806 of yacc.c  */
    7521 #line 1818 "parser.yy"
     7522#line 1820 "parser.yy"
    75227523    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    75237524    break;
     
    75267527
    75277528/* Line 1806 of yacc.c  */
    7528 #line 1820 "parser.yy"
     7529#line 1822 "parser.yy"
    75297530    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    75307531    break;
     
    75337534
    75347535/* Line 1806 of yacc.c  */
    7535 #line 1826 "parser.yy"
     7536#line 1828 "parser.yy"
    75367537    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75377538    break;
     
    75407541
    75417542/* Line 1806 of yacc.c  */
    7542 #line 1828 "parser.yy"
     7543#line 1830 "parser.yy"
    75437544    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    75447545    break;
     
    75477548
    75487549/* Line 1806 of yacc.c  */
    7549 #line 1833 "parser.yy"
     7550#line 1835 "parser.yy"
    75507551    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    75517552    break;
     
    75547555
    75557556/* Line 1806 of yacc.c  */
    7556 #line 1839 "parser.yy"
     7557#line 1841 "parser.yy"
    75577558    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    75587559    break;
     
    75617562
    75627563/* Line 1806 of yacc.c  */
    7563 #line 1844 "parser.yy"
     7564#line 1846 "parser.yy"
    75647565    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    75657566    break;
     
    75687569
    75697570/* Line 1806 of yacc.c  */
    7570 #line 1846 "parser.yy"
     7571#line 1848 "parser.yy"
    75717572    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    75727573    break;
     
    75757576
    75767577/* Line 1806 of yacc.c  */
    7577 #line 1852 "parser.yy"
     7578#line 1854 "parser.yy"
    75787579    { (yyval.tclass) = DeclarationNode::Type; }
    75797580    break;
     
    75827583
    75837584/* Line 1806 of yacc.c  */
    7584 #line 1854 "parser.yy"
     7585#line 1856 "parser.yy"
    75857586    { (yyval.tclass) = DeclarationNode::Ftype; }
    75867587    break;
     
    75897590
    75907591/* Line 1806 of yacc.c  */
    7591 #line 1856 "parser.yy"
     7592#line 1858 "parser.yy"
    75927593    { (yyval.tclass) = DeclarationNode::Dtype; }
    75937594    break;
     
    75967597
    75977598/* Line 1806 of yacc.c  */
    7598 #line 1861 "parser.yy"
     7599#line 1863 "parser.yy"
    75997600    { (yyval.decl) = 0; }
    76007601    break;
     
    76037604
    76047605/* Line 1806 of yacc.c  */
    7605 #line 1863 "parser.yy"
     7606#line 1865 "parser.yy"
    76067607    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    76077608    break;
     
    76107611
    76117612/* Line 1806 of yacc.c  */
    7612 #line 1868 "parser.yy"
     7613#line 1870 "parser.yy"
    76137614    {
    76147615                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
     
    76207621
    76217622/* Line 1806 of yacc.c  */
    7622 #line 1873 "parser.yy"
     7623#line 1875 "parser.yy"
    76237624    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    76247625    break;
     
    76277628
    76287629/* Line 1806 of yacc.c  */
    7629 #line 1875 "parser.yy"
     7630#line 1877 "parser.yy"
    76307631    { (yyval.decl) = 0; }
    76317632    break;
     
    76347635
    76357636/* Line 1806 of yacc.c  */
    7636 #line 1880 "parser.yy"
     7637#line 1882 "parser.yy"
    76377638    { (yyval.en) = new TypeValueNode( (yyvsp[(1) - (1)].decl) ); }
    76387639    break;
     
    76417642
    76427643/* Line 1806 of yacc.c  */
    7643 #line 1883 "parser.yy"
     7644#line 1885 "parser.yy"
    76447645    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new TypeValueNode( (yyvsp[(3) - (3)].decl) ))); }
    76457646    break;
     
    76487649
    76497650/* Line 1806 of yacc.c  */
    7650 #line 1885 "parser.yy"
     7651#line 1887 "parser.yy"
    76517652    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
    76527653    break;
     
    76557656
    76567657/* Line 1806 of yacc.c  */
    7657 #line 1890 "parser.yy"
     7658#line 1892 "parser.yy"
    76587659    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    76597660    break;
     
    76627663
    76637664/* Line 1806 of yacc.c  */
    7664 #line 1892 "parser.yy"
     7665#line 1894 "parser.yy"
    76657666    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    76667667    break;
     
    76697670
    76707671/* Line 1806 of yacc.c  */
    7671 #line 1894 "parser.yy"
     7672#line 1896 "parser.yy"
    76727673    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    76737674    break;
     
    76767677
    76777678/* Line 1806 of yacc.c  */
    7678 #line 1899 "parser.yy"
     7679#line 1901 "parser.yy"
    76797680    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    76807681    break;
     
    76837684
    76847685/* Line 1806 of yacc.c  */
    7685 #line 1901 "parser.yy"
     7686#line 1903 "parser.yy"
    76867687    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    76877688    break;
     
    76907691
    76917692/* Line 1806 of yacc.c  */
    7692 #line 1906 "parser.yy"
     7693#line 1908 "parser.yy"
    76937694    {
    76947695                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
     
    77007701
    77017702/* Line 1806 of yacc.c  */
    7702 #line 1911 "parser.yy"
     7703#line 1913 "parser.yy"
    77037704    {
    77047705                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
     
    77107711
    77117712/* Line 1806 of yacc.c  */
    7712 #line 1919 "parser.yy"
     7713#line 1921 "parser.yy"
    77137714    {
    77147715                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
     
    77207721
    77217722/* Line 1806 of yacc.c  */
    7722 #line 1924 "parser.yy"
     7723#line 1926 "parser.yy"
    77237724    {
    77247725                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
     
    77307731
    77317732/* Line 1806 of yacc.c  */
    7732 #line 1929 "parser.yy"
     7733#line 1931 "parser.yy"
    77337734    {
    77347735                        typedefTable.leaveTrait();
     
    77417742
    77427743/* Line 1806 of yacc.c  */
    7743 #line 1939 "parser.yy"
     7744#line 1941 "parser.yy"
    77447745    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    77457746    break;
     
    77487749
    77497750/* Line 1806 of yacc.c  */
    7750 #line 1949 "parser.yy"
     7751#line 1951 "parser.yy"
    77517752    {
    77527753                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77587759
    77597760/* Line 1806 of yacc.c  */
    7760 #line 1954 "parser.yy"
     7761#line 1956 "parser.yy"
    77617762    {
    77627763                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77687769
    77697770/* Line 1806 of yacc.c  */
    7770 #line 1959 "parser.yy"
     7771#line 1961 "parser.yy"
    77717772    {
    77727773                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    77787779
    77797780/* Line 1806 of yacc.c  */
    7780 #line 1967 "parser.yy"
     7781#line 1969 "parser.yy"
    77817782    {
    77827783                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77887789
    77897790/* Line 1806 of yacc.c  */
    7790 #line 1972 "parser.yy"
     7791#line 1974 "parser.yy"
    77917792    {
    77927793                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77987799
    77997800/* Line 1806 of yacc.c  */
    7800 #line 1982 "parser.yy"
     7801#line 1984 "parser.yy"
    78017802    {}
    78027803    break;
     
    78057806
    78067807/* Line 1806 of yacc.c  */
    7807 #line 1984 "parser.yy"
     7808#line 1986 "parser.yy"
    78087809    {
    78097810                        if ( theTree ) {
     
    78187819
    78197820/* Line 1806 of yacc.c  */
    7820 #line 1996 "parser.yy"
     7821#line 1998 "parser.yy"
    78217822    { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    78227823    break;
     
    78257826
    78267827/* Line 1806 of yacc.c  */
    7827 #line 2001 "parser.yy"
     7828#line 2003 "parser.yy"
    78287829    { (yyval.decl) = 0; }
    78297830    break;
     
    78327833
    78337834/* Line 1806 of yacc.c  */
    7834 #line 2009 "parser.yy"
     7835#line 2011 "parser.yy"
    78357836    {}
    78367837    break;
     
    78397840
    78407841/* Line 1806 of yacc.c  */
    7841 #line 2011 "parser.yy"
     7842#line 2013 "parser.yy"
    78427843    {
    78437844                        linkageStack.push( linkage );
     
    78497850
    78507851/* Line 1806 of yacc.c  */
    7851 #line 2016 "parser.yy"
     7852#line 2018 "parser.yy"
    78527853    {
    78537854                        linkage = linkageStack.top();
     
    78607861
    78617862/* Line 1806 of yacc.c  */
    7862 #line 2022 "parser.yy"
     7863#line 2024 "parser.yy"
    78637864    {   // mark all fields in list
    78647865                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     
    78717872
    78727873/* Line 1806 of yacc.c  */
    7873 #line 2037 "parser.yy"
     7874#line 2039 "parser.yy"
    78747875    {
    78757876                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78827883
    78837884/* Line 1806 of yacc.c  */
    7884 #line 2043 "parser.yy"
     7885#line 2045 "parser.yy"
    78857886    {
    78867887                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78937894
    78947895/* Line 1806 of yacc.c  */
    7895 #line 2052 "parser.yy"
     7896#line 2054 "parser.yy"
    78967897    {
    78977898                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79047905
    79057906/* Line 1806 of yacc.c  */
    7906 #line 2058 "parser.yy"
     7907#line 2060 "parser.yy"
    79077908    {
    79087909                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79157916
    79167917/* Line 1806 of yacc.c  */
    7917 #line 2064 "parser.yy"
     7918#line 2066 "parser.yy"
    79187919    {
    79197920                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79267927
    79277928/* Line 1806 of yacc.c  */
    7928 #line 2070 "parser.yy"
     7929#line 2072 "parser.yy"
    79297930    {
    79307931                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79377938
    79387939/* Line 1806 of yacc.c  */
    7939 #line 2076 "parser.yy"
     7940#line 2078 "parser.yy"
    79407941    {
    79417942                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79487949
    79497950/* Line 1806 of yacc.c  */
    7950 #line 2084 "parser.yy"
     7951#line 2086 "parser.yy"
    79517952    {
    79527953                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79597960
    79607961/* Line 1806 of yacc.c  */
    7961 #line 2090 "parser.yy"
     7962#line 2092 "parser.yy"
    79627963    {
    79637964                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79707971
    79717972/* Line 1806 of yacc.c  */
    7972 #line 2098 "parser.yy"
     7973#line 2100 "parser.yy"
    79737974    {
    79747975                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79817982
    79827983/* Line 1806 of yacc.c  */
    7983 #line 2104 "parser.yy"
     7984#line 2106 "parser.yy"
    79847985    {
    79857986                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79927993
    79937994/* Line 1806 of yacc.c  */
    7994 #line 2119 "parser.yy"
    7995     { (yyval.en) = new CompositeExprNode2( build_binary_val( OperatorNode::Range, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     7995#line 2121 "parser.yy"
     7996    { (yyval.en) = new CompositeExprNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    79967997    break;
    79977998
     
    79998000
    80008001/* Line 1806 of yacc.c  */
    8001 #line 2129 "parser.yy"
     8002#line 2131 "parser.yy"
    80028003    { (yyval.decl) = 0; }
    80038004    break;
     
    80068007
    80078008/* Line 1806 of yacc.c  */
    8008 #line 2136 "parser.yy"
     8009#line 2138 "parser.yy"
    80098010    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    80108011    break;
     
    80138014
    80148015/* Line 1806 of yacc.c  */
    8015 #line 2142 "parser.yy"
     8016#line 2144 "parser.yy"
    80168017    { (yyval.decl) = 0; }
    80178018    break;
    80188019
    80198020  case 559:
    8020 
    8021 /* Line 1806 of yacc.c  */
    8022 #line 2157 "parser.yy"
    8023     {}
    8024     break;
    8025 
    8026   case 560:
    8027 
    8028 /* Line 1806 of yacc.c  */
    8029 #line 2158 "parser.yy"
    8030     {}
    8031     break;
    8032 
    8033   case 561:
    80348021
    80358022/* Line 1806 of yacc.c  */
     
    80388025    break;
    80398026
    8040   case 562:
     8027  case 560:
    80418028
    80428029/* Line 1806 of yacc.c  */
     
    80458032    break;
    80468033
     8034  case 561:
     8035
     8036/* Line 1806 of yacc.c  */
     8037#line 2161 "parser.yy"
     8038    {}
     8039    break;
     8040
     8041  case 562:
     8042
     8043/* Line 1806 of yacc.c  */
     8044#line 2162 "parser.yy"
     8045    {}
     8046    break;
     8047
    80478048  case 563:
    80488049
    80498050/* Line 1806 of yacc.c  */
    8050 #line 2195 "parser.yy"
     8051#line 2197 "parser.yy"
    80518052    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80528053    break;
    80538054
    80548055  case 565:
    8055 
    8056 /* Line 1806 of yacc.c  */
    8057 #line 2198 "parser.yy"
    8058     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8059     break;
    8060 
    8061   case 566:
    80628056
    80638057/* Line 1806 of yacc.c  */
     
    80668060    break;
    80678061
     8062  case 566:
     8063
     8064/* Line 1806 of yacc.c  */
     8065#line 2202 "parser.yy"
     8066    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8067    break;
     8068
    80688069  case 567:
    80698070
    80708071/* Line 1806 of yacc.c  */
    8071 #line 2205 "parser.yy"
     8072#line 2207 "parser.yy"
    80728073    {
    80738074                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    80798080
    80808081/* Line 1806 of yacc.c  */
    8081 #line 2210 "parser.yy"
     8082#line 2212 "parser.yy"
    80828083    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80838084    break;
     
    80868087
    80878088/* Line 1806 of yacc.c  */
    8088 #line 2215 "parser.yy"
     8089#line 2217 "parser.yy"
    80898090    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    80908091    break;
     
    80938094
    80948095/* Line 1806 of yacc.c  */
    8095 #line 2217 "parser.yy"
     8096#line 2219 "parser.yy"
    80968097    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    80978098    break;
     
    81008101
    81018102/* Line 1806 of yacc.c  */
    8102 #line 2219 "parser.yy"
     8103#line 2221 "parser.yy"
    81038104    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81048105    break;
     
    81078108
    81088109/* Line 1806 of yacc.c  */
    8109 #line 2224 "parser.yy"
     8110#line 2226 "parser.yy"
    81108111    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    81118112    break;
    81128113
    81138114  case 573:
    8114 
    8115 /* Line 1806 of yacc.c  */
    8116 #line 2226 "parser.yy"
    8117     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8118     break;
    8119 
    8120   case 574:
    81218115
    81228116/* Line 1806 of yacc.c  */
     
    81258119    break;
    81268120
     8121  case 574:
     8122
     8123/* Line 1806 of yacc.c  */
     8124#line 2230 "parser.yy"
     8125    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8126    break;
     8127
    81278128  case 575:
    81288129
    81298130/* Line 1806 of yacc.c  */
    8130 #line 2230 "parser.yy"
     8131#line 2232 "parser.yy"
    81318132    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81328133    break;
     
    81358136
    81368137/* Line 1806 of yacc.c  */
    8137 #line 2235 "parser.yy"
     8138#line 2237 "parser.yy"
    81388139    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81398140    break;
     
    81428143
    81438144/* Line 1806 of yacc.c  */
    8144 #line 2237 "parser.yy"
     8145#line 2239 "parser.yy"
    81458146    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81468147    break;
     
    81498150
    81508151/* Line 1806 of yacc.c  */
    8151 #line 2246 "parser.yy"
     8152#line 2248 "parser.yy"
    81528153    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81538154    break;
     
    81568157
    81578158/* Line 1806 of yacc.c  */
    8158 #line 2249 "parser.yy"
     8159#line 2251 "parser.yy"
    81598160    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81608161    break;
     
    81638164
    81648165/* Line 1806 of yacc.c  */
    8165 #line 2254 "parser.yy"
     8166#line 2256 "parser.yy"
    81668167    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    81678168    break;
     
    81708171
    81718172/* Line 1806 of yacc.c  */
    8172 #line 2256 "parser.yy"
     8173#line 2258 "parser.yy"
    81738174    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81748175    break;
     
    81778178
    81788179/* Line 1806 of yacc.c  */
    8179 #line 2258 "parser.yy"
     8180#line 2260 "parser.yy"
    81808181    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81818182    break;
     
    81848185
    81858186/* Line 1806 of yacc.c  */
    8186 #line 2263 "parser.yy"
     8187#line 2265 "parser.yy"
    81878188    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    81888189    break;
     
    81918192
    81928193/* Line 1806 of yacc.c  */
    8193 #line 2265 "parser.yy"
     8194#line 2267 "parser.yy"
    81948195    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    81958196    break;
     
    81988199
    81998200/* Line 1806 of yacc.c  */
    8200 #line 2267 "parser.yy"
     8201#line 2269 "parser.yy"
    82018202    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82028203    break;
    82038204
    82048205  case 587:
    8205 
    8206 /* Line 1806 of yacc.c  */
    8207 #line 2272 "parser.yy"
    8208     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8209     break;
    8210 
    8211   case 588:
    82128206
    82138207/* Line 1806 of yacc.c  */
     
    82168210    break;
    82178211
     8212  case 588:
     8213
     8214/* Line 1806 of yacc.c  */
     8215#line 2276 "parser.yy"
     8216    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8217    break;
     8218
    82188219  case 589:
    82198220
    82208221/* Line 1806 of yacc.c  */
    8221 #line 2276 "parser.yy"
     8222#line 2278 "parser.yy"
    82228223    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82238224    break;
     
    82268227
    82278228/* Line 1806 of yacc.c  */
    8228 #line 2291 "parser.yy"
     8229#line 2293 "parser.yy"
    82298230    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    82308231    break;
     
    82338234
    82348235/* Line 1806 of yacc.c  */
    8235 #line 2293 "parser.yy"
     8236#line 2295 "parser.yy"
    82368237    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    82378238    break;
     
    82408241
    82418242/* Line 1806 of yacc.c  */
    8242 #line 2295 "parser.yy"
     8243#line 2297 "parser.yy"
    82438244    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82448245    break;
     
    82478248
    82488249/* Line 1806 of yacc.c  */
    8249 #line 2300 "parser.yy"
     8250#line 2302 "parser.yy"
    82508251    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    82518252    break;
     
    82548255
    82558256/* Line 1806 of yacc.c  */
    8256 #line 2302 "parser.yy"
     8257#line 2304 "parser.yy"
    82578258    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    82588259    break;
     
    82618262
    82628263/* Line 1806 of yacc.c  */
    8263 #line 2304 "parser.yy"
     8264#line 2306 "parser.yy"
    82648265    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82658266    break;
    82668267
    82678268  case 599:
    8268 
    8269 /* Line 1806 of yacc.c  */
    8270 #line 2309 "parser.yy"
    8271     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8272     break;
    8273 
    8274   case 600:
    82758269
    82768270/* Line 1806 of yacc.c  */
     
    82798273    break;
    82808274
     8275  case 600:
     8276
     8277/* Line 1806 of yacc.c  */
     8278#line 2313 "parser.yy"
     8279    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8280    break;
     8281
    82818282  case 601:
    82828283
    82838284/* Line 1806 of yacc.c  */
    8284 #line 2313 "parser.yy"
     8285#line 2315 "parser.yy"
    82858286    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82868287    break;
     
    82898290
    82908291/* Line 1806 of yacc.c  */
    8291 #line 2328 "parser.yy"
     8292#line 2330 "parser.yy"
    82928293    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82938294    break;
    82948295
    82958296  case 604:
    8296 
    8297 /* Line 1806 of yacc.c  */
    8298 #line 2331 "parser.yy"
    8299     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8300     break;
    8301 
    8302   case 605:
    83038297
    83048298/* Line 1806 of yacc.c  */
     
    83078301    break;
    83088302
     8303  case 605:
     8304
     8305/* Line 1806 of yacc.c  */
     8306#line 2335 "parser.yy"
     8307    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8308    break;
     8309
    83098310  case 607:
    83108311
    83118312/* Line 1806 of yacc.c  */
    8312 #line 2339 "parser.yy"
     8313#line 2341 "parser.yy"
    83138314    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83148315    break;
     
    83178318
    83188319/* Line 1806 of yacc.c  */
    8319 #line 2344 "parser.yy"
     8320#line 2346 "parser.yy"
    83208321    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    83218322    break;
     
    83248325
    83258326/* Line 1806 of yacc.c  */
    8326 #line 2346 "parser.yy"
     8327#line 2348 "parser.yy"
    83278328    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    83288329    break;
     
    83318332
    83328333/* Line 1806 of yacc.c  */
    8333 #line 2348 "parser.yy"
     8334#line 2350 "parser.yy"
    83348335    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83358336    break;
     
    83388339
    83398340/* Line 1806 of yacc.c  */
    8340 #line 2353 "parser.yy"
     8341#line 2355 "parser.yy"
    83418342    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    83428343    break;
    83438344
    83448345  case 612:
    8345 
    8346 /* Line 1806 of yacc.c  */
    8347 #line 2355 "parser.yy"
    8348     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8349     break;
    8350 
    8351   case 613:
    83528346
    83538347/* Line 1806 of yacc.c  */
     
    83568350    break;
    83578351
     8352  case 613:
     8353
     8354/* Line 1806 of yacc.c  */
     8355#line 2359 "parser.yy"
     8356    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8357    break;
     8358
    83588359  case 614:
    83598360
    83608361/* Line 1806 of yacc.c  */
    8361 #line 2359 "parser.yy"
     8362#line 2361 "parser.yy"
    83628363    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83638364    break;
     
    83668367
    83678368/* Line 1806 of yacc.c  */
    8368 #line 2364 "parser.yy"
     8369#line 2366 "parser.yy"
    83698370    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    83708371    break;
     
    83738374
    83748375/* Line 1806 of yacc.c  */
    8375 #line 2366 "parser.yy"
     8376#line 2368 "parser.yy"
    83768377    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83778378    break;
     
    83808381
    83818382/* Line 1806 of yacc.c  */
    8382 #line 2368 "parser.yy"
     8383#line 2370 "parser.yy"
    83838384    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83848385    break;
     
    83878388
    83888389/* Line 1806 of yacc.c  */
    8389 #line 2378 "parser.yy"
     8390#line 2380 "parser.yy"
    83908391    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83918392    break;
    83928393
    83938394  case 620:
    8394 
    8395 /* Line 1806 of yacc.c  */
    8396 #line 2381 "parser.yy"
    8397     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8398     break;
    8399 
    8400   case 621:
    84018395
    84028396/* Line 1806 of yacc.c  */
     
    84058399    break;
    84068400
     8401  case 621:
     8402
     8403/* Line 1806 of yacc.c  */
     8404#line 2385 "parser.yy"
     8405    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8406    break;
     8407
    84078408  case 622:
    84088409
    84098410/* Line 1806 of yacc.c  */
    8410 #line 2388 "parser.yy"
     8411#line 2390 "parser.yy"
    84118412    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    84128413    break;
     
    84158416
    84168417/* Line 1806 of yacc.c  */
    8417 #line 2390 "parser.yy"
     8418#line 2392 "parser.yy"
    84188419    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84198420    break;
     
    84228423
    84238424/* Line 1806 of yacc.c  */
    8424 #line 2392 "parser.yy"
     8425#line 2394 "parser.yy"
    84258426    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84268427    break;
     
    84298430
    84308431/* Line 1806 of yacc.c  */
    8431 #line 2397 "parser.yy"
     8432#line 2399 "parser.yy"
    84328433    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    84338434    break;
    84348435
    84358436  case 626:
    8436 
    8437 /* Line 1806 of yacc.c  */
    8438 #line 2399 "parser.yy"
    8439     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8440     break;
    8441 
    8442   case 627:
    84438437
    84448438/* Line 1806 of yacc.c  */
     
    84478441    break;
    84488442
     8443  case 627:
     8444
     8445/* Line 1806 of yacc.c  */
     8446#line 2403 "parser.yy"
     8447    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8448    break;
     8449
    84498450  case 628:
    84508451
    84518452/* Line 1806 of yacc.c  */
    8452 #line 2403 "parser.yy"
     8453#line 2405 "parser.yy"
    84538454    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84548455    break;
     
    84578458
    84588459/* Line 1806 of yacc.c  */
    8459 #line 2408 "parser.yy"
     8460#line 2410 "parser.yy"
    84608461    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    84618462    break;
     
    84648465
    84658466/* Line 1806 of yacc.c  */
    8466 #line 2410 "parser.yy"
     8467#line 2412 "parser.yy"
    84678468    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    84688469    break;
     
    84718472
    84728473/* Line 1806 of yacc.c  */
    8473 #line 2412 "parser.yy"
     8474#line 2414 "parser.yy"
    84748475    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84758476    break;
     
    84788479
    84798480/* Line 1806 of yacc.c  */
    8480 #line 2443 "parser.yy"
     8481#line 2445 "parser.yy"
    84818482    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84828483    break;
    84838484
    84848485  case 634:
    8485 
    8486 /* Line 1806 of yacc.c  */
    8487 #line 2446 "parser.yy"
    8488     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8489     break;
    8490 
    8491   case 635:
    84928486
    84938487/* Line 1806 of yacc.c  */
     
    84968490    break;
    84978491
     8492  case 635:
     8493
     8494/* Line 1806 of yacc.c  */
     8495#line 2450 "parser.yy"
     8496    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8497    break;
     8498
    84988499  case 636:
    84998500
    85008501/* Line 1806 of yacc.c  */
    8501 #line 2453 "parser.yy"
     8502#line 2455 "parser.yy"
    85028503    {
    85038504                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    85098510
    85108511/* Line 1806 of yacc.c  */
    8511 #line 2458 "parser.yy"
     8512#line 2460 "parser.yy"
    85128513    {
    85138514                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    85198520
    85208521/* Line 1806 of yacc.c  */
    8521 #line 2466 "parser.yy"
     8522#line 2468 "parser.yy"
    85228523    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    85238524    break;
     
    85268527
    85278528/* Line 1806 of yacc.c  */
    8528 #line 2468 "parser.yy"
     8529#line 2470 "parser.yy"
    85298530    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    85308531    break;
     
    85338534
    85348535/* Line 1806 of yacc.c  */
    8535 #line 2470 "parser.yy"
     8536#line 2472 "parser.yy"
    85368537    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85378538    break;
     
    85408541
    85418542/* Line 1806 of yacc.c  */
    8542 #line 2475 "parser.yy"
     8543#line 2477 "parser.yy"
    85438544    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    85448545    break;
     
    85478548
    85488549/* Line 1806 of yacc.c  */
    8549 #line 2477 "parser.yy"
     8550#line 2479 "parser.yy"
    85508551    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85518552    break;
     
    85548555
    85558556/* Line 1806 of yacc.c  */
    8556 #line 2482 "parser.yy"
     8557#line 2484 "parser.yy"
    85578558    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    85588559    break;
     
    85618562
    85628563/* Line 1806 of yacc.c  */
    8563 #line 2484 "parser.yy"
     8564#line 2486 "parser.yy"
    85648565    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85658566    break;
    85668567
    85678568  case 646:
    8568 
    8569 /* Line 1806 of yacc.c  */
    8570 #line 2499 "parser.yy"
    8571     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8572     break;
    8573 
    8574   case 647:
    85758569
    85768570/* Line 1806 of yacc.c  */
     
    85798573    break;
    85808574
     8575  case 647:
     8576
     8577/* Line 1806 of yacc.c  */
     8578#line 2503 "parser.yy"
     8579    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8580    break;
     8581
    85818582  case 648:
    85828583
    85838584/* Line 1806 of yacc.c  */
    8584 #line 2506 "parser.yy"
     8585#line 2508 "parser.yy"
    85858586    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    85868587    break;
     
    85898590
    85908591/* Line 1806 of yacc.c  */
    8591 #line 2508 "parser.yy"
     8592#line 2510 "parser.yy"
    85928593    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    85938594    break;
     
    85968597
    85978598/* Line 1806 of yacc.c  */
    8598 #line 2510 "parser.yy"
     8599#line 2512 "parser.yy"
    85998600    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    86008601    break;
     
    86038604
    86048605/* Line 1806 of yacc.c  */
    8605 #line 2512 "parser.yy"
     8606#line 2514 "parser.yy"
    86068607    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    86078608    break;
     
    86108611
    86118612/* Line 1806 of yacc.c  */
    8612 #line 2514 "parser.yy"
     8613#line 2516 "parser.yy"
    86138614    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86148615    break;
    86158616
    86168617  case 654:
    8617 
    8618 /* Line 1806 of yacc.c  */
    8619 #line 2520 "parser.yy"
    8620     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8621     break;
    8622 
    8623   case 655:
    86248618
    86258619/* Line 1806 of yacc.c  */
     
    86288622    break;
    86298623
     8624  case 655:
     8625
     8626/* Line 1806 of yacc.c  */
     8627#line 2524 "parser.yy"
     8628    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8629    break;
     8630
    86308631  case 656:
    86318632
    86328633/* Line 1806 of yacc.c  */
    8633 #line 2524 "parser.yy"
     8634#line 2526 "parser.yy"
    86348635    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86358636    break;
     
    86388639
    86398640/* Line 1806 of yacc.c  */
    8640 #line 2529 "parser.yy"
     8641#line 2531 "parser.yy"
    86418642    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    86428643    break;
     
    86458646
    86468647/* Line 1806 of yacc.c  */
    8647 #line 2531 "parser.yy"
     8648#line 2533 "parser.yy"
    86488649    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    86498650    break;
     
    86528653
    86538654/* Line 1806 of yacc.c  */
    8654 #line 2533 "parser.yy"
     8655#line 2535 "parser.yy"
    86558656    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86568657    break;
     
    86598660
    86608661/* Line 1806 of yacc.c  */
    8661 #line 2539 "parser.yy"
     8662#line 2541 "parser.yy"
    86628663    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    86638664    break;
     
    86668667
    86678668/* Line 1806 of yacc.c  */
    8668 #line 2541 "parser.yy"
     8669#line 2543 "parser.yy"
    86698670    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    86708671    break;
     
    86738674
    86748675/* Line 1806 of yacc.c  */
    8675 #line 2547 "parser.yy"
     8676#line 2549 "parser.yy"
    86768677    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    86778678    break;
     
    86808681
    86818682/* Line 1806 of yacc.c  */
    8682 #line 2549 "parser.yy"
     8683#line 2551 "parser.yy"
    86838684    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    86848685    break;
     
    86878688
    86888689/* Line 1806 of yacc.c  */
    8689 #line 2551 "parser.yy"
     8690#line 2553 "parser.yy"
    86908691    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    86918692    break;
     
    86948695
    86958696/* Line 1806 of yacc.c  */
    8696 #line 2553 "parser.yy"
     8697#line 2555 "parser.yy"
    86978698    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    86988699    break;
    86998700
    87008701  case 668:
    8701 
    8702 /* Line 1806 of yacc.c  */
    8703 #line 2568 "parser.yy"
    8704     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8705     break;
    8706 
    8707   case 669:
    87088702
    87098703/* Line 1806 of yacc.c  */
     
    87128706    break;
    87138707
     8708  case 669:
     8709
     8710/* Line 1806 of yacc.c  */
     8711#line 2572 "parser.yy"
     8712    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8713    break;
     8714
    87148715  case 670:
    87158716
    87168717/* Line 1806 of yacc.c  */
    8717 #line 2575 "parser.yy"
     8718#line 2577 "parser.yy"
    87188719    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    87198720    break;
     
    87228723
    87238724/* Line 1806 of yacc.c  */
    8724 #line 2577 "parser.yy"
     8725#line 2579 "parser.yy"
    87258726    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    87268727    break;
     
    87298730
    87308731/* Line 1806 of yacc.c  */
    8731 #line 2579 "parser.yy"
     8732#line 2581 "parser.yy"
    87328733    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    87338734    break;
     
    87368737
    87378738/* Line 1806 of yacc.c  */
    8738 #line 2581 "parser.yy"
     8739#line 2583 "parser.yy"
    87398740    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    87408741    break;
     
    87438744
    87448745/* Line 1806 of yacc.c  */
    8745 #line 2583 "parser.yy"
     8746#line 2585 "parser.yy"
    87468747    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87478748    break;
    87488749
    87498750  case 676:
    8750 
    8751 /* Line 1806 of yacc.c  */
    8752 #line 2589 "parser.yy"
    8753     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8754     break;
    8755 
    8756   case 677:
    87578751
    87588752/* Line 1806 of yacc.c  */
     
    87618755    break;
    87628756
     8757  case 677:
     8758
     8759/* Line 1806 of yacc.c  */
     8760#line 2593 "parser.yy"
     8761    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8762    break;
     8763
    87638764  case 678:
    87648765
    87658766/* Line 1806 of yacc.c  */
    8766 #line 2593 "parser.yy"
     8767#line 2595 "parser.yy"
    87678768    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87688769    break;
     
    87718772
    87728773/* Line 1806 of yacc.c  */
    8773 #line 2598 "parser.yy"
     8774#line 2600 "parser.yy"
    87748775    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    87758776    break;
     
    87788779
    87798780/* Line 1806 of yacc.c  */
    8780 #line 2600 "parser.yy"
     8781#line 2602 "parser.yy"
    87818782    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87828783    break;
     
    87858786
    87868787/* Line 1806 of yacc.c  */
    8787 #line 2602 "parser.yy"
     8788#line 2604 "parser.yy"
    87888789    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87898790    break;
     
    87928793
    87938794/* Line 1806 of yacc.c  */
    8794 #line 2609 "parser.yy"
     8795#line 2611 "parser.yy"
    87958796    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    87968797    break;
     
    87998800
    88008801/* Line 1806 of yacc.c  */
    8801 #line 2620 "parser.yy"
     8802#line 2622 "parser.yy"
    88028803    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    88038804    break;
     
    88068807
    88078808/* Line 1806 of yacc.c  */
    8808 #line 2623 "parser.yy"
     8809#line 2625 "parser.yy"
    88098810    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    88108811    break;
     
    88138814
    88148815/* Line 1806 of yacc.c  */
    8815 #line 2625 "parser.yy"
     8816#line 2627 "parser.yy"
    88168817    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    88178818    break;
     
    88208821
    88218822/* Line 1806 of yacc.c  */
    8822 #line 2628 "parser.yy"
     8823#line 2630 "parser.yy"
    88238824    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    88248825    break;
     
    88278828
    88288829/* Line 1806 of yacc.c  */
    8829 #line 2630 "parser.yy"
     8830#line 2632 "parser.yy"
    88308831    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    88318832    break;
     
    88348835
    88358836/* Line 1806 of yacc.c  */
    8836 #line 2632 "parser.yy"
     8837#line 2634 "parser.yy"
    88378838    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    88388839    break;
    88398840
    88408841  case 692:
    8841 
    8842 /* Line 1806 of yacc.c  */
    8843 #line 2646 "parser.yy"
    8844     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8845     break;
    8846 
    8847   case 693:
    88488842
    88498843/* Line 1806 of yacc.c  */
     
    88528846    break;
    88538847
     8848  case 693:
     8849
     8850/* Line 1806 of yacc.c  */
     8851#line 2650 "parser.yy"
     8852    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8853    break;
     8854
    88548855  case 694:
    88558856
    88568857/* Line 1806 of yacc.c  */
    8857 #line 2653 "parser.yy"
     8858#line 2655 "parser.yy"
    88588859    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    88598860    break;
     
    88628863
    88638864/* Line 1806 of yacc.c  */
    8864 #line 2655 "parser.yy"
     8865#line 2657 "parser.yy"
    88658866    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    88668867    break;
     
    88698870
    88708871/* Line 1806 of yacc.c  */
    8871 #line 2657 "parser.yy"
     8872#line 2659 "parser.yy"
    88728873    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    88738874    break;
     
    88768877
    88778878/* Line 1806 of yacc.c  */
    8878 #line 2659 "parser.yy"
     8879#line 2661 "parser.yy"
    88798880    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    88808881    break;
     
    88838884
    88848885/* Line 1806 of yacc.c  */
    8885 #line 2661 "parser.yy"
     8886#line 2663 "parser.yy"
    88868887    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88878888    break;
    88888889
    88898890  case 700:
    8890 
    8891 /* Line 1806 of yacc.c  */
    8892 #line 2667 "parser.yy"
    8893     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8894     break;
    8895 
    8896   case 701:
    88978891
    88988892/* Line 1806 of yacc.c  */
     
    89018895    break;
    89028896
     8897  case 701:
     8898
     8899/* Line 1806 of yacc.c  */
     8900#line 2671 "parser.yy"
     8901    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8902    break;
     8903
    89038904  case 702:
    89048905
    89058906/* Line 1806 of yacc.c  */
    8906 #line 2671 "parser.yy"
     8907#line 2673 "parser.yy"
    89078908    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89088909    break;
     
    89118912
    89128913/* Line 1806 of yacc.c  */
    8913 #line 2676 "parser.yy"
     8914#line 2678 "parser.yy"
    89148915    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    89158916    break;
     
    89188919
    89198920/* Line 1806 of yacc.c  */
    8920 #line 2678 "parser.yy"
     8921#line 2680 "parser.yy"
    89218922    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89228923    break;
     
    89258926
    89268927/* Line 1806 of yacc.c  */
    8927 #line 2688 "parser.yy"
     8928#line 2690 "parser.yy"
    89288929    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    89298930    break;
     
    89328933
    89338934/* Line 1806 of yacc.c  */
    8934 #line 2698 "parser.yy"
     8935#line 2700 "parser.yy"
    89358936    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89368937    break;
     
    89398940
    89408941/* Line 1806 of yacc.c  */
    8941 #line 2700 "parser.yy"
     8942#line 2702 "parser.yy"
    89428943    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89438944    break;
     
    89468947
    89478948/* Line 1806 of yacc.c  */
    8948 #line 2702 "parser.yy"
     8949#line 2704 "parser.yy"
    89498950    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89508951    break;
     
    89538954
    89548955/* Line 1806 of yacc.c  */
    8955 #line 2704 "parser.yy"
     8956#line 2706 "parser.yy"
    89568957    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89578958    break;
     
    89608961
    89618962/* Line 1806 of yacc.c  */
    8962 #line 2706 "parser.yy"
     8963#line 2708 "parser.yy"
    89638964    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89648965    break;
     
    89678968
    89688969/* Line 1806 of yacc.c  */
    8969 #line 2708 "parser.yy"
     8970#line 2710 "parser.yy"
    89708971    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89718972    break;
     
    89748975
    89758976/* Line 1806 of yacc.c  */
    8976 #line 2715 "parser.yy"
     8977#line 2717 "parser.yy"
    89778978    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89788979    break;
     
    89818982
    89828983/* Line 1806 of yacc.c  */
    8983 #line 2717 "parser.yy"
     8984#line 2719 "parser.yy"
    89848985    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    89858986    break;
     
    89888989
    89898990/* Line 1806 of yacc.c  */
    8990 #line 2719 "parser.yy"
     8991#line 2721 "parser.yy"
    89918992    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89928993    break;
     
    89958996
    89968997/* Line 1806 of yacc.c  */
    8997 #line 2721 "parser.yy"
     8998#line 2723 "parser.yy"
    89988999    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    89999000    break;
     
    90029003
    90039004/* Line 1806 of yacc.c  */
    9004 #line 2723 "parser.yy"
     9005#line 2725 "parser.yy"
    90059006    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90069007    break;
     
    90099010
    90109011/* Line 1806 of yacc.c  */
    9011 #line 2725 "parser.yy"
     9012#line 2727 "parser.yy"
    90129013    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    90139014    break;
     
    90169017
    90179018/* Line 1806 of yacc.c  */
    9018 #line 2727 "parser.yy"
     9019#line 2729 "parser.yy"
    90199020    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90209021    break;
     
    90239024
    90249025/* Line 1806 of yacc.c  */
    9025 #line 2729 "parser.yy"
     9026#line 2731 "parser.yy"
    90269027    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    90279028    break;
     
    90309031
    90319032/* Line 1806 of yacc.c  */
    9032 #line 2731 "parser.yy"
     9033#line 2733 "parser.yy"
    90339034    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    90349035    break;
     
    90379038
    90389039/* Line 1806 of yacc.c  */
    9039 #line 2733 "parser.yy"
     9040#line 2735 "parser.yy"
    90409041    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90419042    break;
     
    90449045
    90459046/* Line 1806 of yacc.c  */
    9046 #line 2738 "parser.yy"
     9047#line 2740 "parser.yy"
    90479048    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    90489049    break;
     
    90519052
    90529053/* Line 1806 of yacc.c  */
    9053 #line 2740 "parser.yy"
     9054#line 2742 "parser.yy"
    90549055    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    90559056    break;
     
    90589059
    90599060/* Line 1806 of yacc.c  */
    9060 #line 2745 "parser.yy"
     9061#line 2747 "parser.yy"
    90619062    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
    90629063    break;
     
    90659066
    90669067/* Line 1806 of yacc.c  */
    9067 #line 2747 "parser.yy"
     9068#line 2749 "parser.yy"
    90689069    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
    90699070    break;
     
    90729073
    90739074/* Line 1806 of yacc.c  */
    9074 #line 2774 "parser.yy"
     9075#line 2776 "parser.yy"
    90759076    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    90769077    break;
     
    90799080
    90809081/* Line 1806 of yacc.c  */
    9081 #line 2785 "parser.yy"
     9082#line 2787 "parser.yy"
    90829083    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    90839084    break;
     
    90869087
    90879088/* Line 1806 of yacc.c  */
    9088 #line 2787 "parser.yy"
     9089#line 2789 "parser.yy"
    90899090    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    90909091    break;
     
    90939094
    90949095/* Line 1806 of yacc.c  */
    9095 #line 2789 "parser.yy"
     9096#line 2791 "parser.yy"
    90969097    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    90979098    break;
     
    91009101
    91019102/* Line 1806 of yacc.c  */
    9102 #line 2791 "parser.yy"
     9103#line 2793 "parser.yy"
    91039104    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91049105    break;
     
    91079108
    91089109/* Line 1806 of yacc.c  */
    9109 #line 2793 "parser.yy"
     9110#line 2795 "parser.yy"
    91109111    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    91119112    break;
     
    91149115
    91159116/* Line 1806 of yacc.c  */
    9116 #line 2795 "parser.yy"
     9117#line 2797 "parser.yy"
    91179118    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    91189119    break;
     
    91219122
    91229123/* Line 1806 of yacc.c  */
    9123 #line 2802 "parser.yy"
     9124#line 2804 "parser.yy"
    91249125    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    91259126    break;
     
    91289129
    91299130/* Line 1806 of yacc.c  */
    9130 #line 2804 "parser.yy"
     9131#line 2806 "parser.yy"
    91319132    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    91329133    break;
     
    91359136
    91369137/* Line 1806 of yacc.c  */
    9137 #line 2806 "parser.yy"
     9138#line 2808 "parser.yy"
    91389139    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    91399140    break;
     
    91429143
    91439144/* Line 1806 of yacc.c  */
    9144 #line 2808 "parser.yy"
     9145#line 2810 "parser.yy"
    91459146    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    91469147    break;
     
    91499150
    91509151/* Line 1806 of yacc.c  */
    9151 #line 2810 "parser.yy"
     9152#line 2812 "parser.yy"
    91529153    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    91539154    break;
     
    91569157
    91579158/* Line 1806 of yacc.c  */
    9158 #line 2812 "parser.yy"
     9159#line 2814 "parser.yy"
    91599160    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    91609161    break;
     
    91639164
    91649165/* Line 1806 of yacc.c  */
    9165 #line 2817 "parser.yy"
     9166#line 2819 "parser.yy"
    91669167    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    91679168    break;
     
    91709171
    91719172/* Line 1806 of yacc.c  */
    9172 #line 2822 "parser.yy"
     9173#line 2824 "parser.yy"
    91739174    { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); }
    91749175    break;
    91759176
    91769177  case 749:
    9177 
    9178 /* Line 1806 of yacc.c  */
    9179 #line 2824 "parser.yy"
    9180     { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    9181     break;
    9182 
    9183   case 750:
    91849178
    91859179/* Line 1806 of yacc.c  */
     
    91889182    break;
    91899183
     9184  case 750:
     9185
     9186/* Line 1806 of yacc.c  */
     9187#line 2828 "parser.yy"
     9188    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
     9189    break;
     9190
    91909191  case 753:
    91919192
    91929193/* Line 1806 of yacc.c  */
    9193 #line 2850 "parser.yy"
     9194#line 2852 "parser.yy"
    91949195    { (yyval.en) = 0; }
    91959196    break;
     
    91989199
    91999200/* Line 1806 of yacc.c  */
    9200 #line 2852 "parser.yy"
     9201#line 2854 "parser.yy"
    92019202    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    92029203    break;
     
    92059206
    92069207/* Line 1806 of yacc.c  */
    9207 #line 9208 "Parser/parser.cc"
     9208#line 9209 "Parser/parser.cc"
    92089209      default: break;
    92099210    }
     
    94369437
    94379438/* Line 2067 of yacc.c  */
    9438 #line 2855 "parser.yy"
     9439#line 2857 "parser.yy"
    94399440
    94409441// ----end of grammar----
  • src/Parser/parser.h

    r71a3593 rd9e2280  
    274274        LabelNode *label;
    275275        InitializerNode *in;
    276         OperatorNode::Type op;
     276        OperKinds op;
    277277        bool flag;
    278278
  • src/Parser/parser.yy

    r71a3593 rd9e2280  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Aug  5 11:42:23 2016
    13 // Update Count     : 1749
     12// Last Modified On : Fri Aug  5 15:06:44 2016
     13// Update Count     : 1756
    1414//
    1515
     
    119119        LabelNode *label;
    120120        InitializerNode *in;
    121         OperatorNode::Type op;
     121        OperKinds op;
    122122        bool flag;
    123123}
     
    355355                // little advantage to this feature and many disadvantages. It is possible to write x[(i,j)] in CFA, which is
    356356                // equivalent to the old x[i,j].
    357                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::Index, $1, $4 ) ); }
     357                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Index, $1, $4 ) ); }
    358358        | postfix_expression '(' argument_expression_list ')'
    359                 { $$ = new CompositeExprNode2( build_func( $1, $3 ) ); }
     359                { $$ = new CompositeExprNode( build_func( $1, $3 ) ); }
    360360        // ambiguity with .0 so space required after field-selection, e.g.
    361361                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
    362362        | postfix_expression '.' no_attr_identifier
    363                 { $$ = new CompositeExprNode2( build_fieldSel( $1, new VarRefNode( $3 ) ) ); }
     363                { $$ = new CompositeExprNode( build_fieldSel( $1, new VarRefNode( $3 ) ) ); }
    364364        | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
    365365        | postfix_expression ARROW no_attr_identifier
    366                 { $$ = new CompositeExprNode2( build_pfieldSel( $1, new VarRefNode( $3 ) ) ); }
     366                { $$ = new CompositeExprNode( build_pfieldSel( $1, new VarRefNode( $3 ) ) ); }
    367367        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
    368368        | postfix_expression ICR
    369                 { $$ = new CompositeExprNode2( build_unary_ptr( OperatorNode::IncrPost, $1 ) ); }
     369                { $$ = new CompositeExprNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
    370370        | postfix_expression DECR
    371                 { $$ = new CompositeExprNode2( build_unary_ptr( OperatorNode::DecrPost, $1 ) ); }
     371                { $$ = new CompositeExprNode( build_unary_ptr( OperKinds::DecrPost, $1 ) ); }
    372372        | '(' type_name_no_function ')' '{' initializer_list comma_opt '}' // C99
    373373                { $$ = new CompoundLiteralNode( $2, new InitializerNode( $5, true ) ); }
     
    376376                        Token fn;
    377377                        fn.str = new std::string( "?{}" ); // location undefined
    378                         $$ = new CompositeExprNode2( build_func( new VarRefNode( fn ), (ExpressionNode *)( $1 )->set_link( $3 ) ) );
     378                        $$ = new CompositeExprNode( build_func( new VarRefNode( fn ), (ExpressionNode *)( $1 )->set_link( $3 ) ) );
    379379                }
    380380        ;
     
    398398                { $$ = $7->set_argName( $3 ); }
    399399        | '[' push assignment_expression ',' tuple_expression_list pop ']' ':' assignment_expression
    400                 { $$ = $9->set_argName( new CompositeExprNode2( build_tuple( (ExpressionNode *)$3->set_link( $5 ) ) ) ); }
     400                { $$ = $9->set_argName( new CompositeExprNode( build_tuple( (ExpressionNode *)$3->set_link( $5 ) ) ) ); }
    401401        ;
    402402
     
    412412                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
    413413        | no_attr_identifier '.' field
    414                 { $$ = new CompositeExprNode2( build_fieldSel( $3, new VarRefNode( $1 ) ) ); }
     414                { $$ = new CompositeExprNode( build_fieldSel( $3, new VarRefNode( $1 ) ) ); }
    415415        | no_attr_identifier '.' '[' push field_list pop ']'
    416                 { $$ = new CompositeExprNode2( build_fieldSel( $5, new VarRefNode( $1 ) ) ); }
     416                { $$ = new CompositeExprNode( build_fieldSel( $5, new VarRefNode( $1 ) ) ); }
    417417        | no_attr_identifier ARROW field
    418                 { $$ = new CompositeExprNode2( build_pfieldSel( $3, new VarRefNode( $1 ) ) ); }
     418                { $$ = new CompositeExprNode( build_pfieldSel( $3, new VarRefNode( $1 ) ) ); }
    419419        | no_attr_identifier ARROW '[' push field_list pop ']'
    420                 { $$ = new CompositeExprNode2( build_pfieldSel( $5, new VarRefNode( $1 ) ) ); }
     420                { $$ = new CompositeExprNode( build_pfieldSel( $5, new VarRefNode( $1 ) ) ); }
    421421        ;
    422422
     
    437437                {
    438438                        switch ( $1 ) {
    439                           case OperatorNode::AddressOf:
    440                                 $$ = new CompositeExprNode2( build_addressOf( $2 ) );
     439                          case OperKinds::AddressOf:
     440                                $$ = new CompositeExprNode( build_addressOf( $2 ) );
    441441                                break;
    442                           case OperatorNode::PointTo:
    443                                 $$ = new CompositeExprNode2( build_unary_val( $1, $2 ) );
     442                          case OperKinds::PointTo:
     443                                $$ = new CompositeExprNode( build_unary_val( $1, $2 ) );
    444444                                break;
    445445                          default:
     
    448448                }
    449449        | unary_operator cast_expression
    450                         { $$ = new CompositeExprNode2( build_unary_val( $1, $2 ) ); }
     450                        { $$ = new CompositeExprNode( build_unary_val( $1, $2 ) ); }
    451451        | ICR unary_expression
    452                 { $$ = new CompositeExprNode2( build_unary_ptr( OperatorNode::Incr, $2 ) ); }
     452                { $$ = new CompositeExprNode( build_unary_ptr( OperKinds::Incr, $2 ) ); }
    453453        | DECR unary_expression
    454                 { $$ = new CompositeExprNode2( build_unary_ptr( OperatorNode::Decr, $2 ) ); }
     454                { $$ = new CompositeExprNode( build_unary_ptr( OperKinds::Decr, $2 ) ); }
    455455        | SIZEOF unary_expression
    456                 { $$ = new CompositeExprNode2( build_sizeOf( $2 ) ); }
     456                { $$ = new CompositeExprNode( build_sizeOf( $2 ) ); }
    457457        | SIZEOF '(' type_name_no_function ')'
    458                 { $$ = new CompositeExprNode2( build_sizeOf( new TypeValueNode( $3 ) ) ); }
     458                { $$ = new CompositeExprNode( build_sizeOf( new TypeValueNode( $3 ) ) ); }
    459459        | OFFSETOF '(' type_name_no_function ',' no_attr_identifier ')'
    460                 { $$ = new CompositeExprNode2( build_offsetOf( new TypeValueNode( $3 ), new VarRefNode( $5 ) ) ); }
     460                { $$ = new CompositeExprNode( build_offsetOf( new TypeValueNode( $3 ), new VarRefNode( $5 ) ) ); }
    461461        | ATTR_IDENTIFIER
    462                 { $$ = new CompositeExprNode2( build_attr( new VarRefNode( $1 ) ) ); }
     462                { $$ = new CompositeExprNode( build_attr( new VarRefNode( $1 ) ) ); }
    463463        | ATTR_IDENTIFIER '(' type_name ')'
    464                 { $$ = new CompositeExprNode2( build_attr( new VarRefNode( $1 ), new TypeValueNode( $3 ) ) ); }
     464                { $$ = new CompositeExprNode( build_attr( new VarRefNode( $1 ), new TypeValueNode( $3 ) ) ); }
    465465        | ATTR_IDENTIFIER '(' argument_expression ')'
    466                 { $$ = new CompositeExprNode2( build_attr( new VarRefNode( $1 ), $3 ) ); }
     466                { $$ = new CompositeExprNode( build_attr( new VarRefNode( $1 ), $3 ) ); }
    467467        | ALIGNOF unary_expression                                                      // GCC, variable alignment
    468                 { $$ = new CompositeExprNode2( build_alignOf( $2 ) ); }
     468                { $$ = new CompositeExprNode( build_alignOf( $2 ) ); }
    469469        | ALIGNOF '(' type_name_no_function ')'                         // GCC, type alignment
    470                 { $$ = new CompositeExprNode2( build_alignOf( new TypeValueNode( $3 ) ) ); }
     470                { $$ = new CompositeExprNode( build_alignOf( new TypeValueNode( $3 ) ) ); }
    471471//      | ANDAND IDENTIFIER                                                                     // GCC, address of label
    472 //              { $$ = new CompositeExprNode( new OperatorNode( OperatorNode::LabelAddress ), new VarRefNode( $2, true ) ); }
     472//              { $$ = new CompositeExprNode( new OperatorNode( OperKinds::LabelAddress ), new VarRefNode( $2, true ) ); }
    473473        ;
    474474
    475475ptrref_operator:
    476         '*'                                                                                     { $$ = OperatorNode::PointTo; }
    477         | '&'                                                                           { $$ = OperatorNode::AddressOf; }
     476        '*'                                                                                     { $$ = OperKinds::PointTo; }
     477        | '&'                                                                           { $$ = OperKinds::AddressOf; }
    478478                // GCC, address of label must be handled by semantic check for ref,ref,label
    479 //      | ANDAND                                                                        { $$ = OperatorNode::And; }
     479//      | ANDAND                                                                        { $$ = OperKinds::And; }
    480480        ;
    481481
    482482unary_operator:
    483         '+'                                                                                     { $$ = OperatorNode::UnPlus; }
    484         | '-'                                                                           { $$ = OperatorNode::UnMinus; }
    485         | '!'                                                                           { $$ = OperatorNode::Neg; }
    486         | '~'                                                                           { $$ = OperatorNode::BitNeg; }
     483        '+'                                                                                     { $$ = OperKinds::UnPlus; }
     484        | '-'                                                                           { $$ = OperKinds::UnMinus; }
     485        | '!'                                                                           { $$ = OperKinds::Neg; }
     486        | '~'                                                                           { $$ = OperKinds::BitNeg; }
    487487        ;
    488488
     
    490490        unary_expression
    491491        | '(' type_name_no_function ')' cast_expression
    492                 { $$ = new CompositeExprNode2( build_cast( new TypeValueNode( $2 ), $4 ) ); }
     492                { $$ = new CompositeExprNode( build_cast( new TypeValueNode( $2 ), $4 ) ); }
    493493        | '(' type_name_no_function ')' tuple
    494                 { $$ = new CompositeExprNode2( build_cast( new TypeValueNode( $2 ), $4 ) ); }
     494                { $$ = new CompositeExprNode( build_cast( new TypeValueNode( $2 ), $4 ) ); }
    495495        ;
    496496
     
    498498        cast_expression
    499499        | multiplicative_expression '*' cast_expression
    500                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::Mul, $1, $3 ) ); }
     500                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Mul, $1, $3 ) ); }
    501501        | multiplicative_expression '/' cast_expression
    502                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::Div, $1, $3 ) ); }
     502                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Div, $1, $3 ) ); }
    503503        | multiplicative_expression '%' cast_expression
    504                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::Mod, $1, $3 ) ); }
     504                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Mod, $1, $3 ) ); }
    505505        ;
    506506
     
    508508        multiplicative_expression
    509509        | additive_expression '+' multiplicative_expression
    510                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::Plus, $1, $3 ) ); }
     510                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Plus, $1, $3 ) ); }
    511511        | additive_expression '-' multiplicative_expression
    512                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::Minus, $1, $3 ) ); }
     512                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Minus, $1, $3 ) ); }
    513513        ;
    514514
     
    516516        additive_expression
    517517        | shift_expression LS additive_expression
    518                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::LShift, $1, $3 ) ); }
     518                { $$ = new CompositeExprNode( build_binary_val( OperKinds::LShift, $1, $3 ) ); }
    519519        | shift_expression RS additive_expression
    520                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::RShift, $1, $3 ) ); }
     520                { $$ = new CompositeExprNode( build_binary_val( OperKinds::RShift, $1, $3 ) ); }
    521521        ;
    522522
     
    524524        shift_expression
    525525        | relational_expression '<' shift_expression
    526                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::LThan, $1, $3 ) ); }
     526                { $$ = new CompositeExprNode( build_binary_val( OperKinds::LThan, $1, $3 ) ); }
    527527        | relational_expression '>' shift_expression
    528                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::GThan, $1, $3 ) ); }
     528                { $$ = new CompositeExprNode( build_binary_val( OperKinds::GThan, $1, $3 ) ); }
    529529        | relational_expression LE shift_expression
    530                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::LEThan, $1, $3 ) ); }
     530                { $$ = new CompositeExprNode( build_binary_val( OperKinds::LEThan, $1, $3 ) ); }
    531531        | relational_expression GE shift_expression
    532                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::GEThan, $1, $3 ) ); }
     532                { $$ = new CompositeExprNode( build_binary_val( OperKinds::GEThan, $1, $3 ) ); }
    533533        ;
    534534
     
    536536        relational_expression
    537537        | equality_expression EQ relational_expression
    538                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::Eq, $1, $3 ) ); }
     538                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Eq, $1, $3 ) ); }
    539539        | equality_expression NE relational_expression
    540                 { $$ = new CompositeExprNode2( build_binary_val( OperatorNode::Neq, $1, $3 ) ); }
     540                { $$ = new CompositeExprNode( build_binary_val( OperKinds::Neq, $1, $3 ) ); }
    541541        ;
    542542
     
    544544        equality_expression
    545545        | AND_expression '&' equality_ex