Changeset c1c1112


Ignore:
Timestamp:
Aug 25, 2016, 9:14:06 PM (6 years ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
4e2b9710
Parents:
2acf5fc
Message:

fix segment fault when printing syntax error, more refactoring of parser code

Location:
src
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • src/Parser/DeclarationNode.cc

    r2acf5fc rc1c1112  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 18 23:48:23 2016
    13 // Update Count     : 182
     12// Last Modified On : Thu Aug 25 20:42:25 2016
     13// Update Count     : 232
    1414//
    1515
     
    9393        } // if
    9494
    95         if(storageClass != NoStorageClass) os << DeclarationNode::storageName[storageClass] << ' ';
    96         if(isInline) os << DeclarationNode::storageName[Inline] << ' ';
    97         if(isNoreturn) os << DeclarationNode::storageName[Noreturn] << ' ';
     95        if ( storageClass != NoStorageClass ) os << DeclarationNode::storageName[storageClass] << ' ';
     96        if ( isInline ) os << DeclarationNode::storageName[Inline] << ' ';
     97        if ( isNoreturn ) os << DeclarationNode::storageName[Noreturn] << ' ';
    9898        if ( type ) {
    9999                type->print( os, indent );
     
    147147} // DeclarationNode::newFunction
    148148
    149 DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) {
     149DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) {
    150150        DeclarationNode *newnode = new DeclarationNode;
    151151        newnode->type = new TypeData();
    152         newnode->type->qualifiers.push_back( q );
     152        newnode->type->qualifiers[ q ] = 1;
    153153        return newnode;
    154154} // DeclarationNode::newQualifier
    155155
    156 DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
    157         DeclarationNode *newnode = new DeclarationNode;
    158         switch (sc) {
    159                 case Inline: newnode->isInline = true; break;
    160                 case Noreturn: newnode->isNoreturn = true; break;
    161                 default: newnode->storageClass = sc; break;
    162         }
     156DeclarationNode * DeclarationNode::newForall( DeclarationNode *forall ) {
     157        DeclarationNode *newnode = new DeclarationNode;
     158        newnode->type = new TypeData( TypeData::Unknown );
     159        newnode->type->forall = forall;
     160        return newnode;
     161} // DeclarationNode::newForall
     162
     163DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
     164        DeclarationNode *newnode = new DeclarationNode;
     165        //switch (sc) {
     166        //      case Inline: newnode->isInline = true; break;
     167        //      case Noreturn: newnode->isNoreturn = true; break;
     168        //      default: newnode->storageClass = sc; break;
     169        //}
     170        newnode->storageClass = sc;
    163171        return newnode;
    164172} // DeclarationNode::newStorageClass
    165173
    166 DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) {
     174DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
    167175        DeclarationNode *newnode = new DeclarationNode;
    168176        newnode->type = new TypeData( TypeData::Basic );
     
    171179} // DeclarationNode::newBasicType
    172180
    173 DeclarationNode *DeclarationNode::newBuiltinType( BuiltinType bt ) {
     181DeclarationNode * DeclarationNode::newModifier( Modifier mod ) {
     182        DeclarationNode *newnode = new DeclarationNode;
     183        newnode->type = new TypeData( TypeData::Basic );
     184        newnode->type->basic->modifiers.push_back( mod );
     185        return newnode;
     186} // DeclarationNode::newModifier
     187
     188DeclarationNode * DeclarationNode::newBuiltinType( BuiltinType bt ) {
    174189        DeclarationNode *newnode = new DeclarationNode;
    175190        newnode->type = new TypeData( TypeData::Builtin );
     
    178193} // DeclarationNode::newBuiltinType
    179194
    180 DeclarationNode *DeclarationNode::newModifier( Modifier mod ) {
    181         DeclarationNode *newnode = new DeclarationNode;
    182         newnode->type = new TypeData( TypeData::Basic );
    183         newnode->type->basic->modifiers.push_back( mod );
    184         return newnode;
    185 } // DeclarationNode::newModifier
    186 
    187 DeclarationNode *DeclarationNode::newForall( DeclarationNode *forall ) {
    188         DeclarationNode *newnode = new DeclarationNode;
    189         newnode->type = new TypeData( TypeData::Unknown );
    190         newnode->type->forall = forall;
    191         return newnode;
    192 } // DeclarationNode::newForall
    193 
    194 DeclarationNode *DeclarationNode::newFromTypedef( std::string *name ) {
     195DeclarationNode * DeclarationNode::newFromTypedef( std::string *name ) {
    195196        DeclarationNode *newnode = new DeclarationNode;
    196197        newnode->type = new TypeData( TypeData::SymbolicInst );
     
    201202} // DeclarationNode::newFromTypedef
    202203
    203 DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ) {
     204DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ) {
    204205        DeclarationNode *newnode = new DeclarationNode;
    205206        newnode->type = new TypeData( TypeData::Aggregate );
     
    369370                        src = 0;
    370371                } else {
    371                         dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
    372                 } // if
    373         } // if
    374 }
     372                        dst->qualifiers |= src->qualifiers;
     373                } // if
     374        } // if
     375}
     376
     377void DeclarationNode::checkQualifiers( TypeData *src, TypeData *dst ) {
     378        TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers;
     379
     380        if ( (qsrc & qdst).any() ) {                                            // common bits between qualifier masks ?
     381                error = "duplicate qualifier ";
     382                int j = 0;                                                                              // separator detector
     383                for ( int i = 0; i < DeclarationNode::NoOfQualifier; i += 1 ) {
     384                        if ( qsrc[i] & qdst[i] ) {                                      // find specific qualifiers in common
     385                                if ( j > 0 ) error += ", ";
     386                                error += DeclarationNode::qualifierName[i];
     387                                j += 1;
     388                        } // if
     389                } // for
     390                error += " in declaration of ";
     391        } // if
     392} // DeclarationNode::checkQualifiers
    375393
    376394DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
     
    380398                        if ( ! type ) {
    381399                                type = new TypeData;
     400                        } else {
     401                                checkQualifiers( q->type, type );
    382402                        } // if
    383403                        addQualifiersToType( q->type, type );
     
    405425        isInline = isInline || q->isInline;
    406426        isNoreturn = isNoreturn || q->isNoreturn;
    407         if(storageClass == NoStorageClass) {
     427        if ( storageClass == NoStorageClass ) {
    408428                storageClass = q->storageClass;
    409         }
    410         else if (q->storageClass != NoStorageClass) {
     429        } else if ( q->storageClass != NoStorageClass ) {
    411430                q->error = "invalid combination of storage classes in declaration of ";
    412         }
    413         if(error.empty()) error = q->error;
     431        } // if
     432        if ( error.empty() ) error = q->error;
    414433        return this;
    415434}
     
    430449                        switch ( dst->kind ) {
    431450                          case TypeData::Unknown:
    432                                 src->qualifiers.splice( src->qualifiers.end(), dst->qualifiers );
     451                                src->qualifiers |= dst->qualifiers;
    433452                                dst = src;
    434453                                src = 0;
    435454                                break;
    436455                          case TypeData::Basic:
    437                                 dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
     456                                dst->qualifiers |= src->qualifiers;
    438457                                if ( src->kind != TypeData::Unknown ) {
    439458                                        assert( src->kind == TypeData::Basic );
     
    451470                                                dst->base->aggInst->params = maybeClone( src->aggregate->actuals );
    452471                                        } // if
    453                                         dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers );
     472                                        dst->base->qualifiers |= src->qualifiers;
    454473                                        src = 0;
    455474                                        break;
     
    480499                                                type->aggInst->params = maybeClone( o->type->aggregate->actuals );
    481500                                        } // if
    482                                         type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers );
     501                                        type->qualifiers |= o->type->qualifiers;
    483502                                } else {
    484503                                        type = o->type;
     
    615634                                        p->type->base->aggInst->params = maybeClone( type->aggregate->actuals );
    616635                                } // if
    617                                 p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers );
     636                                p->type->base->qualifiers |= type->qualifiers;
    618637                                break;
    619638
     
    652671                                        lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals );
    653672                                } // if
    654                                 lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers );
     673                                lastArray->base->qualifiers |= type->qualifiers;
    655674                                break;
    656675                          default:
     
    874893
    875894Declaration *DeclarationNode::build() const {
    876         if( !error.empty() ) throw SemanticError( error, this );
     895        if ( ! error.empty() ) throw SemanticError( error, this );
    877896        if ( type ) {
    878897                return type->buildDecl( name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
  • src/Parser/ParseNode.h

    r2acf5fc rc1c1112  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Aug 21 11:53:59 2016
    13 // Update Count     : 546
     12// Last Modified On : Thu Aug 25 21:00:08 2016
     13// Update Count     : 563
    1414//
    1515
     
    9999        InitializerNode *kids;
    100100        bool maybeConstructed;
    101 };
     101}; // InitializerNode
    102102
    103103//##############################################################################
     
    126126        bool extension = false;
    127127        std::unique_ptr<Expression> expr;
    128 };
     128}; // ExpressionNode
    129129
    130130template< typename T >
     
    150150        UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress,
    151151        Ctor, Dtor,
    152 };
     152}; // OperKinds
    153153
    154154struct LabelNode {
     
    196196class DeclarationNode : public ParseNode {
    197197  public:
    198         enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic };
     198        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoOfQualifier };
    199199        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
    200200        enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
     
    204204        enum BuiltinType { Valist };
    205205
     206        static const char *qualifierName[];
    206207        static const char *storageName[];
    207         static const char *qualifierName[];
    208208        static const char *basicTypeName[];
    209209        static const char *modifierName[];
     
    214214        static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param, StatementNode *body, bool newStyle = false );
    215215        static DeclarationNode *newQualifier( Qualifier );
     216        static DeclarationNode *newForall( DeclarationNode *);
    216217        static DeclarationNode *newStorageClass( StorageClass );
    217218        static DeclarationNode *newBasicType( BasicType );
    218219        static DeclarationNode *newModifier( Modifier );
    219         static DeclarationNode *newForall( DeclarationNode *);
     220        static DeclarationNode *newBuiltinType( BuiltinType );
    220221        static DeclarationNode *newFromTypedef( std::string *);
    221222        static DeclarationNode *newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body );
     
    236237        static DeclarationNode *newAttr( std::string *, ExpressionNode *expr );
    237238        static DeclarationNode *newAttr( std::string *, DeclarationNode *type );
    238         static DeclarationNode *newBuiltinType( BuiltinType );
    239239
    240240        DeclarationNode();
     
    243243
    244244        DeclarationNode *addQualifiers( DeclarationNode *);
     245        void checkQualifiers( TypeData *, TypeData * );
    245246        DeclarationNode *copyStorageClasses( DeclarationNode *);
    246247        DeclarationNode *addType( DeclarationNode *);
     
    285286        bool get_extension() const { return extension; }
    286287        DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
    287   private:
     288  public:
    288289        // StorageClass buildStorageClass() const;
    289290        // bool buildFuncSpecifier( StorageClass key ) const;
  • src/Parser/TypeData.cc

    r2acf5fc rc1c1112  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 18 23:48:44 2016
    13 // Update Count     : 64
     12// Last Modified On : Wed Aug 24 13:46:55 2016
     13// Update Count     : 69
    1414//
    1515
     
    244244        using std::string;
    245245
    246         printEnums( qualifiers.begin(), qualifiers.end(), DeclarationNode::qualifierName, os );
     246        for ( int i = 0; i < DeclarationNode::NoOfQualifier; i += 1 ) {
     247                if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' ';
     248        } // for
    247249
    248250        if ( forall ) {
     
    425427                if ( ! toplevel && aggregate->fields ) {
    426428                        ret = clone();
    427                         ret->qualifiers.clear();
     429//                      ret->qualifiers.reset();
    428430                } // if
    429431                break;
     
    431433                if ( ! toplevel && enumeration->constants ) {
    432434                        ret = clone();
    433                         ret->qualifiers.clear();
     435//                      ret->qualifiers.reset();
    434436                } // if
    435437                break;
     
    554556Type::Qualifiers TypeData::buildQualifiers() const {
    555557        Type::Qualifiers q;
    556         for ( std::list< DeclarationNode::Qualifier >::const_iterator i = qualifiers.begin(); i != qualifiers.end(); ++i ) {
    557                 switch ( *i ) {
    558                   case DeclarationNode::Const:
    559                         q.isConst = true;
    560                         break;
    561                   case DeclarationNode::Volatile:
    562                         q.isVolatile = true;
    563                         break;
    564                   case DeclarationNode::Restrict:
    565                         q.isRestrict = true;
    566                         break;
    567                   case DeclarationNode::Lvalue:
    568                         q.isLvalue = true;
    569                         break;
    570                   case DeclarationNode::Atomic:
    571                         q.isAtomic = true;
    572                         break;
    573                 } // switch
    574         } // for
     558        q.isConst = qualifiers[ DeclarationNode::Const ];
     559        q.isVolatile = qualifiers[ DeclarationNode::Volatile ];
     560        q.isRestrict = qualifiers[ DeclarationNode::Restrict ];
     561        q.isLvalue = qualifiers[ DeclarationNode::Lvalue ];
     562        q.isAtomic = qualifiers[ DeclarationNode::Atomic ];;
    575563        return q;
    576564}
  • src/Parser/TypeData.h

    r2acf5fc rc1c1112  
    1010// Created On       : Sat May 16 15:18:36 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 18 23:48:52 2016
    13 // Update Count     : 22
     12// Last Modified On : Thu Aug 25 17:34:06 2016
     13// Update Count     : 26
    1414//
    1515
     
    1717#define TYPEDATA_H
    1818
    19 #include <list>
     19#include <bitset>
    2020
    2121#include "ParseNode.h"
     
    3535
    3636        TypeData * base;
    37         std::list< DeclarationNode::Qualifier > qualifiers;
     37        typedef std::bitset< DeclarationNode::NoOfQualifier > Qualifiers;
     38        Qualifiers qualifiers;
    3839        DeclarationNode * forall;
    3940
  • src/Parser/lex.cc

    r2acf5fc rc1c1112  
    14691469 * Created On       : Sat Sep 22 08:58:10 2001
    14701470 * Last Modified By : Peter A. Buhr
    1471  * Last Modified On : Thu Aug 18 22:17:30 2016
    1472  * Update Count     : 472
     1471 * Last Modified On : Wed Aug 24 13:27:04 2016
     1472 * Update Count     : 487
    14731473 */
    14741474#line 20 "lex.ll"
     
    18271827{
    18281828        /* " stop highlighting */
    1829         static char *filename[FILENAME_MAX];                            // temporarily store current source-file name
     1829        static char filename[FILENAME_MAX];                                     // temporarily store current source-file name
    18301830        char *end_num;
    18311831        char *begin_string, *end_string;
     
    18421842                //std::cout << "file " << filename << " line " << lineno << std::endl;
    18431843                yylineno = lineno;
    1844                 yyfilename = filename[0];
     1844                yyfilename = filename;
    18451845        } // if
    18461846}
     
    24262426YY_RULE_SETUP
    24272427#line 290 "lex.ll"
    2428 { BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
     2428{ BEGIN QUOTE; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
    24292429        YY_BREAK
    24302430case 116:
    24312431YY_RULE_SETUP
    24322432#line 291 "lex.ll"
    2433 { *strtext += std::string( yytext ); }
     2433{ strtext->append( yytext, yyleng ); }
    24342434        YY_BREAK
    24352435case 117:
     
    24372437YY_RULE_SETUP
    24382438#line 292 "lex.ll"
    2439 { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
     2439{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
    24402440        YY_BREAK
    24412441/* ' stop highlighting */
     
    24442444YY_RULE_SETUP
    24452445#line 296 "lex.ll"
    2446 { BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
     2446{ BEGIN STRING; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
    24472447        YY_BREAK
    24482448case 119:
    24492449YY_RULE_SETUP
    24502450#line 297 "lex.ll"
    2451 { *strtext += std::string( yytext ); }
     2451{ strtext->append( yytext, yyleng ); }
    24522452        YY_BREAK
    24532453case 120:
     
    24552455YY_RULE_SETUP
    24562456#line 298 "lex.ll"
    2457 { BEGIN 0; *strtext += std::string( yytext ); RETURN_STR(STRINGliteral); }
     2457{ BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
    24582458        YY_BREAK
    24592459/* " stop highlighting */
     
    24622462YY_RULE_SETUP
    24632463#line 302 "lex.ll"
    2464 { rm_underscore(); *strtext += std::string( yytext ); }
     2464{ rm_underscore(); strtext->append( yytext, yyleng ); }
    24652465        YY_BREAK
    24662466case 122:
     
    24732473YY_RULE_SETUP
    24742474#line 304 "lex.ll"
    2475 { *strtext += std::string( yytext ); } // unknown escape character
     2475{ strtext->append( yytext, yyleng ); } // unknown escape character
    24762476        YY_BREAK
    24772477/* punctuation */
  • src/Parser/lex.ll

    r2acf5fc rc1c1112  
    1010 * Created On       : Sat Sep 22 08:58:10 2001
    1111 * Last Modified By : Peter A. Buhr
    12  * Last Modified On : Thu Aug 18 22:17:30 2016
    13  * Update Count     : 472
     12 * Last Modified On : Wed Aug 24 13:27:04 2016
     13 * Update Count     : 487
    1414 */
    1515
     
    141141^{h_white}*"#"{h_white}*[0-9]+{h_white}*["][^"\n]+["].*"\n" {
    142142        /* " stop highlighting */
    143         static char *filename[FILENAME_MAX];                            // temporarily store current source-file name
     143        static char filename[FILENAME_MAX];                                     // temporarily store current source-file name
    144144        char *end_num;
    145145        char *begin_string, *end_string;
     
    156156                //std::cout << "file " << filename << " line " << lineno << std::endl;
    157157                yylineno = lineno;
    158                 yyfilename = filename[0];
     158                yyfilename = filename;
    159159        } // if
    160160}
     
    288288
    289289                                /* character constant, allows empty value */
    290 ({cwide_prefix}[_]?)?['] { BEGIN QUOTE; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
    291 <QUOTE>[^'\\\n]* { *strtext += std::string( yytext ); }
    292 <QUOTE>['\n]    { BEGIN 0; *strtext += std::string( yytext); RETURN_STR(CHARACTERconstant); }
     290({cwide_prefix}[_]?)?['] { BEGIN QUOTE; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
     291<QUOTE>[^'\\\n]* { strtext->append( yytext, yyleng ); }
     292<QUOTE>['\n]    { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(CHARACTERconstant); }
    293293                                /* ' stop highlighting */
    294294
    295295                                /* string constant */
    296 ({swide_prefix}[_]?)?["] { BEGIN STRING; rm_underscore(); strtext = new std::string; *strtext += std::string( yytext ); }
    297 <STRING>[^"\\\n]* { *strtext += std::string( yytext ); }
    298 <STRING>["\n]   { BEGIN 0; *strtext += std::string( yytext ); RETURN_STR(STRINGliteral); }
     296({swide_prefix}[_]?)?["] { BEGIN STRING; rm_underscore(); strtext = new std::string( yytext, yyleng ); }
     297<STRING>[^"\\\n]* { strtext->append( yytext, yyleng ); }
     298<STRING>["\n]   { BEGIN 0; strtext->append( yytext, yyleng ); RETURN_STR(STRINGliteral); }
    299299                                /* " stop highlighting */
    300300
    301301                                /* common character/string constant */
    302 <QUOTE,STRING>{escape_seq} { rm_underscore(); *strtext += std::string( yytext ); }
     302<QUOTE,STRING>{escape_seq} { rm_underscore(); strtext->append( yytext, yyleng ); }
    303303<QUOTE,STRING>"\\"{h_white}*"\n" {}                                             // continuation (ALSO HANDLED BY CPP)
    304 <QUOTE,STRING>"\\" { *strtext += std::string( yytext ); } // unknown escape character
     304<QUOTE,STRING>"\\" { strtext->append( yytext, yyleng ); } // unknown escape character
    305305
    306306                                /* punctuation */
  • src/Parser/parser.cc

    r2acf5fc rc1c1112  
    8383#include "LinkageSpec.h"
    8484
    85 union DeclQualifiers {
    86         unsigned int value;                                                                     // assume 32-bits
    87         struct {
    88                 bool Extern : 1;
    89                 bool Static : 1;
    90                 bool Auto : 1;
    91                 bool Register : 1;
    92                 bool Inline : 1;
    93                 bool Fortran : 1;
    94                 bool Noreturn : 1;
    95                 bool Threadlocal : 1;
    96                 bool Extension : 1;
    97                 bool Lvalue : 1;
    98                 bool Const : 1;
    99                 bool Volatile : 1;
    100                 bool Restrict : 1;
    101                 bool Atomic : 1;
    102         } qual;
    103 }; // DeclQualifiers
    104 DeclQualifiers declQualifiers = { 0 };
    105 
    106 union DeclType {
    107         unsigned int value;                                                                     // assume 32-bits
    108         struct {
    109                 bool Char : 1;
    110                 bool Bool : 1;
    111                 bool Short : 1;
    112                 bool Int : 1;
    113                 bool Float : 1;
    114                 bool Double : 1;
    115                 bool Long : 1;
    116                 bool Signed : 1;
    117                 bool Unsigned : 1;
    118                 bool Void : 1;
    119                 bool Complex : 1;
    120                 bool Imaginary : 1;
    121                 bool Valist : 1;
    122         } type;
    123 }; // DeclType
    124 DeclType declTypes = { 0 };
    125 
    12685extern DeclarationNode * parseTree;
    12786extern LinkageSpec::Spec linkage;
     
    13796
    13897/* Line 268 of yacc.c  */
    139 #line 140 "Parser/parser.cc"
     98#line 99 "Parser/parser.cc"
    14099
    141100/* Enabling traces.  */
     
    388347
    389348/* Line 293 of yacc.c  */
    390 #line 156 "parser.yy"
     349#line 115 "parser.yy"
    391350
    392351        Token tok;
     
    408367
    409368/* Line 293 of yacc.c  */
    410 #line 411 "Parser/parser.cc"
     369#line 370 "Parser/parser.cc"
    411370} YYSTYPE;
    412371# define YYSTYPE_IS_TRIVIAL 1
     
    420379
    421380/* Line 343 of yacc.c  */
    422 #line 423 "Parser/parser.cc"
     381#line 382 "Parser/parser.cc"
    423382
    424383#ifdef short
     
    10621021static const yytype_uint16 yyrline[] =
    10631022{
    1064        0,   341,   341,   345,   352,   353,   354,   358,   359,   360,
    1065      364,   365,   369,   370,   374,   375,   379,   383,   384,   395,
    1066      397,   399,   401,   406,   407,   413,   417,   419,   420,   422,
    1067      423,   425,   427,   429,   438,   439,   445,   446,   450,   451,
    1068      455,   459,   461,   463,   465,   470,   473,   475,   477,   482,
    1069      495,   497,   499,   501,   503,   505,   507,   509,   511,   513,
    1070      515,   522,   523,   529,   530,   531,   532,   536,   537,   539,
    1071      544,   545,   547,   549,   554,   555,   557,   562,   563,   565,
    1072      570,   571,   573,   575,   577,   582,   583,   585,   590,   591,
    1073      596,   597,   602,   603,   608,   609,   614,   615,   620,   621,
    1074      624,   626,   631,   636,   637,   639,   645,   646,   650,   651,
    1075      652,   653,   654,   655,   656,   657,   658,   659,   660,   666,
    1076      668,   670,   672,   677,   678,   683,   684,   690,   691,   697,
    1077      698,   699,   700,   701,   702,   703,   704,   705,   715,   722,
    1078      724,   734,   735,   740,   742,   748,   750,   754,   755,   760,
    1079      765,   768,   770,   772,   782,   784,   795,   796,   798,   802,
    1080      804,   808,   809,   814,   815,   819,   824,   825,   829,   831,
    1081      837,   838,   842,   844,   846,   848,   854,   855,   859,   861,
    1082      866,   868,   870,   875,   877,   882,   884,   888,   891,   895,
    1083      898,   902,   904,   906,   908,   913,   915,   917,   922,   924,
    1084      926,   928,   930,   935,   937,   939,   941,   946,   958,   959,
    1085      964,   966,   971,   975,   977,   979,   981,   983,   989,   990,
    1086      996,   997,  1001,  1002,  1007,  1009,  1015,  1016,  1018,  1023,
    1087     1028,  1038,  1040,  1044,  1045,  1050,  1052,  1056,  1057,  1061,
    1088     1063,  1067,  1068,  1072,  1073,  1077,  1078,  1093,  1094,  1095,
    1089     1096,  1097,  1101,  1106,  1113,  1123,  1128,  1133,  1141,  1146,
    1090     1151,  1156,  1161,  1169,  1191,  1196,  1203,  1205,  1212,  1217,
    1091     1222,  1233,  1238,  1243,  1248,  1253,  1262,  1267,  1275,  1276,
    1092     1277,  1278,  1284,  1289,  1297,  1298,  1299,  1300,  1304,  1305,
    1093     1306,  1307,  1312,  1313,  1322,  1323,  1328,  1329,  1334,  1336,
    1094     1338,  1340,  1342,  1345,  1344,  1356,  1357,  1359,  1369,  1370,
    1095     1375,  1377,  1379,  1381,  1383,  1385,  1387,  1389,  1394,  1396,
    1096     1398,  1400,  1402,  1404,  1406,  1408,  1410,  1412,  1414,  1416,
    1097     1418,  1424,  1425,  1427,  1429,  1431,  1436,  1437,  1443,  1444,
    1098     1446,  1448,  1453,  1455,  1457,  1459,  1464,  1465,  1467,  1469,
    1099     1474,  1475,  1477,  1482,  1483,  1485,  1487,  1492,  1494,  1496,
    1100     1501,  1502,  1506,  1508,  1514,  1513,  1517,  1519,  1524,  1526,
    1101     1532,  1533,  1538,  1539,  1541,  1542,  1551,  1552,  1554,  1556,
    1102     1561,  1563,  1569,  1570,  1572,  1575,  1578,  1583,  1584,  1589,
    1103     1594,  1598,  1600,  1606,  1605,  1612,  1614,  1620,  1621,  1629,
    1104     1630,  1634,  1635,  1636,  1638,  1640,  1647,  1648,  1650,  1652,
    1105     1657,  1658,  1664,  1665,  1669,  1670,  1675,  1676,  1677,  1679,
    1106     1687,  1688,  1690,  1693,  1695,  1699,  1700,  1701,  1703,  1705,
    1107     1709,  1714,  1722,  1723,  1732,  1734,  1739,  1740,  1741,  1745,
    1108     1746,  1747,  1751,  1752,  1753,  1757,  1758,  1759,  1764,  1765,
    1109     1766,  1767,  1773,  1774,  1776,  1781,  1782,  1787,  1788,  1789,
    1110     1790,  1791,  1806,  1807,  1812,  1813,  1819,  1821,  1824,  1826,
    1111     1828,  1851,  1852,  1854,  1856,  1861,  1862,  1864,  1869,  1874,
    1112     1875,  1881,  1880,  1884,  1888,  1890,  1892,  1898,  1899,  1904,
    1113     1909,  1911,  1916,  1918,  1919,  1921,  1926,  1928,  1930,  1935,
    1114     1937,  1942,  1947,  1955,  1961,  1960,  1974,  1975,  1980,  1981,
    1115     1985,  1990,  1995,  2003,  2008,  2019,  2020,  2025,  2026,  2032,
    1116     2033,  2037,  2038,  2039,  2042,  2041,  2052,  2061,  2067,  2073,
    1117     2082,  2088,  2094,  2100,  2106,  2114,  2120,  2128,  2134,  2143,
    1118     2144,  2145,  2149,  2153,  2155,  2161,  2162,  2166,  2167,  2172,
    1119     2178,  2179,  2182,  2184,  2185,  2190,  2191,  2192,  2193,  2227,
    1120     2229,  2230,  2232,  2237,  2242,  2247,  2249,  2251,  2256,  2258,
    1121     2260,  2262,  2267,  2269,  2278,  2280,  2281,  2286,  2288,  2290,
    1122     2295,  2297,  2299,  2304,  2306,  2308,  2317,  2318,  2319,  2323,
    1123     2325,  2327,  2332,  2334,  2336,  2341,  2343,  2345,  2360,  2362,
    1124     2363,  2365,  2370,  2371,  2376,  2378,  2380,  2385,  2387,  2389,
    1125     2391,  2396,  2398,  2400,  2410,  2412,  2413,  2415,  2420,  2422,
    1126     2424,  2429,  2431,  2433,  2435,  2440,  2442,  2444,  2475,  2477,
    1127     2478,  2480,  2485,  2490,  2498,  2500,  2502,  2507,  2509,  2514,
    1128     2516,  2530,  2531,  2533,  2538,  2540,  2542,  2544,  2546,  2551,
    1129     2552,  2554,  2556,  2561,  2563,  2565,  2571,  2573,  2575,  2579,
    1130     2581,  2583,  2585,  2599,  2600,  2602,  2607,  2609,  2611,  2613,
    1131     2615,  2620,  2621,  2623,  2625,  2630,  2632,  2634,  2640,  2641,
    1132     2643,  2652,  2655,  2657,  2660,  2662,  2664,  2677,  2678,  2680,
    1133     2685,  2687,  2689,  2691,  2693,  2698,  2699,  2701,  2703,  2708,
    1134     2710,  2718,  2719,  2720,  2725,  2726,  2730,  2732,  2734,  2736,
    1135     2738,  2740,  2747,  2749,  2751,  2753,  2755,  2757,  2759,  2761,
    1136     2763,  2765,  2770,  2772,  2774,  2779,  2805,  2806,  2808,  2812,
    1137     2813,  2817,  2819,  2821,  2823,  2825,  2827,  2834,  2836,  2838,
    1138     2840,  2842,  2844,  2849,  2854,  2856,  2858,  2876,  2878,  2883,
    1139     2884
     1023       0,   300,   300,   304,   311,   312,   313,   317,   318,   319,
     1024     323,   324,   328,   329,   333,   334,   338,   342,   343,   354,
     1025     356,   358,   360,   365,   366,   372,   376,   378,   379,   381,
     1026     382,   384,   386,   388,   397,   398,   404,   405,   409,   410,
     1027     414,   418,   420,   422,   424,   429,   432,   434,   436,   441,
     1028     454,   456,   458,   460,   462,   464,   466,   468,   470,   472,
     1029     474,   481,   482,   488,   489,   490,   491,   495,   496,   498,
     1030     503,   504,   506,   508,   513,   514,   516,   521,   522,   524,
     1031     529,   530,   532,   534,   536,   541,   542,   544,   549,   550,
     1032     555,   556,   561,   562,   567,   568,   573,   574,   579,   580,
     1033     583,   585,   590,   595,   596,   598,   604,   605,   609,   610,
     1034     611,   612,   613,   614,   615,   616,   617,   618,   619,   625,
     1035     627,   629,   631,   636,   637,   642,   643,   649,   650,   656,
     1036     657,   658,   659,   660,   661,   662,   663,   664,   674,   681,
     1037     683,   693,   694,   699,   701,   707,   709,   713,   714,   719,
     1038     724,   727,   729,   731,   741,   743,   754,   755,   757,   761,
     1039     763,   767,   768,   773,   774,   778,   783,   784,   788,   790,
     1040     796,   797,   801,   803,   805,   807,   813,   814,   818,   820,
     1041     825,   827,   829,   834,   836,   841,   843,   847,   850,   854,
     1042     857,   861,   863,   865,   867,   872,   874,   876,   881,   883,
     1043     885,   887,   889,   894,   896,   898,   900,   905,   917,   918,
     1044     923,   925,   930,   934,   936,   938,   940,   942,   948,   949,
     1045     955,   956,   960,   961,   966,   968,   974,   975,   977,   982,
     1046     987,   997,   999,  1003,  1004,  1009,  1011,  1015,  1016,  1020,
     1047    1022,  1026,  1027,  1031,  1032,  1036,  1037,  1052,  1053,  1054,
     1048    1055,  1056,  1060,  1065,  1072,  1082,  1087,  1092,  1100,  1105,
     1049    1110,  1115,  1120,  1128,  1150,  1155,  1162,  1164,  1171,  1176,
     1050    1181,  1192,  1197,  1202,  1207,  1212,  1221,  1226,  1234,  1235,
     1051    1236,  1237,  1243,  1248,  1256,  1257,  1258,  1259,  1263,  1264,
     1052    1265,  1266,  1271,  1272,  1281,  1282,  1287,  1288,  1293,  1295,
     1053    1297,  1299,  1301,  1304,  1303,  1315,  1316,  1318,  1328,  1329,
     1054    1334,  1336,  1338,  1340,  1342,  1345,  1347,  1350,  1355,  1357,
     1055    1359,  1361,  1363,  1365,  1367,  1369,  1371,  1373,  1375,  1377,
     1056    1379,  1385,  1386,  1388,  1390,  1392,  1397,  1398,  1404,  1405,
     1057    1407,  1409,  1414,  1416,  1418,  1420,  1425,  1426,  1428,  1430,
     1058    1435,  1436,  1438,  1443,  1444,  1446,  1448,  1453,  1455,  1457,
     1059    1462,  1463,  1467,  1469,  1475,  1474,  1478,  1480,  1485,  1487,
     1060    1493,  1494,  1499,  1500,  1502,  1503,  1512,  1513,  1515,  1517,
     1061    1522,  1524,  1530,  1531,  1533,  1536,  1539,  1544,  1545,  1550,
     1062    1555,  1559,  1561,  1567,  1566,  1573,  1575,  1581,  1582,  1590,
     1063    1591,  1595,  1596,  1597,  1599,  1601,  1608,  1609,  1611,  1613,
     1064    1618,  1619,  1625,  1626,  1630,  1631,  1636,  1637,  1638,  1640,
     1065    1648,  1649,  1651,  1654,  1656,  1660,  1661,  1662,  1664,  1666,
     1066    1670,  1675,  1683,  1684,  1693,  1695,  1700,  1701,  1702,  1706,
     1067    1707,  1708,  1712,  1713,  1714,  1718,  1719,  1720,  1725,  1726,
     1068    1727,  1728,  1734,  1735,  1737,  1742,  1743,  1748,  1749,  1750,
     1069    1751,  1752,  1767,  1768,  1773,  1774,  1780,  1782,  1785,  1787,
     1070    1789,  1812,  1813,  1815,  1817,  1822,  1823,  1825,  1830,  1835,
     1071    1836,  1842,  1841,  1845,  1849,  1851,  1853,  1859,  1860,  1865,
     1072    1870,  1872,  1877,  1879,  1880,  1882,  1887,  1889,  1891,  1896,
     1073    1898,  1903,  1908,  1916,  1922,  1921,  1935,  1936,  1941,  1942,
     1074    1946,  1951,  1956,  1964,  1969,  1980,  1981,  1986,  1987,  1993,
     1075    1994,  1998,  1999,  2000,  2003,  2002,  2013,  2022,  2028,  2034,
     1076    2043,  2049,  2055,  2061,  2067,  2075,  2081,  2089,  2095,  2104,
     1077    2105,  2106,  2110,  2114,  2116,  2121,  2122,  2126,  2127,  2132,
     1078    2138,  2139,  2142,  2144,  2145,  2149,  2150,  2151,  2152,  2186,
     1079    2188,  2189,  2191,  2196,  2201,  2206,  2208,  2210,  2215,  2217,
     1080    2219,  2221,  2226,  2228,  2237,  2239,  2240,  2245,  2247,  2249,
     1081    2254,  2256,  2258,  2263,  2265,  2267,  2276,  2277,  2278,  2282,
     1082    2284,  2286,  2291,  2293,  2295,  2300,  2302,  2304,  2319,  2321,
     1083    2322,  2324,  2329,  2330,  2335,  2337,  2339,  2344,  2346,  2348,
     1084    2350,  2355,  2357,  2359,  2369,  2371,  2372,  2374,  2379,  2381,
     1085    2383,  2388,  2390,  2392,  2394,  2399,  2401,  2403,  2434,  2436,
     1086    2437,  2439,  2444,  2449,  2457,  2459,  2461,  2466,  2468,  2473,
     1087    2475,  2489,  2490,  2492,  2497,  2499,  2501,  2503,  2505,  2510,
     1088    2511,  2513,  2515,  2520,  2522,  2524,  2530,  2532,  2534,  2538,
     1089    2540,  2542,  2544,  2558,  2559,  2561,  2566,  2568,  2570,  2572,
     1090    2574,  2579,  2580,  2582,  2584,  2589,  2591,  2593,  2599,  2600,
     1091    2602,  2611,  2614,  2616,  2619,  2621,  2623,  2636,  2637,  2639,
     1092    2644,  2646,  2648,  2650,  2652,  2657,  2658,  2660,  2662,  2667,
     1093    2669,  2677,  2678,  2679,  2684,  2685,  2689,  2691,  2693,  2695,
     1094    2697,  2699,  2706,  2708,  2710,  2712,  2714,  2716,  2718,  2720,
     1095    2722,  2724,  2729,  2731,  2733,  2738,  2764,  2765,  2767,  2771,
     1096    2772,  2776,  2778,  2780,  2782,  2784,  2786,  2793,  2795,  2797,
     1097    2799,  2801,  2803,  2808,  2813,  2815,  2817,  2835,  2837,  2842,
     1098    2843
    11401099};
    11411100#endif
     
    50084967
    50094968/* Line 1806 of yacc.c  */
    5010 #line 341 "parser.yy"
     4969#line 300 "parser.yy"
    50114970    { typedefTable.enterScope(); }
    50124971    break;
     
    50154974
    50164975/* Line 1806 of yacc.c  */
    5017 #line 345 "parser.yy"
     4976#line 304 "parser.yy"
    50184977    { typedefTable.leaveScope(); }
    50194978    break;
     
    50224981
    50234982/* Line 1806 of yacc.c  */
    5024 #line 352 "parser.yy"
     4983#line 311 "parser.yy"
    50254984    { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
    50264985    break;
     
    50294988
    50304989/* Line 1806 of yacc.c  */
    5031 #line 353 "parser.yy"
     4990#line 312 "parser.yy"
    50324991    { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
    50334992    break;
     
    50364995
    50374996/* Line 1806 of yacc.c  */
    5038 #line 354 "parser.yy"
     4997#line 313 "parser.yy"
    50394998    { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); }
    50404999    break;
     
    50435002
    50445003/* Line 1806 of yacc.c  */
    5045 #line 379 "parser.yy"
     5004#line 338 "parser.yy"
    50465005    { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].str) ); }
    50475006    break;
     
    50505009
    50515010/* Line 1806 of yacc.c  */
    5052 #line 383 "parser.yy"
     5011#line 342 "parser.yy"
    50535012    { (yyval.str) = (yyvsp[(1) - (1)].tok); }
    50545013    break;
     
    50575016
    50585017/* Line 1806 of yacc.c  */
    5059 #line 385 "parser.yy"
     5018#line 344 "parser.yy"
    50605019    {
    50615020                        appendStr( (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].tok) );                                            // append 2nd juxtaposed string to 1st
     
    50685027
    50695028/* Line 1806 of yacc.c  */
    5070 #line 396 "parser.yy"
     5029#line 355 "parser.yy"
    50715030    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    50725031    break;
     
    50755034
    50765035/* Line 1806 of yacc.c  */
    5077 #line 398 "parser.yy"
     5036#line 357 "parser.yy"
    50785037    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    50795038    break;
     
    50825041
    50835042/* Line 1806 of yacc.c  */
    5084 #line 400 "parser.yy"
     5043#line 359 "parser.yy"
    50855044    { (yyval.en) = (yyvsp[(2) - (3)].en); }
    50865045    break;
     
    50895048
    50905049/* Line 1806 of yacc.c  */
    5091 #line 402 "parser.yy"
     5050#line 361 "parser.yy"
    50925051    { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); }
    50935052    break;
     
    50965055
    50975056/* Line 1806 of yacc.c  */
    5098 #line 412 "parser.yy"
     5057#line 371 "parser.yy"
    50995058    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
    51005059    break;
     
    51035062
    51045063/* Line 1806 of yacc.c  */
    5105 #line 414 "parser.yy"
     5064#line 373 "parser.yy"
    51065065    { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
    51075066    break;
     
    51105069
    51115070/* Line 1806 of yacc.c  */
    5112 #line 418 "parser.yy"
     5071#line 377 "parser.yy"
    51135072    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
    51145073    break;
     
    51175076
    51185077/* Line 1806 of yacc.c  */
    5119 #line 421 "parser.yy"
     5078#line 380 "parser.yy"
    51205079    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
    51215080    break;
     
    51245083
    51255084/* Line 1806 of yacc.c  */
    5126 #line 424 "parser.yy"
     5085#line 383 "parser.yy"
    51275086    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
    51285087    break;
     
    51315090
    51325091/* Line 1806 of yacc.c  */
    5133 #line 426 "parser.yy"
     5092#line 385 "parser.yy"
    51345093    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
    51355094    break;
     
    51385097
    51395098/* Line 1806 of yacc.c  */
    5140 #line 428 "parser.yy"
     5099#line 387 "parser.yy"
    51415100    { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
    51425101    break;
     
    51455104
    51465105/* Line 1806 of yacc.c  */
    5147 #line 430 "parser.yy"
     5106#line 389 "parser.yy"
    51485107    {
    51495108                        Token fn;
     
    51565115
    51575116/* Line 1806 of yacc.c  */
    5158 #line 440 "parser.yy"
     5117#line 399 "parser.yy"
    51595118    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
    51605119    break;
     
    51635122
    51645123/* Line 1806 of yacc.c  */
    5165 #line 445 "parser.yy"
     5124#line 404 "parser.yy"
    51665125    { (yyval.en) = 0; }
    51675126    break;
     
    51705129
    51715130/* Line 1806 of yacc.c  */
    5172 #line 451 "parser.yy"
     5131#line 410 "parser.yy"
    51735132    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    51745133    break;
     
    51775136
    51785137/* Line 1806 of yacc.c  */
    5179 #line 456 "parser.yy"
     5138#line 415 "parser.yy"
    51805139    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    51815140    break;
     
    51845143
    51855144/* Line 1806 of yacc.c  */
    5186 #line 460 "parser.yy"
     5145#line 419 "parser.yy"
    51875146    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
    51885147    break;
     
    51915150
    51925151/* Line 1806 of yacc.c  */
    5193 #line 462 "parser.yy"
     5152#line 421 "parser.yy"
    51945153    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
    51955154    break;
     
    51985157
    51995158/* Line 1806 of yacc.c  */
    5200 #line 464 "parser.yy"
     5159#line 423 "parser.yy"
    52015160    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
    52025161    break;
     
    52055164
    52065165/* Line 1806 of yacc.c  */
    5207 #line 466 "parser.yy"
     5166#line 425 "parser.yy"
    52085167    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
    52095168    break;
     
    52125171
    52135172/* Line 1806 of yacc.c  */
    5214 #line 474 "parser.yy"
     5173#line 433 "parser.yy"
    52155174    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    52165175    break;
     
    52195178
    52205179/* Line 1806 of yacc.c  */
    5221 #line 476 "parser.yy"
     5180#line 435 "parser.yy"
    52225181    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    52235182    break;
     
    52265185
    52275186/* Line 1806 of yacc.c  */
    5228 #line 478 "parser.yy"
     5187#line 437 "parser.yy"
    52295188    { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
    52305189    break;
     
    52335192
    52345193/* Line 1806 of yacc.c  */
    5235 #line 483 "parser.yy"
     5194#line 442 "parser.yy"
    52365195    {
    52375196                        switch ( (yyvsp[(1) - (2)].op) ) {
     
    52515210
    52525211/* Line 1806 of yacc.c  */
    5253 #line 496 "parser.yy"
     5212#line 455 "parser.yy"
    52545213    { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
    52555214    break;
     
    52585217
    52595218/* Line 1806 of yacc.c  */
    5260 #line 498 "parser.yy"
     5219#line 457 "parser.yy"
    52615220    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
    52625221    break;
     
    52655224
    52665225/* Line 1806 of yacc.c  */
    5267 #line 500 "parser.yy"
     5226#line 459 "parser.yy"
    52685227    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
    52695228    break;
     
    52725231
    52735232/* Line 1806 of yacc.c  */
    5274 #line 502 "parser.yy"
     5233#line 461 "parser.yy"
    52755234    { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    52765235    break;
     
    52795238
    52805239/* Line 1806 of yacc.c  */
    5281 #line 504 "parser.yy"
     5240#line 463 "parser.yy"
    52825241    { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52835242    break;
     
    52865245
    52875246/* Line 1806 of yacc.c  */
    5288 #line 506 "parser.yy"
     5247#line 465 "parser.yy"
    52895248    { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    52905249    break;
     
    52935252
    52945253/* Line 1806 of yacc.c  */
    5295 #line 508 "parser.yy"
     5254#line 467 "parser.yy"
    52965255    { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52975256    break;
     
    53005259
    53015260/* Line 1806 of yacc.c  */
    5302 #line 510 "parser.yy"
     5261#line 469 "parser.yy"
    53035262    { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
    53045263    break;
     
    53075266
    53085267/* Line 1806 of yacc.c  */
    5309 #line 512 "parser.yy"
     5268#line 471 "parser.yy"
    53105269    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
    53115270    break;
     
    53145273
    53155274/* Line 1806 of yacc.c  */
    5316 #line 514 "parser.yy"
     5275#line 473 "parser.yy"
    53175276    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
    53185277    break;
     
    53215280
    53225281/* Line 1806 of yacc.c  */
    5323 #line 516 "parser.yy"
     5282#line 475 "parser.yy"
    53245283    { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
    53255284    break;
     
    53285287
    53295288/* Line 1806 of yacc.c  */
    5330 #line 522 "parser.yy"
     5289#line 481 "parser.yy"
    53315290    { (yyval.op) = OperKinds::PointTo; }
    53325291    break;
     
    53355294
    53365295/* Line 1806 of yacc.c  */
     5296#line 482 "parser.yy"
     5297    { (yyval.op) = OperKinds::AddressOf; }
     5298    break;
     5299
     5300  case 63:
     5301
     5302/* Line 1806 of yacc.c  */
     5303#line 488 "parser.yy"
     5304    { (yyval.op) = OperKinds::UnPlus; }
     5305    break;
     5306
     5307  case 64:
     5308
     5309/* Line 1806 of yacc.c  */
     5310#line 489 "parser.yy"
     5311    { (yyval.op) = OperKinds::UnMinus; }
     5312    break;
     5313
     5314  case 65:
     5315
     5316/* Line 1806 of yacc.c  */
     5317#line 490 "parser.yy"
     5318    { (yyval.op) = OperKinds::Neg; }
     5319    break;
     5320
     5321  case 66:
     5322
     5323/* Line 1806 of yacc.c  */
     5324#line 491 "parser.yy"
     5325    { (yyval.op) = OperKinds::BitNeg; }
     5326    break;
     5327
     5328  case 68:
     5329
     5330/* Line 1806 of yacc.c  */
     5331#line 497 "parser.yy"
     5332    { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
     5333    break;
     5334
     5335  case 69:
     5336
     5337/* Line 1806 of yacc.c  */
     5338#line 499 "parser.yy"
     5339    { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
     5340    break;
     5341
     5342  case 71:
     5343
     5344/* Line 1806 of yacc.c  */
     5345#line 505 "parser.yy"
     5346    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5347    break;
     5348
     5349  case 72:
     5350
     5351/* Line 1806 of yacc.c  */
     5352#line 507 "parser.yy"
     5353    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5354    break;
     5355
     5356  case 73:
     5357
     5358/* Line 1806 of yacc.c  */
     5359#line 509 "parser.yy"
     5360    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5361    break;
     5362
     5363  case 75:
     5364
     5365/* Line 1806 of yacc.c  */
     5366#line 515 "parser.yy"
     5367    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5368    break;
     5369
     5370  case 76:
     5371
     5372/* Line 1806 of yacc.c  */
     5373#line 517 "parser.yy"
     5374    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5375    break;
     5376
     5377  case 78:
     5378
     5379/* Line 1806 of yacc.c  */
    53375380#line 523 "parser.yy"
    5338     { (yyval.op) = OperKinds::AddressOf; }
    5339     break;
    5340 
    5341   case 63:
    5342 
    5343 /* Line 1806 of yacc.c  */
    5344 #line 529 "parser.yy"
    5345     { (yyval.op) = OperKinds::UnPlus; }
    5346     break;
    5347 
    5348   case 64:
    5349 
    5350 /* Line 1806 of yacc.c  */
    5351 #line 530 "parser.yy"
    5352     { (yyval.op) = OperKinds::UnMinus; }
    5353     break;
    5354 
    5355   case 65:
     5381    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5382    break;
     5383
     5384  case 79:
     5385
     5386/* Line 1806 of yacc.c  */
     5387#line 525 "parser.yy"
     5388    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5389    break;
     5390
     5391  case 81:
    53565392
    53575393/* Line 1806 of yacc.c  */
    53585394#line 531 "parser.yy"
    5359     { (yyval.op) = OperKinds::Neg; }
    5360     break;
    5361 
    5362   case 66:
    5363 
    5364 /* Line 1806 of yacc.c  */
    5365 #line 532 "parser.yy"
    5366     { (yyval.op) = OperKinds::BitNeg; }
    5367     break;
    5368 
    5369   case 68:
    5370 
    5371 /* Line 1806 of yacc.c  */
    5372 #line 538 "parser.yy"
    5373     { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
    5374     break;
    5375 
    5376   case 69:
    5377 
    5378 /* Line 1806 of yacc.c  */
    5379 #line 540 "parser.yy"
    5380     { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
    5381     break;
    5382 
    5383   case 71:
    5384 
    5385 /* Line 1806 of yacc.c  */
    5386 #line 546 "parser.yy"
    5387     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5388     break;
    5389 
    5390   case 72:
    5391 
    5392 /* Line 1806 of yacc.c  */
    5393 #line 548 "parser.yy"
    5394     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5395     break;
    5396 
    5397   case 73:
    5398 
    5399 /* Line 1806 of yacc.c  */
    5400 #line 550 "parser.yy"
    5401     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5402     break;
    5403 
    5404   case 75:
    5405 
    5406 /* Line 1806 of yacc.c  */
    5407 #line 556 "parser.yy"
    5408     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5409     break;
    5410 
    5411   case 76:
    5412 
    5413 /* Line 1806 of yacc.c  */
    5414 #line 558 "parser.yy"
    5415     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5416     break;
    5417 
    5418   case 78:
    5419 
    5420 /* Line 1806 of yacc.c  */
    5421 #line 564 "parser.yy"
    5422     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5423     break;
    5424 
    5425   case 79:
    5426 
    5427 /* Line 1806 of yacc.c  */
    5428 #line 566 "parser.yy"
    5429     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5430     break;
    5431 
    5432   case 81:
    5433 
    5434 /* Line 1806 of yacc.c  */
    5435 #line 572 "parser.yy"
    54365395    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54375396    break;
     
    54405399
    54415400/* Line 1806 of yacc.c  */
    5442 #line 574 "parser.yy"
     5401#line 533 "parser.yy"
    54435402    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54445403    break;
     
    54475406
    54485407/* Line 1806 of yacc.c  */
    5449 #line 576 "parser.yy"
     5408#line 535 "parser.yy"
    54505409    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54515410    break;
     
    54545413
    54555414/* Line 1806 of yacc.c  */
    5456 #line 578 "parser.yy"
     5415#line 537 "parser.yy"
    54575416    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54585417    break;
     
    54615420
    54625421/* Line 1806 of yacc.c  */
     5422#line 543 "parser.yy"
     5423    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5424    break;
     5425
     5426  case 87:
     5427
     5428/* Line 1806 of yacc.c  */
     5429#line 545 "parser.yy"
     5430    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5431    break;
     5432
     5433  case 89:
     5434
     5435/* Line 1806 of yacc.c  */
     5436#line 551 "parser.yy"
     5437    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5438    break;
     5439
     5440  case 91:
     5441
     5442/* Line 1806 of yacc.c  */
     5443#line 557 "parser.yy"
     5444    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5445    break;
     5446
     5447  case 93:
     5448
     5449/* Line 1806 of yacc.c  */
     5450#line 563 "parser.yy"
     5451    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5452    break;
     5453
     5454  case 95:
     5455
     5456/* Line 1806 of yacc.c  */
     5457#line 569 "parser.yy"
     5458    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
     5459    break;
     5460
     5461  case 97:
     5462
     5463/* Line 1806 of yacc.c  */
     5464#line 575 "parser.yy"
     5465    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
     5466    break;
     5467
     5468  case 99:
     5469
     5470/* Line 1806 of yacc.c  */
     5471#line 581 "parser.yy"
     5472    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     5473    break;
     5474
     5475  case 100:
     5476
     5477/* Line 1806 of yacc.c  */
    54635478#line 584 "parser.yy"
    5464     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5465     break;
    5466 
    5467   case 87:
     5479    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
     5480    break;
     5481
     5482  case 101:
    54685483
    54695484/* Line 1806 of yacc.c  */
    54705485#line 586 "parser.yy"
    5471     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5472     break;
    5473 
    5474   case 89:
    5475 
    5476 /* Line 1806 of yacc.c  */
    5477 #line 592 "parser.yy"
    5478     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5479     break;
    5480 
    5481   case 91:
    5482 
    5483 /* Line 1806 of yacc.c  */
    5484 #line 598 "parser.yy"
    5485     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5486     break;
    5487 
    5488   case 93:
     5486    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     5487    break;
     5488
     5489  case 104:
     5490
     5491/* Line 1806 of yacc.c  */
     5492#line 597 "parser.yy"
     5493    { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5494    break;
     5495
     5496  case 105:
     5497
     5498/* Line 1806 of yacc.c  */
     5499#line 599 "parser.yy"
     5500    { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new ExpressionNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
     5501    break;
     5502
     5503  case 106:
    54895504
    54905505/* Line 1806 of yacc.c  */
    54915506#line 604 "parser.yy"
    5492     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5493     break;
    5494 
    5495   case 95:
     5507    { (yyval.en) = nullptr; }
     5508    break;
     5509
     5510  case 108:
     5511
     5512/* Line 1806 of yacc.c  */
     5513#line 609 "parser.yy"
     5514    { (yyval.op) = OperKinds::Assign; }
     5515    break;
     5516
     5517  case 109:
    54965518
    54975519/* Line 1806 of yacc.c  */
    54985520#line 610 "parser.yy"
    5499     { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
    5500     break;
    5501 
    5502   case 97:
     5521    { (yyval.op) = OperKinds::MulAssn; }
     5522    break;
     5523
     5524  case 110:
     5525
     5526/* Line 1806 of yacc.c  */
     5527#line 611 "parser.yy"
     5528    { (yyval.op) = OperKinds::DivAssn; }
     5529    break;
     5530
     5531  case 111:
     5532
     5533/* Line 1806 of yacc.c  */
     5534#line 612 "parser.yy"
     5535    { (yyval.op) = OperKinds::ModAssn; }
     5536    break;
     5537
     5538  case 112:
     5539
     5540/* Line 1806 of yacc.c  */
     5541#line 613 "parser.yy"
     5542    { (yyval.op) = OperKinds::PlusAssn; }
     5543    break;
     5544
     5545  case 113:
     5546
     5547/* Line 1806 of yacc.c  */
     5548#line 614 "parser.yy"
     5549    { (yyval.op) = OperKinds::MinusAssn; }
     5550    break;
     5551
     5552  case 114:
     5553
     5554/* Line 1806 of yacc.c  */
     5555#line 615 "parser.yy"
     5556    { (yyval.op) = OperKinds::LSAssn; }
     5557    break;
     5558
     5559  case 115:
    55035560
    55045561/* Line 1806 of yacc.c  */
    55055562#line 616 "parser.yy"
    5506     { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
    5507     break;
    5508 
    5509   case 99:
    5510 
    5511 /* Line 1806 of yacc.c  */
    5512 #line 622 "parser.yy"
    5513     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    5514     break;
    5515 
    5516   case 100:
    5517 
    5518 /* Line 1806 of yacc.c  */
    5519 #line 625 "parser.yy"
    5520     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
    5521     break;
    5522 
    5523   case 101:
    5524 
    5525 /* Line 1806 of yacc.c  */
    5526 #line 627 "parser.yy"
    5527     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    5528     break;
    5529 
    5530   case 104:
     5563    { (yyval.op) = OperKinds::RSAssn; }
     5564    break;
     5565
     5566  case 116:
     5567
     5568/* Line 1806 of yacc.c  */
     5569#line 617 "parser.yy"
     5570    { (yyval.op) = OperKinds::AndAssn; }
     5571    break;
     5572
     5573  case 117:
     5574
     5575/* Line 1806 of yacc.c  */
     5576#line 618 "parser.yy"
     5577    { (yyval.op) = OperKinds::ERAssn; }
     5578    break;
     5579
     5580  case 118:
     5581
     5582/* Line 1806 of yacc.c  */
     5583#line 619 "parser.yy"
     5584    { (yyval.op) = OperKinds::OrAssn; }
     5585    break;
     5586
     5587  case 119:
     5588
     5589/* Line 1806 of yacc.c  */
     5590#line 626 "parser.yy"
     5591    { (yyval.en) = new ExpressionNode( build_tuple() ); }
     5592    break;
     5593
     5594  case 120:
     5595
     5596/* Line 1806 of yacc.c  */
     5597#line 628 "parser.yy"
     5598    { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
     5599    break;
     5600
     5601  case 121:
     5602
     5603/* Line 1806 of yacc.c  */
     5604#line 630 "parser.yy"
     5605    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); }
     5606    break;
     5607
     5608  case 122:
     5609
     5610/* Line 1806 of yacc.c  */
     5611#line 632 "parser.yy"
     5612    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
     5613    break;
     5614
     5615  case 124:
    55315616
    55325617/* Line 1806 of yacc.c  */
    55335618#line 638 "parser.yy"
    5534     { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5535     break;
    5536 
    5537   case 105:
    5538 
    5539 /* Line 1806 of yacc.c  */
    5540 #line 640 "parser.yy"
    5541     { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new ExpressionNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
    5542     break;
    5543 
    5544   case 106:
    5545 
    5546 /* Line 1806 of yacc.c  */
    5547 #line 645 "parser.yy"
    5548     { (yyval.en) = nullptr; }
    5549     break;
    5550 
    5551   case 108:
    5552 
    5553 /* Line 1806 of yacc.c  */
    5554 #line 650 "parser.yy"
    5555     { (yyval.op) = OperKinds::Assign; }
    5556     break;
    5557 
    5558   case 109:
    5559 
    5560 /* Line 1806 of yacc.c  */
    5561 #line 651 "parser.yy"
    5562     { (yyval.op) = OperKinds::MulAssn; }
    5563     break;
    5564 
    5565   case 110:
    5566 
    5567 /* Line 1806 of yacc.c  */
    5568 #line 652 "parser.yy"
    5569     { (yyval.op) = OperKinds::DivAssn; }
    5570     break;
    5571 
    5572   case 111:
    5573 
    5574 /* Line 1806 of yacc.c  */
    5575 #line 653 "parser.yy"
    5576     { (yyval.op) = OperKinds::ModAssn; }
    5577     break;
    5578 
    5579   case 112:
    5580 
    5581 /* Line 1806 of yacc.c  */
    5582 #line 654 "parser.yy"
    5583     { (yyval.op) = OperKinds::PlusAssn; }
    5584     break;
    5585 
    5586   case 113:
    5587 
    5588 /* Line 1806 of yacc.c  */
    5589 #line 655 "parser.yy"
    5590     { (yyval.op) = OperKinds::MinusAssn; }
    5591     break;
    5592 
    5593   case 114:
    5594 
    5595 /* Line 1806 of yacc.c  */
    5596 #line 656 "parser.yy"
    5597     { (yyval.op) = OperKinds::LSAssn; }
    5598     break;
    5599 
    5600   case 115:
    5601 
    5602 /* Line 1806 of yacc.c  */
    5603 #line 657 "parser.yy"
    5604     { (yyval.op) = OperKinds::RSAssn; }
    5605     break;
    5606 
    5607   case 116:
     5619    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     5620    break;
     5621
     5622  case 126:
     5623
     5624/* Line 1806 of yacc.c  */
     5625#line 644 "parser.yy"
     5626    { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     5627    break;
     5628
     5629  case 127:
     5630
     5631/* Line 1806 of yacc.c  */
     5632#line 649 "parser.yy"
     5633    { (yyval.en) = 0; }
     5634    break;
     5635
     5636  case 131:
    56085637
    56095638/* Line 1806 of yacc.c  */
    56105639#line 658 "parser.yy"
    5611     { (yyval.op) = OperKinds::AndAssn; }
    5612     break;
    5613 
    5614   case 117:
    5615 
    5616 /* Line 1806 of yacc.c  */
    5617 #line 659 "parser.yy"
    5618     { (yyval.op) = OperKinds::ERAssn; }
    5619     break;
    5620 
    5621   case 118:
    5622 
    5623 /* Line 1806 of yacc.c  */
    5624 #line 660 "parser.yy"
    5625     { (yyval.op) = OperKinds::OrAssn; }
    5626     break;
    5627 
    5628   case 119:
    5629 
    5630 /* Line 1806 of yacc.c  */
    5631 #line 667 "parser.yy"
    5632     { (yyval.en) = new ExpressionNode( build_tuple() ); }
    5633     break;
    5634 
    5635   case 120:
    5636 
    5637 /* Line 1806 of yacc.c  */
    5638 #line 669 "parser.yy"
    5639     { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
    5640     break;
    5641 
    5642   case 121:
    5643 
    5644 /* Line 1806 of yacc.c  */
    5645 #line 671 "parser.yy"
    5646     { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); }
    5647     break;
    5648 
    5649   case 122:
    5650 
    5651 /* Line 1806 of yacc.c  */
    5652 #line 673 "parser.yy"
    5653     { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
    5654     break;
    5655 
    5656   case 124:
    5657 
    5658 /* Line 1806 of yacc.c  */
    5659 #line 679 "parser.yy"
    5660     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    5661     break;
    5662 
    5663   case 126:
    5664 
    5665 /* Line 1806 of yacc.c  */
    5666 #line 685 "parser.yy"
    5667     { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    5668     break;
    5669 
    5670   case 127:
    5671 
    5672 /* Line 1806 of yacc.c  */
    5673 #line 690 "parser.yy"
    5674     { (yyval.en) = 0; }
    5675     break;
    5676 
    5677   case 131:
    5678 
    5679 /* Line 1806 of yacc.c  */
    5680 #line 699 "parser.yy"
    56815640    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    56825641    break;
     
    56855644
    56865645/* Line 1806 of yacc.c  */
    5687 #line 706 "parser.yy"
     5646#line 665 "parser.yy"
    56885647    {
    56895648                        Token fn;
     
    56965655
    56975656/* Line 1806 of yacc.c  */
    5698 #line 716 "parser.yy"
     5657#line 675 "parser.yy"
    56995658    {
    57005659                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
     
    57055664
    57065665/* Line 1806 of yacc.c  */
    5707 #line 723 "parser.yy"
     5666#line 682 "parser.yy"
    57085667    { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); }
    57095668    break;
     
    57125671
    57135672/* Line 1806 of yacc.c  */
    5714 #line 730 "parser.yy"
     5673#line 689 "parser.yy"
    57155674    { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); }
    57165675    break;
     
    57195678
    57205679/* Line 1806 of yacc.c  */
    5721 #line 736 "parser.yy"
     5680#line 695 "parser.yy"
    57225681    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    57235682    break;
     
    57265685
    57275686/* Line 1806 of yacc.c  */
    5728 #line 741 "parser.yy"
     5687#line 700 "parser.yy"
    57295688    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57305689    break;
     
    57335692
    57345693/* Line 1806 of yacc.c  */
    5735 #line 743 "parser.yy"
     5694#line 702 "parser.yy"
    57365695    {   // mark all fields in list
    57375696                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
     
    57445703
    57455704/* Line 1806 of yacc.c  */
    5746 #line 749 "parser.yy"
     5705#line 708 "parser.yy"
    57475706    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57485707    break;
     
    57515710
    57525711/* Line 1806 of yacc.c  */
    5753 #line 756 "parser.yy"
     5712#line 715 "parser.yy"
    57545713    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    57555714    break;
     
    57585717
    57595718/* Line 1806 of yacc.c  */
    5760 #line 761 "parser.yy"
     5719#line 720 "parser.yy"
    57615720    { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); }
    57625721    break;
     
    57655724
    57665725/* Line 1806 of yacc.c  */
    5767 #line 767 "parser.yy"
     5726#line 726 "parser.yy"
    57685727    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
    57695728    break;
     
    57725731
    57735732/* Line 1806 of yacc.c  */
    5774 #line 769 "parser.yy"
     5733#line 728 "parser.yy"
    57755734    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
    57765735    break;
     
    57795738
    57805739/* Line 1806 of yacc.c  */
    5781 #line 771 "parser.yy"
     5740#line 730 "parser.yy"
    57825741    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    57835742    break;
     
    57865745
    57875746/* Line 1806 of yacc.c  */
    5788 #line 773 "parser.yy"
     5747#line 732 "parser.yy"
    57895748    {
    57905749                        StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
     
    58015760
    58025761/* Line 1806 of yacc.c  */
    5803 #line 783 "parser.yy"
     5762#line 742 "parser.yy"
    58045763    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    58055764    break;
     
    58085767
    58095768/* Line 1806 of yacc.c  */
    5810 #line 785 "parser.yy"
     5769#line 744 "parser.yy"
    58115770    {
    58125771                        StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
     
    58185777
    58195778/* Line 1806 of yacc.c  */
    5820 #line 795 "parser.yy"
     5779#line 754 "parser.yy"
    58215780    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    58225781    break;
     
    58255784
    58265785/* Line 1806 of yacc.c  */
    5827 #line 797 "parser.yy"
     5786#line 756 "parser.yy"
    58285787    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    58295788    break;
     
    58325791
    58335792/* Line 1806 of yacc.c  */
     5793#line 761 "parser.yy"
     5794    { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
     5795    break;
     5796
     5797  case 160:
     5798
     5799/* Line 1806 of yacc.c  */
     5800#line 763 "parser.yy"
     5801    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
     5802    break;
     5803
     5804  case 161:
     5805
     5806/* Line 1806 of yacc.c  */
     5807#line 767 "parser.yy"
     5808    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
     5809    break;
     5810
     5811  case 162:
     5812
     5813/* Line 1806 of yacc.c  */
     5814#line 768 "parser.yy"
     5815    { (yyval.sn) = new StatementNode( build_default() ); }
     5816    break;
     5817
     5818  case 164:
     5819
     5820/* Line 1806 of yacc.c  */
     5821#line 774 "parser.yy"
     5822    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); }
     5823    break;
     5824
     5825  case 165:
     5826
     5827/* Line 1806 of yacc.c  */
     5828#line 778 "parser.yy"
     5829    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
     5830    break;
     5831
     5832  case 166:
     5833
     5834/* Line 1806 of yacc.c  */
     5835#line 783 "parser.yy"
     5836    { (yyval.sn) = 0; }
     5837    break;
     5838
     5839  case 168:
     5840
     5841/* Line 1806 of yacc.c  */
     5842#line 789 "parser.yy"
     5843    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
     5844    break;
     5845
     5846  case 169:
     5847
     5848/* Line 1806 of yacc.c  */
     5849#line 791 "parser.yy"
     5850    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); }
     5851    break;
     5852
     5853  case 170:
     5854
     5855/* Line 1806 of yacc.c  */
     5856#line 796 "parser.yy"
     5857    { (yyval.sn) = 0; }
     5858    break;
     5859
     5860  case 172:
     5861
     5862/* Line 1806 of yacc.c  */
    58345863#line 802 "parser.yy"
    5835     { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
    5836     break;
    5837 
    5838   case 160:
     5864    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
     5865    break;
     5866
     5867  case 173:
    58395868
    58405869/* Line 1806 of yacc.c  */
    58415870#line 804 "parser.yy"
    5842     { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
    5843     break;
    5844 
    5845   case 161:
     5871    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); }
     5872    break;
     5873
     5874  case 174:
     5875
     5876/* Line 1806 of yacc.c  */
     5877#line 806 "parser.yy"
     5878    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
     5879    break;
     5880
     5881  case 175:
    58465882
    58475883/* Line 1806 of yacc.c  */
    58485884#line 808 "parser.yy"
    5849     { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    5850     break;
    5851 
    5852   case 162:
    5853 
    5854 /* Line 1806 of yacc.c  */
    5855 #line 809 "parser.yy"
    5856     { (yyval.sn) = new StatementNode( build_default() ); }
    5857     break;
    5858 
    5859   case 164:
    5860 
    5861 /* Line 1806 of yacc.c  */
    5862 #line 815 "parser.yy"
    5863     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); }
    5864     break;
    5865 
    5866   case 165:
     5885    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(3) - (4)].sn)->set_last( (yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
     5886    break;
     5887
     5888  case 176:
     5889
     5890/* Line 1806 of yacc.c  */
     5891#line 813 "parser.yy"
     5892    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
     5893    break;
     5894
     5895  case 178:
    58675896
    58685897/* Line 1806 of yacc.c  */
    58695898#line 819 "parser.yy"
    5870     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
    5871     break;
    5872 
    5873   case 166:
    5874 
    5875 /* Line 1806 of yacc.c  */
    5876 #line 824 "parser.yy"
    58775899    { (yyval.sn) = 0; }
    58785900    break;
    58795901
    5880   case 168:
     5902  case 179:
     5903
     5904/* Line 1806 of yacc.c  */
     5905#line 821 "parser.yy"
     5906    { (yyval.sn) = 0; }
     5907    break;
     5908
     5909  case 180:
     5910
     5911/* Line 1806 of yacc.c  */
     5912#line 826 "parser.yy"
     5913    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
     5914    break;
     5915
     5916  case 181:
     5917
     5918/* Line 1806 of yacc.c  */
     5919#line 828 "parser.yy"
     5920    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ) ); }
     5921    break;
     5922
     5923  case 182:
    58815924
    58825925/* Line 1806 of yacc.c  */
    58835926#line 830 "parser.yy"
    5884     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
    5885     break;
    5886 
    5887   case 169:
    5888 
    5889 /* Line 1806 of yacc.c  */
    5890 #line 832 "parser.yy"
    5891     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); }
    5892     break;
    5893 
    5894   case 170:
     5927    { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
     5928    break;
     5929
     5930  case 183:
     5931
     5932/* Line 1806 of yacc.c  */
     5933#line 835 "parser.yy"
     5934    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
     5935    break;
     5936
     5937  case 184:
    58955938
    58965939/* Line 1806 of yacc.c  */
    58975940#line 837 "parser.yy"
    5898     { (yyval.sn) = 0; }
    5899     break;
    5900 
    5901   case 172:
    5902 
    5903 /* Line 1806 of yacc.c  */
    5904 #line 843 "parser.yy"
    5905     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    5906     break;
    5907 
    5908   case 173:
    5909 
    5910 /* Line 1806 of yacc.c  */
    5911 #line 845 "parser.yy"
    5912     { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    5913     break;
    5914 
    5915   case 174:
    5916 
    5917 /* Line 1806 of yacc.c  */
    5918 #line 847 "parser.yy"
    5919     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    5920     break;
    5921 
    5922   case 175:
     5941    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
     5942    break;
     5943
     5944  case 185:
     5945
     5946/* Line 1806 of yacc.c  */
     5947#line 842 "parser.yy"
     5948    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
     5949    break;
     5950
     5951  case 186:
     5952
     5953/* Line 1806 of yacc.c  */
     5954#line 846 "parser.yy"
     5955    { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
     5956    break;
     5957
     5958  case 187:
    59235959
    59245960/* Line 1806 of yacc.c  */
    59255961#line 849 "parser.yy"
    5926     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(3) - (4)].sn)->set_last( (yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
    5927     break;
    5928 
    5929   case 176:
    5930 
    5931 /* Line 1806 of yacc.c  */
    5932 #line 854 "parser.yy"
     5962    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
     5963    break;
     5964
     5965  case 188:
     5966
     5967/* Line 1806 of yacc.c  */
     5968#line 853 "parser.yy"
     5969    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
     5970    break;
     5971
     5972  case 189:
     5973
     5974/* Line 1806 of yacc.c  */
     5975#line 856 "parser.yy"
    59335976    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
    59345977    break;
    59355978
    5936   case 178:
     5979  case 190:
    59375980
    59385981/* Line 1806 of yacc.c  */
    59395982#line 860 "parser.yy"
    5940     { (yyval.sn) = 0; }
    5941     break;
    5942 
    5943   case 179:
     5983    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); }
     5984    break;
     5985
     5986  case 191:
    59445987
    59455988/* Line 1806 of yacc.c  */
    59465989#line 862 "parser.yy"
    5947     { (yyval.sn) = 0; }
    5948     break;
    5949 
    5950   case 180:
    5951 
    5952 /* Line 1806 of yacc.c  */
    5953 #line 867 "parser.yy"
    5954     { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    5955     break;
    5956 
    5957   case 181:
    5958 
    5959 /* Line 1806 of yacc.c  */
    5960 #line 869 "parser.yy"
    5961     { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ) ); }
    5962     break;
    5963 
    5964   case 182:
    5965 
    5966 /* Line 1806 of yacc.c  */
    5967 #line 871 "parser.yy"
    5968     { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
    5969     break;
    5970 
    5971   case 183:
    5972 
    5973 /* Line 1806 of yacc.c  */
    5974 #line 876 "parser.yy"
    5975     { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    5976     break;
    5977 
    5978   case 184:
    5979 
    5980 /* Line 1806 of yacc.c  */
    5981 #line 878 "parser.yy"
    5982     { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    5983     break;
    5984 
    5985   case 185:
    5986 
    5987 /* Line 1806 of yacc.c  */
    5988 #line 883 "parser.yy"
    5989     { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
    5990     break;
    5991 
    5992   case 186:
    5993 
    5994 /* Line 1806 of yacc.c  */
    5995 #line 887 "parser.yy"
    5996     { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
    5997     break;
    5998 
    5999   case 187:
     5990    { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
     5991    break;
     5992
     5993  case 192:
     5994
     5995/* Line 1806 of yacc.c  */
     5996#line 864 "parser.yy"
     5997    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
     5998    break;
     5999
     6000  case 193:
     6001
     6002/* Line 1806 of yacc.c  */
     6003#line 866 "parser.yy"
     6004    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
     6005    break;
     6006
     6007  case 194:
     6008
     6009/* Line 1806 of yacc.c  */
     6010#line 868 "parser.yy"
     6011    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); }
     6012    break;
     6013
     6014  case 195:
     6015
     6016/* Line 1806 of yacc.c  */
     6017#line 873 "parser.yy"
     6018    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); }
     6019    break;
     6020
     6021  case 196:
     6022
     6023/* Line 1806 of yacc.c  */
     6024#line 875 "parser.yy"
     6025    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); }
     6026    break;
     6027
     6028  case 197:
     6029
     6030/* Line 1806 of yacc.c  */
     6031#line 877 "parser.yy"
     6032    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); }
     6033    break;
     6034
     6035  case 199:
     6036
     6037/* Line 1806 of yacc.c  */
     6038#line 884 "parser.yy"
     6039    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
     6040    break;
     6041
     6042  case 200:
     6043
     6044/* Line 1806 of yacc.c  */
     6045#line 886 "parser.yy"
     6046    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
     6047    break;
     6048
     6049  case 201:
     6050
     6051/* Line 1806 of yacc.c  */
     6052#line 888 "parser.yy"
     6053    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
     6054    break;
     6055
     6056  case 202:
    60006057
    60016058/* Line 1806 of yacc.c  */
    60026059#line 890 "parser.yy"
    6003     { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
    6004     break;
    6005 
    6006   case 188:
    6007 
    6008 /* Line 1806 of yacc.c  */
    6009 #line 894 "parser.yy"
    6010     { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
    6011     break;
    6012 
    6013   case 189:
     6060    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
     6061    break;
     6062
     6063  case 203:
     6064
     6065/* Line 1806 of yacc.c  */
     6066#line 895 "parser.yy"
     6067    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
     6068    break;
     6069
     6070  case 204:
    60146071
    60156072/* Line 1806 of yacc.c  */
    60166073#line 897 "parser.yy"
    6017     { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
    6018     break;
    6019 
    6020   case 190:
     6074    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
     6075    break;
     6076
     6077  case 205:
     6078
     6079/* Line 1806 of yacc.c  */
     6080#line 899 "parser.yy"
     6081    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
     6082    break;
     6083
     6084  case 206:
    60216085
    60226086/* Line 1806 of yacc.c  */
    60236087#line 901 "parser.yy"
    6024     { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); }
    6025     break;
    6026 
    6027   case 191:
    6028 
    6029 /* Line 1806 of yacc.c  */
    6030 #line 903 "parser.yy"
    6031     { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
    6032     break;
    6033 
    6034   case 192:
    6035 
    6036 /* Line 1806 of yacc.c  */
    6037 #line 905 "parser.yy"
    6038     { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    6039     break;
    6040 
    6041   case 193:
    6042 
    6043 /* Line 1806 of yacc.c  */
    6044 #line 907 "parser.yy"
    6045     { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    6046     break;
    6047 
    6048   case 194:
    6049 
    6050 /* Line 1806 of yacc.c  */
    6051 #line 909 "parser.yy"
    6052     { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); }
    6053     break;
    6054 
    6055   case 195:
    6056 
    6057 /* Line 1806 of yacc.c  */
    6058 #line 914 "parser.yy"
    6059     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); }
    6060     break;
    6061 
    6062   case 196:
    6063 
    6064 /* Line 1806 of yacc.c  */
    6065 #line 916 "parser.yy"
    6066     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); }
    6067     break;
    6068 
    6069   case 197:
    6070 
    6071 /* Line 1806 of yacc.c  */
    6072 #line 918 "parser.yy"
    6073     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); }
    6074     break;
    6075 
    6076   case 199:
    6077 
    6078 /* Line 1806 of yacc.c  */
    6079 #line 925 "parser.yy"
    6080     { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
    6081     break;
    6082 
    6083   case 200:
    6084 
    6085 /* Line 1806 of yacc.c  */
    6086 #line 927 "parser.yy"
    6087     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
    6088     break;
    6089 
    6090   case 201:
    6091 
    6092 /* Line 1806 of yacc.c  */
    6093 #line 929 "parser.yy"
    6094     { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
    6095     break;
    6096 
    6097   case 202:
    6098 
    6099 /* Line 1806 of yacc.c  */
    6100 #line 931 "parser.yy"
    6101     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
    6102     break;
    6103 
    6104   case 203:
    6105 
    6106 /* Line 1806 of yacc.c  */
    6107 #line 936 "parser.yy"
    6108     { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
    6109     break;
    6110 
    6111   case 204:
    6112 
    6113 /* Line 1806 of yacc.c  */
    6114 #line 938 "parser.yy"
    61156088    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
    61166089    break;
    61176090
    6118   case 205:
    6119 
    6120 /* Line 1806 of yacc.c  */
    6121 #line 940 "parser.yy"
    6122     { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
    6123     break;
    6124 
    6125   case 206:
    6126 
    6127 /* Line 1806 of yacc.c  */
    6128 #line 942 "parser.yy"
    6129     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
    6130     break;
    6131 
    61326091  case 207:
    61336092
    61346093/* Line 1806 of yacc.c  */
    6135 #line 947 "parser.yy"
     6094#line 906 "parser.yy"
    61366095    {
    61376096                        (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) );
     
    61426101
    61436102/* Line 1806 of yacc.c  */
    6144 #line 960 "parser.yy"
     6103#line 919 "parser.yy"
    61456104    {
    61466105                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61526111
    61536112/* Line 1806 of yacc.c  */
    6154 #line 965 "parser.yy"
     6113#line 924 "parser.yy"
    61556114    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    61566115    break;
     
    61596118
    61606119/* Line 1806 of yacc.c  */
    6161 #line 967 "parser.yy"
     6120#line 926 "parser.yy"
    61626121    {
    61636122                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61696128
    61706129/* Line 1806 of yacc.c  */
     6130#line 935 "parser.yy"
     6131    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); }
     6132    break;
     6133
     6134  case 214:
     6135
     6136/* Line 1806 of yacc.c  */
     6137#line 937 "parser.yy"
     6138    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); }
     6139    break;
     6140
     6141  case 215:
     6142
     6143/* Line 1806 of yacc.c  */
     6144#line 939 "parser.yy"
     6145    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); }
     6146    break;
     6147
     6148  case 216:
     6149
     6150/* Line 1806 of yacc.c  */
     6151#line 941 "parser.yy"
     6152    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ) ); }
     6153    break;
     6154
     6155  case 217:
     6156
     6157/* Line 1806 of yacc.c  */
     6158#line 943 "parser.yy"
     6159    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ) ); }
     6160    break;
     6161
     6162  case 218:
     6163
     6164/* Line 1806 of yacc.c  */
     6165#line 948 "parser.yy"
     6166    { (yyval.flag) = false; }
     6167    break;
     6168
     6169  case 219:
     6170
     6171/* Line 1806 of yacc.c  */
     6172#line 950 "parser.yy"
     6173    { (yyval.flag) = true; }
     6174    break;
     6175
     6176  case 220:
     6177
     6178/* Line 1806 of yacc.c  */
     6179#line 955 "parser.yy"
     6180    { (yyval.en) = 0; }
     6181    break;
     6182
     6183  case 223:
     6184
     6185/* Line 1806 of yacc.c  */
     6186#line 962 "parser.yy"
     6187    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     6188    break;
     6189
     6190  case 224:
     6191
     6192/* Line 1806 of yacc.c  */
     6193#line 967 "parser.yy"
     6194    { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
     6195    break;
     6196
     6197  case 225:
     6198
     6199/* Line 1806 of yacc.c  */
     6200#line 969 "parser.yy"
     6201    { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
     6202    break;
     6203
     6204  case 226:
     6205
     6206/* Line 1806 of yacc.c  */
     6207#line 974 "parser.yy"
     6208    { (yyval.en) = 0; }
     6209    break;
     6210
     6211  case 227:
     6212
     6213/* Line 1806 of yacc.c  */
    61716214#line 976 "parser.yy"
    6172     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); }
    6173     break;
    6174 
    6175   case 214:
     6215    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
     6216    break;
     6217
     6218  case 228:
    61766219
    61776220/* Line 1806 of yacc.c  */
    61786221#line 978 "parser.yy"
    6179     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); }
    6180     break;
    6181 
    6182   case 215:
    6183 
    6184 /* Line 1806 of yacc.c  */
    6185 #line 980 "parser.yy"
    6186     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); }
    6187     break;
    6188 
    6189   case 216:
    6190 
    6191 /* Line 1806 of yacc.c  */
    6192 #line 982 "parser.yy"
    6193     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ) ); }
    6194     break;
    6195 
    6196   case 217:
    6197 
    6198 /* Line 1806 of yacc.c  */
    6199 #line 984 "parser.yy"
    6200     { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ) ); }
    6201     break;
    6202 
    6203   case 218:
    6204 
    6205 /* Line 1806 of yacc.c  */
    6206 #line 989 "parser.yy"
    6207     { (yyval.flag) = false; }
    6208     break;
    6209 
    6210   case 219:
    6211 
    6212 /* Line 1806 of yacc.c  */
    6213 #line 991 "parser.yy"
    6214     { (yyval.flag) = true; }
    6215     break;
    6216 
    6217   case 220:
    6218 
    6219 /* Line 1806 of yacc.c  */
    6220 #line 996 "parser.yy"
    6221     { (yyval.en) = 0; }
    6222     break;
    6223 
    6224   case 223:
    6225 
    6226 /* Line 1806 of yacc.c  */
    6227 #line 1003 "parser.yy"
    6228     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    6229     break;
    6230 
    6231   case 224:
    6232 
    6233 /* Line 1806 of yacc.c  */
    6234 #line 1008 "parser.yy"
    6235     { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
    6236     break;
    6237 
    6238   case 225:
    6239 
    6240 /* Line 1806 of yacc.c  */
    6241 #line 1010 "parser.yy"
    6242     { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
    6243     break;
    6244 
    6245   case 226:
    6246 
    6247 /* Line 1806 of yacc.c  */
    6248 #line 1015 "parser.yy"
    6249     { (yyval.en) = 0; }
    6250     break;
    6251 
    6252   case 227:
    6253 
    6254 /* Line 1806 of yacc.c  */
    6255 #line 1017 "parser.yy"
    6256     { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    6257     break;
    6258 
    6259   case 228:
    6260 
    6261 /* Line 1806 of yacc.c  */
    6262 #line 1019 "parser.yy"
    62636222    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
    62646223    break;
     
    62676226
    62686227/* Line 1806 of yacc.c  */
    6269 #line 1024 "parser.yy"
     6228#line 983 "parser.yy"
    62706229    {
    62716230                        (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) );
     
    62776236
    62786237/* Line 1806 of yacc.c  */
    6279 #line 1029 "parser.yy"
     6238#line 988 "parser.yy"
    62806239    {
    62816240                        (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) );
     
    62876246
    62886247/* Line 1806 of yacc.c  */
    6289 #line 1039 "parser.yy"
     6248#line 998 "parser.yy"
    62906249    { (yyval.decl) = 0; }
    62916250    break;
     
    62946253
    62956254/* Line 1806 of yacc.c  */
    6296 #line 1046 "parser.yy"
     6255#line 1005 "parser.yy"
    62976256    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    62986257    break;
     
    63016260
    63026261/* Line 1806 of yacc.c  */
    6303 #line 1051 "parser.yy"
     6262#line 1010 "parser.yy"
    63046263    { (yyval.decl) = 0; }
    63056264    break;
     
    63086267
    63096268/* Line 1806 of yacc.c  */
    6310 #line 1058 "parser.yy"
     6269#line 1017 "parser.yy"
    63116270    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    63126271    break;
     
    63156274
    63166275/* Line 1806 of yacc.c  */
    6317 #line 1072 "parser.yy"
     6276#line 1031 "parser.yy"
    63186277    {}
    63196278    break;
     
    63226281
    63236282/* Line 1806 of yacc.c  */
    6324 #line 1073 "parser.yy"
     6283#line 1032 "parser.yy"
    63256284    {}
    63266285    break;
     
    63296288
    63306289/* Line 1806 of yacc.c  */
    6331 #line 1102 "parser.yy"
     6290#line 1061 "parser.yy"
    63326291    {
    63336292                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63396298
    63406299/* Line 1806 of yacc.c  */
    6341 #line 1109 "parser.yy"
     6300#line 1068 "parser.yy"
    63426301    {
    63436302                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63496308
    63506309/* Line 1806 of yacc.c  */
    6351 #line 1114 "parser.yy"
     6310#line 1073 "parser.yy"
    63526311    {
    63536312                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
     
    63596318
    63606319/* Line 1806 of yacc.c  */
    6361 #line 1124 "parser.yy"
     6320#line 1083 "parser.yy"
    63626321    {
    63636322                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63696328
    63706329/* Line 1806 of yacc.c  */
    6371 #line 1129 "parser.yy"
     6330#line 1088 "parser.yy"
    63726331    {
    63736332                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63796338
    63806339/* Line 1806 of yacc.c  */
    6381 #line 1134 "parser.yy"
     6340#line 1093 "parser.yy"
    63826341    {
    63836342                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
     
    63896348
    63906349/* Line 1806 of yacc.c  */
    6391 #line 1142 "parser.yy"
     6350#line 1101 "parser.yy"
    63926351    {
    63936352                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63996358
    64006359/* Line 1806 of yacc.c  */
    6401 #line 1147 "parser.yy"
     6360#line 1106 "parser.yy"
    64026361    {
    64036362                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64096368
    64106369/* Line 1806 of yacc.c  */
    6411 #line 1152 "parser.yy"
     6370#line 1111 "parser.yy"
    64126371    {
    64136372                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64196378
    64206379/* Line 1806 of yacc.c  */
    6421 #line 1157 "parser.yy"
     6380#line 1116 "parser.yy"
    64226381    {
    64236382                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    64296388
    64306389/* Line 1806 of yacc.c  */
    6431 #line 1162 "parser.yy"
     6390#line 1121 "parser.yy"
    64326391    {
    64336392                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    64396398
    64406399/* Line 1806 of yacc.c  */
    6441 #line 1170 "parser.yy"
     6400#line 1129 "parser.yy"
    64426401    {
    64436402                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
     
    64486407
    64496408/* Line 1806 of yacc.c  */
    6450 #line 1193 "parser.yy"
     6409#line 1152 "parser.yy"
    64516410    {
    64526411                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    64576416
    64586417/* Line 1806 of yacc.c  */
    6459 #line 1197 "parser.yy"
     6418#line 1156 "parser.yy"
    64606419    {
    64616420                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    64666425
    64676426/* Line 1806 of yacc.c  */
    6468 #line 1204 "parser.yy"
     6427#line 1163 "parser.yy"
    64696428    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    64706429    break;
     
    64736432
    64746433/* Line 1806 of yacc.c  */
    6475 #line 1208 "parser.yy"
     6434#line 1167 "parser.yy"
    64766435    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    64776436    break;
     
    64806439
    64816440/* Line 1806 of yacc.c  */
    6482 #line 1213 "parser.yy"
     6441#line 1172 "parser.yy"
    64836442    {
    64846443                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64906449
    64916450/* Line 1806 of yacc.c  */
    6492 #line 1218 "parser.yy"
     6451#line 1177 "parser.yy"
    64936452    {
    64946453                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65006459
    65016460/* Line 1806 of yacc.c  */
    6502 #line 1223 "parser.yy"
     6461#line 1182 "parser.yy"
    65036462    {
    65046463                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
     
    65106469
    65116470/* Line 1806 of yacc.c  */
    6512 #line 1234 "parser.yy"
     6471#line 1193 "parser.yy"
    65136472    {
    65146473                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65206479
    65216480/* Line 1806 of yacc.c  */
    6522 #line 1239 "parser.yy"
     6481#line 1198 "parser.yy"
    65236482    {
    65246483                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65306489
    65316490/* Line 1806 of yacc.c  */
    6532 #line 1244 "parser.yy"
     6491#line 1203 "parser.yy"
    65336492    {
    65346493                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65406499
    65416500/* Line 1806 of yacc.c  */
    6542 #line 1249 "parser.yy"
     6501#line 1208 "parser.yy"
    65436502    {
    65446503                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65506509
    65516510/* Line 1806 of yacc.c  */
    6552 #line 1254 "parser.yy"
     6511#line 1213 "parser.yy"
    65536512    {
    65546513                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65606519
    65616520/* Line 1806 of yacc.c  */
    6562 #line 1263 "parser.yy"
     6521#line 1222 "parser.yy"
    65636522    {
    65646523                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
     
    65706529
    65716530/* Line 1806 of yacc.c  */
    6572 #line 1268 "parser.yy"
     6531#line 1227 "parser.yy"
    65736532    {
    65746533                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
     
    65806539
    65816540/* Line 1806 of yacc.c  */
    6582 #line 1285 "parser.yy"
     6541#line 1244 "parser.yy"
    65836542    {
    65846543                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65906549
    65916550/* Line 1806 of yacc.c  */
    6592 #line 1290 "parser.yy"
     6551#line 1249 "parser.yy"
    65936552    {
    65946553                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    66006559
    66016560/* Line 1806 of yacc.c  */
    6602 #line 1312 "parser.yy"
     6561#line 1271 "parser.yy"
    66036562    { (yyval.decl) = 0; }
    66046563    break;
     
    66076566
    66086567/* Line 1806 of yacc.c  */
    6609 #line 1324 "parser.yy"
     6568#line 1283 "parser.yy"
    66106569    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66116570    break;
     
    66146573
    66156574/* Line 1806 of yacc.c  */
    6616 #line 1335 "parser.yy"
     6575#line 1294 "parser.yy"
    66176576    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    66186577    break;
     
    66216580
    66226581/* Line 1806 of yacc.c  */
    6623 #line 1337 "parser.yy"
     6582#line 1296 "parser.yy"
    66246583    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    66256584    break;
     
    66286587
    66296588/* Line 1806 of yacc.c  */
    6630 #line 1339 "parser.yy"
     6589#line 1298 "parser.yy"
    66316590    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    66326591    break;
     
    66356594
    66366595/* Line 1806 of yacc.c  */
    6637 #line 1341 "parser.yy"
     6596#line 1300 "parser.yy"
    66386597    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    66396598    break;
     
    66426601
    66436602/* Line 1806 of yacc.c  */
    6644 #line 1343 "parser.yy"
     6603#line 1302 "parser.yy"
    66456604    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    66466605    break;
     
    66496608
    66506609/* Line 1806 of yacc.c  */
    6651 #line 1345 "parser.yy"
     6610#line 1304 "parser.yy"
    66526611    {
    66536612                        typedefTable.enterScope();
     
    66586617
    66596618/* Line 1806 of yacc.c  */
    6660 #line 1349 "parser.yy"
     6619#line 1308 "parser.yy"
    66616620    {
    66626621                        typedefTable.leaveScope();
     
    66686627
    66696628/* Line 1806 of yacc.c  */
     6629#line 1317 "parser.yy"
     6630    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6631    break;
     6632
     6633  case 307:
     6634
     6635/* Line 1806 of yacc.c  */
     6636#line 1319 "parser.yy"
     6637    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     6638    break;
     6639
     6640  case 309:
     6641
     6642/* Line 1806 of yacc.c  */
     6643#line 1330 "parser.yy"
     6644    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6645    break;
     6646
     6647  case 310:
     6648
     6649/* Line 1806 of yacc.c  */
     6650#line 1335 "parser.yy"
     6651    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
     6652    break;
     6653
     6654  case 311:
     6655
     6656/* Line 1806 of yacc.c  */
     6657#line 1337 "parser.yy"
     6658    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
     6659    break;
     6660
     6661  case 312:
     6662
     6663/* Line 1806 of yacc.c  */
     6664#line 1339 "parser.yy"
     6665    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
     6666    break;
     6667
     6668  case 313:
     6669
     6670/* Line 1806 of yacc.c  */
     6671#line 1341 "parser.yy"
     6672    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     6673    break;
     6674
     6675  case 314:
     6676
     6677/* Line 1806 of yacc.c  */
     6678#line 1344 "parser.yy"
     6679    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; }
     6680    break;
     6681
     6682  case 315:
     6683
     6684/* Line 1806 of yacc.c  */
     6685#line 1346 "parser.yy"
     6686    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
     6687    break;
     6688
     6689  case 316:
     6690
     6691/* Line 1806 of yacc.c  */
     6692#line 1349 "parser.yy"
     6693    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; }
     6694    break;
     6695
     6696  case 317:
     6697
     6698/* Line 1806 of yacc.c  */
     6699#line 1351 "parser.yy"
     6700    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
     6701    break;
     6702
     6703  case 318:
     6704
     6705/* Line 1806 of yacc.c  */
     6706#line 1356 "parser.yy"
     6707    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
     6708    break;
     6709
     6710  case 319:
     6711
     6712/* Line 1806 of yacc.c  */
    66706713#line 1358 "parser.yy"
     6714    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
     6715    break;
     6716
     6717  case 320:
     6718
     6719/* Line 1806 of yacc.c  */
     6720#line 1360 "parser.yy"
     6721    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
     6722    break;
     6723
     6724  case 321:
     6725
     6726/* Line 1806 of yacc.c  */
     6727#line 1362 "parser.yy"
     6728    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
     6729    break;
     6730
     6731  case 322:
     6732
     6733/* Line 1806 of yacc.c  */
     6734#line 1364 "parser.yy"
     6735    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
     6736    break;
     6737
     6738  case 323:
     6739
     6740/* Line 1806 of yacc.c  */
     6741#line 1366 "parser.yy"
     6742    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
     6743    break;
     6744
     6745  case 324:
     6746
     6747/* Line 1806 of yacc.c  */
     6748#line 1368 "parser.yy"
     6749    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
     6750    break;
     6751
     6752  case 325:
     6753
     6754/* Line 1806 of yacc.c  */
     6755#line 1370 "parser.yy"
     6756    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
     6757    break;
     6758
     6759  case 326:
     6760
     6761/* Line 1806 of yacc.c  */
     6762#line 1372 "parser.yy"
     6763    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     6764    break;
     6765
     6766  case 327:
     6767
     6768/* Line 1806 of yacc.c  */
     6769#line 1374 "parser.yy"
     6770    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
     6771    break;
     6772
     6773  case 328:
     6774
     6775/* Line 1806 of yacc.c  */
     6776#line 1376 "parser.yy"
     6777    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
     6778    break;
     6779
     6780  case 329:
     6781
     6782/* Line 1806 of yacc.c  */
     6783#line 1378 "parser.yy"
     6784    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
     6785    break;
     6786
     6787  case 330:
     6788
     6789/* Line 1806 of yacc.c  */
     6790#line 1380 "parser.yy"
     6791    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
     6792    break;
     6793
     6794  case 332:
     6795
     6796/* Line 1806 of yacc.c  */
     6797#line 1387 "parser.yy"
     6798    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6799    break;
     6800
     6801  case 333:
     6802
     6803/* Line 1806 of yacc.c  */
     6804#line 1389 "parser.yy"
    66716805    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66726806    break;
    66736807
    6674   case 307:
    6675 
    6676 /* Line 1806 of yacc.c  */
    6677 #line 1360 "parser.yy"
     6808  case 334:
     6809
     6810/* Line 1806 of yacc.c  */
     6811#line 1391 "parser.yy"
    66786812    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    66796813    break;
    66806814
    6681   case 309:
    6682 
    6683 /* Line 1806 of yacc.c  */
    6684 #line 1371 "parser.yy"
     6815  case 335:
     6816
     6817/* Line 1806 of yacc.c  */
     6818#line 1393 "parser.yy"
     6819    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
     6820    break;
     6821
     6822  case 337:
     6823
     6824/* Line 1806 of yacc.c  */
     6825#line 1399 "parser.yy"
     6826    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     6827    break;
     6828
     6829  case 339:
     6830
     6831/* Line 1806 of yacc.c  */
     6832#line 1406 "parser.yy"
     6833    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6834    break;
     6835
     6836  case 340:
     6837
     6838/* Line 1806 of yacc.c  */
     6839#line 1408 "parser.yy"
    66856840    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66866841    break;
    66876842
    6688   case 310:
    6689 
    6690 /* Line 1806 of yacc.c  */
    6691 #line 1376 "parser.yy"
    6692     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    6693     break;
    6694 
    6695   case 311:
    6696 
    6697 /* Line 1806 of yacc.c  */
    6698 #line 1378 "parser.yy"
    6699     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    6700     break;
    6701 
    6702   case 312:
    6703 
    6704 /* Line 1806 of yacc.c  */
    6705 #line 1380 "parser.yy"
    6706     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    6707     break;
    6708 
    6709   case 313:
    6710 
    6711 /* Line 1806 of yacc.c  */
    6712 #line 1382 "parser.yy"
    6713     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    6714     break;
    6715 
    6716   case 314:
    6717 
    6718 /* Line 1806 of yacc.c  */
    6719 #line 1384 "parser.yy"
    6720     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    6721     break;
    6722 
    6723   case 315:
    6724 
    6725 /* Line 1806 of yacc.c  */
    6726 #line 1386 "parser.yy"
    6727     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    6728     break;
    6729 
    6730   case 316:
    6731 
    6732 /* Line 1806 of yacc.c  */
    6733 #line 1388 "parser.yy"
    6734     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
    6735     break;
    6736 
    6737   case 317:
    6738 
    6739 /* Line 1806 of yacc.c  */
    6740 #line 1390 "parser.yy"
    6741     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    6742     break;
    6743 
    6744   case 318:
    6745 
    6746 /* Line 1806 of yacc.c  */
    6747 #line 1395 "parser.yy"
    6748     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    6749     break;
    6750 
    6751   case 319:
    6752 
    6753 /* Line 1806 of yacc.c  */
    6754 #line 1397 "parser.yy"
    6755     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    6756     break;
    6757 
    6758   case 320:
    6759 
    6760 /* Line 1806 of yacc.c  */
    6761 #line 1399 "parser.yy"
    6762     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    6763     break;
    6764 
    6765   case 321:
    6766 
    6767 /* Line 1806 of yacc.c  */
    6768 #line 1401 "parser.yy"
    6769     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    6770     break;
    6771 
    6772   case 322:
    6773 
    6774 /* Line 1806 of yacc.c  */
    6775 #line 1403 "parser.yy"
    6776     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
    6777     break;
    6778 
    6779   case 323:
    6780 
    6781 /* Line 1806 of yacc.c  */
    6782 #line 1405 "parser.yy"
    6783     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
    6784     break;
    6785 
    6786   case 324:
    6787 
    6788 /* Line 1806 of yacc.c  */
    6789 #line 1407 "parser.yy"
    6790     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
    6791     break;
    6792 
    6793   case 325:
    6794 
    6795 /* Line 1806 of yacc.c  */
    6796 #line 1409 "parser.yy"
    6797     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
    6798     break;
    6799 
    6800   case 326:
    6801 
    6802 /* Line 1806 of yacc.c  */
    6803 #line 1411 "parser.yy"
    6804     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    6805     break;
    6806 
    6807   case 327:
    6808 
    6809 /* Line 1806 of yacc.c  */
    6810 #line 1413 "parser.yy"
    6811     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    6812     break;
    6813 
    6814   case 328:
     6843  case 341:
     6844
     6845/* Line 1806 of yacc.c  */
     6846#line 1410 "parser.yy"
     6847    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
     6848    break;
     6849
     6850  case 342:
    68156851
    68166852/* Line 1806 of yacc.c  */
    68176853#line 1415 "parser.yy"
    6818     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
    6819     break;
    6820 
    6821   case 329:
     6854    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
     6855    break;
     6856
     6857  case 343:
    68226858
    68236859/* Line 1806 of yacc.c  */
    68246860#line 1417 "parser.yy"
    6825     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
    6826     break;
    6827 
    6828   case 330:
     6861    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
     6862    break;
     6863
     6864  case 344:
    68296865
    68306866/* Line 1806 of yacc.c  */
    68316867#line 1419 "parser.yy"
    6832     { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    6833     break;
    6834 
    6835   case 332:
    6836 
    6837 /* Line 1806 of yacc.c  */
    6838 #line 1426 "parser.yy"
     6868    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
     6869    break;
     6870
     6871  case 345:
     6872
     6873/* Line 1806 of yacc.c  */
     6874#line 1421 "parser.yy"
     6875    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
     6876    break;
     6877
     6878  case 347:
     6879
     6880/* Line 1806 of yacc.c  */
     6881#line 1427 "parser.yy"
    68396882    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68406883    break;
    68416884
    6842   case 333:
    6843 
    6844 /* Line 1806 of yacc.c  */
    6845 #line 1428 "parser.yy"
     6885  case 348:
     6886
     6887/* Line 1806 of yacc.c  */
     6888#line 1429 "parser.yy"
    68466889    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68476890    break;
    68486891
    6849   case 334:
    6850 
    6851 /* Line 1806 of yacc.c  */
    6852 #line 1430 "parser.yy"
     6892  case 349:
     6893
     6894/* Line 1806 of yacc.c  */
     6895#line 1431 "parser.yy"
    68536896    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68546897    break;
    68556898
    6856   case 335:
    6857 
    6858 /* Line 1806 of yacc.c  */
    6859 #line 1432 "parser.yy"
    6860     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    6861     break;
    6862 
    6863   case 337:
    6864 
    6865 /* Line 1806 of yacc.c  */
    6866 #line 1438 "parser.yy"
    6867     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    6868     break;
    6869 
    6870   case 339:
     6899  case 351:
     6900
     6901/* Line 1806 of yacc.c  */
     6902#line 1437 "parser.yy"
     6903    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6904    break;
     6905
     6906  case 352:
     6907
     6908/* Line 1806 of yacc.c  */
     6909#line 1439 "parser.yy"
     6910    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6911    break;
     6912
     6913  case 354:
    68716914
    68726915/* Line 1806 of yacc.c  */
     
    68756918    break;
    68766919
    6877   case 340:
     6920  case 355:
    68786921
    68796922/* Line 1806 of yacc.c  */
     
    68826925    break;
    68836926
    6884   case 341:
     6927  case 356:
    68856928
    68866929/* Line 1806 of yacc.c  */
    68876930#line 1449 "parser.yy"
    6888     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    6889     break;
    6890 
    6891   case 342:
     6931    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     6932    break;
     6933
     6934  case 357:
    68926935
    68936936/* Line 1806 of yacc.c  */
    68946937#line 1454 "parser.yy"
    6895     { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    6896     break;
    6897 
    6898   case 343:
     6938    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
     6939    break;
     6940
     6941  case 358:
    68996942
    69006943/* Line 1806 of yacc.c  */
    69016944#line 1456 "parser.yy"
    6902     { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    6903     break;
    6904 
    6905   case 344:
     6945    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6946    break;
     6947
     6948  case 359:
    69066949
    69076950/* Line 1806 of yacc.c  */
    69086951#line 1458 "parser.yy"
    6909     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    6910     break;
    6911 
    6912   case 345:
    6913 
    6914 /* Line 1806 of yacc.c  */
    6915 #line 1460 "parser.yy"
    6916     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    6917     break;
    6918 
    6919   case 347:
    6920 
    6921 /* Line 1806 of yacc.c  */
    6922 #line 1466 "parser.yy"
    6923     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    6924     break;
    6925 
    6926   case 348:
     6952    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6953    break;
     6954
     6955  case 362:
    69276956
    69286957/* Line 1806 of yacc.c  */
    69296958#line 1468 "parser.yy"
    6930     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    6931     break;
    6932 
    6933   case 349:
     6959    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
     6960    break;
     6961
     6962  case 363:
    69346963
    69356964/* Line 1806 of yacc.c  */
    69366965#line 1470 "parser.yy"
    6937     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    6938     break;
    6939 
    6940   case 351:
    6941 
    6942 /* Line 1806 of yacc.c  */
    6943 #line 1476 "parser.yy"
    6944     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    6945     break;
    6946 
    6947   case 352:
    6948 
    6949 /* Line 1806 of yacc.c  */
    6950 #line 1478 "parser.yy"
    6951     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    6952     break;
    6953 
    6954   case 354:
    6955 
    6956 /* Line 1806 of yacc.c  */
    6957 #line 1484 "parser.yy"
    6958     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    6959     break;
    6960 
    6961   case 355:
    6962 
    6963 /* Line 1806 of yacc.c  */
    6964 #line 1486 "parser.yy"
    6965     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    6966     break;
    6967 
    6968   case 356:
    6969 
    6970 /* Line 1806 of yacc.c  */
    6971 #line 1488 "parser.yy"
    6972     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    6973     break;
    6974 
    6975   case 357:
    6976 
    6977 /* Line 1806 of yacc.c  */
    6978 #line 1493 "parser.yy"
    6979     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    6980     break;
    6981 
    6982   case 358:
    6983 
    6984 /* Line 1806 of yacc.c  */
    6985 #line 1495 "parser.yy"
    6986     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    6987     break;
    6988 
    6989   case 359:
    6990 
    6991 /* Line 1806 of yacc.c  */
    6992 #line 1497 "parser.yy"
    6993     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    6994     break;
    6995 
    6996   case 362:
    6997 
    6998 /* Line 1806 of yacc.c  */
    6999 #line 1507 "parser.yy"
    7000     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
    7001     break;
    7002 
    7003   case 363:
    7004 
    7005 /* Line 1806 of yacc.c  */
    7006 #line 1509 "parser.yy"
    70076966    {
    70086967                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    70146973
    70156974/* Line 1806 of yacc.c  */
    7016 #line 1514 "parser.yy"
     6975#line 1475 "parser.yy"
    70176976    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    70186977    break;
     
    70216980
    70226981/* Line 1806 of yacc.c  */
    7023 #line 1516 "parser.yy"
     6982#line 1477 "parser.yy"
    70246983    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
    70256984    break;
     
    70286987
    70296988/* Line 1806 of yacc.c  */
    7030 #line 1518 "parser.yy"
     6989#line 1479 "parser.yy"
    70316990    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    70326991    break;
     
    70356994
    70366995/* Line 1806 of yacc.c  */
    7037 #line 1520 "parser.yy"
     6996#line 1481 "parser.yy"
    70386997    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    70396998    break;
     
    70427001
    70437002/* Line 1806 of yacc.c  */
    7044 #line 1525 "parser.yy"
     7003#line 1486 "parser.yy"
    70457004    { (yyval.aggKey) = DeclarationNode::Struct; }
    70467005    break;
     
    70497008
    70507009/* Line 1806 of yacc.c  */
    7051 #line 1527 "parser.yy"
     7010#line 1488 "parser.yy"
    70527011    { (yyval.aggKey) = DeclarationNode::Union; }
    70537012    break;
     
    70567015
    70577016/* Line 1806 of yacc.c  */
    7058 #line 1532 "parser.yy"
     7017#line 1493 "parser.yy"
    70597018    { (yyval.decl) = 0; }
    70607019    break;
     
    70637022
    70647023/* Line 1806 of yacc.c  */
    7065 #line 1534 "parser.yy"
     7024#line 1495 "parser.yy"
    70667025    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    70677026    break;
     
    70707029
    70717030/* Line 1806 of yacc.c  */
    7072 #line 1540 "parser.yy"
     7031#line 1501 "parser.yy"
    70737032    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    70747033    break;
     
    70777036
    70787037/* Line 1806 of yacc.c  */
    7079 #line 1543 "parser.yy"
     7038#line 1504 "parser.yy"
    70807039    {   // mark all fields in list
    70817040                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
     
    70887047
    70897048/* Line 1806 of yacc.c  */
    7090 #line 1553 "parser.yy"
     7049#line 1514 "parser.yy"
    70917050    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    70927051    break;
     
    70957054
    70967055/* Line 1806 of yacc.c  */
    7097 #line 1555 "parser.yy"
     7056#line 1516 "parser.yy"
    70987057    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    70997058    break;
     
    71027061
    71037062/* Line 1806 of yacc.c  */
    7104 #line 1557 "parser.yy"
     7063#line 1518 "parser.yy"
    71057064    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    71067065    break;
     
    71097068
    71107069/* Line 1806 of yacc.c  */
     7070#line 1523 "parser.yy"
     7071    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     7072    break;
     7073
     7074  case 381:
     7075
     7076/* Line 1806 of yacc.c  */
     7077#line 1525 "parser.yy"
     7078    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
     7079    break;
     7080
     7081  case 382:
     7082
     7083/* Line 1806 of yacc.c  */
     7084#line 1530 "parser.yy"
     7085    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
     7086    break;
     7087
     7088  case 383:
     7089
     7090/* Line 1806 of yacc.c  */
     7091#line 1532 "parser.yy"
     7092    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
     7093    break;
     7094
     7095  case 384:
     7096
     7097/* Line 1806 of yacc.c  */
     7098#line 1535 "parser.yy"
     7099    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     7100    break;
     7101
     7102  case 385:
     7103
     7104/* Line 1806 of yacc.c  */
     7105#line 1538 "parser.yy"
     7106    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     7107    break;
     7108
     7109  case 387:
     7110
     7111/* Line 1806 of yacc.c  */
     7112#line 1544 "parser.yy"
     7113    { (yyval.en) = 0; }
     7114    break;
     7115
     7116  case 388:
     7117
     7118/* Line 1806 of yacc.c  */
     7119#line 1546 "parser.yy"
     7120    { (yyval.en) = (yyvsp[(1) - (1)].en); }
     7121    break;
     7122
     7123  case 389:
     7124
     7125/* Line 1806 of yacc.c  */
     7126#line 1551 "parser.yy"
     7127    { (yyval.en) = (yyvsp[(2) - (2)].en); }
     7128    break;
     7129
     7130  case 391:
     7131
     7132/* Line 1806 of yacc.c  */
     7133#line 1560 "parser.yy"
     7134    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
     7135    break;
     7136
     7137  case 392:
     7138
     7139/* Line 1806 of yacc.c  */
    71117140#line 1562 "parser.yy"
    7112     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    7113     break;
    7114 
    7115   case 381:
    7116 
    7117 /* Line 1806 of yacc.c  */
    7118 #line 1564 "parser.yy"
    7119     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    7120     break;
    7121 
    7122   case 382:
    7123 
    7124 /* Line 1806 of yacc.c  */
    7125 #line 1569 "parser.yy"
    7126     { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    7127     break;
    7128 
    7129   case 383:
    7130 
    7131 /* Line 1806 of yacc.c  */
    7132 #line 1571 "parser.yy"
    7133     { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    7134     break;
    7135 
    7136   case 384:
    7137 
    7138 /* Line 1806 of yacc.c  */
    7139 #line 1574 "parser.yy"
    7140     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    7141     break;
    7142 
    7143   case 385:
    7144 
    7145 /* Line 1806 of yacc.c  */
    7146 #line 1577 "parser.yy"
    7147     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    7148     break;
    7149 
    7150   case 387:
    7151 
    7152 /* Line 1806 of yacc.c  */
    7153 #line 1583 "parser.yy"
    7154     { (yyval.en) = 0; }
    7155     break;
    7156 
    7157   case 388:
    7158 
    7159 /* Line 1806 of yacc.c  */
    7160 #line 1585 "parser.yy"
    7161     { (yyval.en) = (yyvsp[(1) - (1)].en); }
    7162     break;
    7163 
    7164   case 389:
    7165 
    7166 /* Line 1806 of yacc.c  */
    7167 #line 1590 "parser.yy"
    7168     { (yyval.en) = (yyvsp[(2) - (2)].en); }
    7169     break;
    7170 
    7171   case 391:
    7172 
    7173 /* Line 1806 of yacc.c  */
    7174 #line 1599 "parser.yy"
    7175     { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
    7176     break;
    7177 
    7178   case 392:
    7179 
    7180 /* Line 1806 of yacc.c  */
    7181 #line 1601 "parser.yy"
    71827141    {
    71837142                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    71897148
    71907149/* Line 1806 of yacc.c  */
    7191 #line 1606 "parser.yy"
     7150#line 1567 "parser.yy"
    71927151    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    71937152    break;
     
    71967155
    71977156/* Line 1806 of yacc.c  */
    7198 #line 1608 "parser.yy"
     7157#line 1569 "parser.yy"
    71997158    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    72007159    break;
     
    72037162
    72047163/* Line 1806 of yacc.c  */
    7205 #line 1613 "parser.yy"
     7164#line 1574 "parser.yy"
    72067165    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    72077166    break;
     
    72107169
    72117170/* Line 1806 of yacc.c  */
    7212 #line 1615 "parser.yy"
     7171#line 1576 "parser.yy"
    72137172    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    72147173    break;
     
    72177176
    72187177/* Line 1806 of yacc.c  */
     7178#line 1581 "parser.yy"
     7179    { (yyval.en) = 0; }
     7180    break;
     7181
     7182  case 398:
     7183
     7184/* Line 1806 of yacc.c  */
     7185#line 1583 "parser.yy"
     7186    { (yyval.en) = (yyvsp[(2) - (2)].en); }
     7187    break;
     7188
     7189  case 399:
     7190
     7191/* Line 1806 of yacc.c  */
     7192#line 1590 "parser.yy"
     7193    { (yyval.decl) = 0; }
     7194    break;
     7195
     7196  case 403:
     7197
     7198/* Line 1806 of yacc.c  */
     7199#line 1598 "parser.yy"
     7200    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7201    break;
     7202
     7203  case 404:
     7204
     7205/* Line 1806 of yacc.c  */
     7206#line 1600 "parser.yy"
     7207    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     7208    break;
     7209
     7210  case 405:
     7211
     7212/* Line 1806 of yacc.c  */
     7213#line 1602 "parser.yy"
     7214    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     7215    break;
     7216
     7217  case 407:
     7218
     7219/* Line 1806 of yacc.c  */
     7220#line 1610 "parser.yy"
     7221    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7222    break;
     7223
     7224  case 408:
     7225
     7226/* Line 1806 of yacc.c  */
     7227#line 1612 "parser.yy"
     7228    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7229    break;
     7230
     7231  case 409:
     7232
     7233/* Line 1806 of yacc.c  */
     7234#line 1614 "parser.yy"
     7235    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
     7236    break;
     7237
     7238  case 411:
     7239
     7240/* Line 1806 of yacc.c  */
    72197241#line 1620 "parser.yy"
    7220     { (yyval.en) = 0; }
    7221     break;
    7222 
    7223   case 398:
    7224 
    7225 /* Line 1806 of yacc.c  */
    7226 #line 1622 "parser.yy"
    7227     { (yyval.en) = (yyvsp[(2) - (2)].en); }
    7228     break;
    7229 
    7230   case 399:
    7231 
    7232 /* Line 1806 of yacc.c  */
    7233 #line 1629 "parser.yy"
     7242    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     7243    break;
     7244
     7245  case 412:
     7246
     7247/* Line 1806 of yacc.c  */
     7248#line 1625 "parser.yy"
    72347249    { (yyval.decl) = 0; }
    72357250    break;
    72367251
    7237   case 403:
    7238 
    7239 /* Line 1806 of yacc.c  */
    7240 #line 1637 "parser.yy"
     7252  case 415:
     7253
     7254/* Line 1806 of yacc.c  */
     7255#line 1632 "parser.yy"
     7256    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     7257    break;
     7258
     7259  case 418:
     7260
     7261/* Line 1806 of yacc.c  */
     7262#line 1639 "parser.yy"
    72417263    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72427264    break;
    72437265
    7244   case 404:
    7245 
    7246 /* Line 1806 of yacc.c  */
    7247 #line 1639 "parser.yy"
    7248     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    7249     break;
    7250 
    7251   case 405:
     7266  case 419:
    72527267
    72537268/* Line 1806 of yacc.c  */
    72547269#line 1641 "parser.yy"
    7255     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    7256     break;
    7257 
    7258   case 407:
    7259 
    7260 /* Line 1806 of yacc.c  */
    7261 #line 1649 "parser.yy"
    72627270    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72637271    break;
    72647272
    7265   case 408:
    7266 
    7267 /* Line 1806 of yacc.c  */
    7268 #line 1651 "parser.yy"
    7269     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7270     break;
    7271 
    7272   case 409:
     7273  case 421:
     7274
     7275/* Line 1806 of yacc.c  */
     7276#line 1650 "parser.yy"
     7277    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     7278    break;
     7279
     7280  case 422:
    72737281
    72747282/* Line 1806 of yacc.c  */
    72757283#line 1653 "parser.yy"
    7276     { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    7277     break;
    7278 
    7279   case 411:
    7280 
    7281 /* Line 1806 of yacc.c  */
    7282 #line 1659 "parser.yy"
    7283     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7284     break;
    7285 
    7286   case 412:
    7287 
    7288 /* Line 1806 of yacc.c  */
    7289 #line 1664 "parser.yy"
    7290     { (yyval.decl) = 0; }
    7291     break;
    7292 
    7293   case 415:
     7284    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     7285    break;
     7286
     7287  case 423:
     7288
     7289/* Line 1806 of yacc.c  */
     7290#line 1655 "parser.yy"
     7291    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
     7292    break;
     7293
     7294  case 428:
     7295
     7296/* Line 1806 of yacc.c  */
     7297#line 1665 "parser.yy"
     7298    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     7299    break;
     7300
     7301  case 430:
    72947302
    72957303/* Line 1806 of yacc.c  */
    72967304#line 1671 "parser.yy"
    7297     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    7298     break;
    7299 
    7300   case 418:
    7301 
    7302 /* Line 1806 of yacc.c  */
    7303 #line 1678 "parser.yy"
    7304     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7305     break;
    7306 
    7307   case 419:
    7308 
    7309 /* Line 1806 of yacc.c  */
    7310 #line 1680 "parser.yy"
    7311     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    7312     break;
    7313 
    7314   case 421:
    7315 
    7316 /* Line 1806 of yacc.c  */
    7317 #line 1689 "parser.yy"
    7318     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    7319     break;
    7320 
    7321   case 422:
    7322 
    7323 /* Line 1806 of yacc.c  */
    7324 #line 1692 "parser.yy"
    7325     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    7326     break;
    7327 
    7328   case 423:
    7329 
    7330 /* Line 1806 of yacc.c  */
    7331 #line 1694 "parser.yy"
    7332     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    7333     break;
    7334 
    7335   case 428:
    7336 
    7337 /* Line 1806 of yacc.c  */
    7338 #line 1704 "parser.yy"
    7339     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7340     break;
    7341 
    7342   case 430:
    7343 
    7344 /* Line 1806 of yacc.c  */
    7345 #line 1710 "parser.yy"
    73467305    {
    73477306                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73537312
    73547313/* Line 1806 of yacc.c  */
    7355 #line 1715 "parser.yy"
     7314#line 1676 "parser.yy"
    73567315    {
    73577316                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73637322
    73647323/* Line 1806 of yacc.c  */
    7365 #line 1724 "parser.yy"
     7324#line 1685 "parser.yy"
    73667325    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73677326    break;
     
    73707329
    73717330/* Line 1806 of yacc.c  */
    7372 #line 1733 "parser.yy"
     7331#line 1694 "parser.yy"
    73737332    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    73747333    break;
     
    73777336
    73787337/* Line 1806 of yacc.c  */
    7379 #line 1735 "parser.yy"
     7338#line 1696 "parser.yy"
    73807339    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    73817340    break;
     
    73847343
    73857344/* Line 1806 of yacc.c  */
    7386 #line 1760 "parser.yy"
     7345#line 1721 "parser.yy"
    73877346    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73887347    break;
     
    73917350
    73927351/* Line 1806 of yacc.c  */
    7393 #line 1768 "parser.yy"
     7352#line 1729 "parser.yy"
    73947353    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73957354    break;
     
    73987357
    73997358/* Line 1806 of yacc.c  */
    7400 #line 1773 "parser.yy"
     7359#line 1734 "parser.yy"
    74017360    { (yyval.in) = 0; }
    74027361    break;
     
    74057364
    74067365/* Line 1806 of yacc.c  */
     7366#line 1736 "parser.yy"
     7367    { (yyval.in) = (yyvsp[(2) - (2)].in); }
     7368    break;
     7369
     7370  case 454:
     7371
     7372/* Line 1806 of yacc.c  */
     7373#line 1738 "parser.yy"
     7374    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
     7375    break;
     7376
     7377  case 455:
     7378
     7379/* Line 1806 of yacc.c  */
     7380#line 1742 "parser.yy"
     7381    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
     7382    break;
     7383
     7384  case 456:
     7385
     7386/* Line 1806 of yacc.c  */
     7387#line 1743 "parser.yy"
     7388    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
     7389    break;
     7390
     7391  case 457:
     7392
     7393/* Line 1806 of yacc.c  */
     7394#line 1748 "parser.yy"
     7395    { (yyval.in) = 0; }
     7396    break;
     7397
     7398  case 459:
     7399
     7400/* Line 1806 of yacc.c  */
     7401#line 1750 "parser.yy"
     7402    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
     7403    break;
     7404
     7405  case 460:
     7406
     7407/* Line 1806 of yacc.c  */
     7408#line 1751 "parser.yy"
     7409    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
     7410    break;
     7411
     7412  case 461:
     7413
     7414/* Line 1806 of yacc.c  */
     7415#line 1753 "parser.yy"
     7416    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
     7417    break;
     7418
     7419  case 463:
     7420
     7421/* Line 1806 of yacc.c  */
     7422#line 1769 "parser.yy"
     7423    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
     7424    break;
     7425
     7426  case 465:
     7427
     7428/* Line 1806 of yacc.c  */
    74077429#line 1775 "parser.yy"
    7408     { (yyval.in) = (yyvsp[(2) - (2)].in); }
    7409     break;
    7410 
    7411   case 454:
    7412 
    7413 /* Line 1806 of yacc.c  */
    7414 #line 1777 "parser.yy"
    7415     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    7416     break;
    7417 
    7418   case 455:
     7430    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
     7431    break;
     7432
     7433  case 466:
    74197434
    74207435/* Line 1806 of yacc.c  */
    74217436#line 1781 "parser.yy"
    7422     { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    7423     break;
    7424 
    7425   case 456:
    7426 
    7427 /* Line 1806 of yacc.c  */
    7428 #line 1782 "parser.yy"
    7429     { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    7430     break;
    7431 
    7432   case 457:
    7433 
    7434 /* Line 1806 of yacc.c  */
    7435 #line 1787 "parser.yy"
    7436     { (yyval.in) = 0; }
    7437     break;
    7438 
    7439   case 459:
    7440 
    7441 /* Line 1806 of yacc.c  */
    7442 #line 1789 "parser.yy"
    7443     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    7444     break;
    7445 
    7446   case 460:
     7437    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
     7438    break;
     7439
     7440  case 467:
     7441
     7442/* Line 1806 of yacc.c  */
     7443#line 1784 "parser.yy"
     7444    { (yyval.en) = (yyvsp[(3) - (5)].en); }
     7445    break;
     7446
     7447  case 468:
     7448
     7449/* Line 1806 of yacc.c  */
     7450#line 1786 "parser.yy"
     7451    { (yyval.en) = (yyvsp[(3) - (5)].en); }
     7452    break;
     7453
     7454  case 469:
     7455
     7456/* Line 1806 of yacc.c  */
     7457#line 1788 "parser.yy"
     7458    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
     7459    break;
     7460
     7461  case 470:
    74477462
    74487463/* Line 1806 of yacc.c  */
    74497464#line 1790 "parser.yy"
    7450     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
    7451     break;
    7452 
    7453   case 461:
    7454 
    7455 /* Line 1806 of yacc.c  */
    7456 #line 1792 "parser.yy"
    7457     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    7458     break;
    7459 
    7460   case 463:
    7461 
    7462 /* Line 1806 of yacc.c  */
    7463 #line 1808 "parser.yy"
    7464     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
    7465     break;
    7466 
    7467   case 465:
     7465    { (yyval.en) = (yyvsp[(4) - (6)].en); }
     7466    break;
     7467
     7468  case 472:
    74687469
    74697470/* Line 1806 of yacc.c  */
    74707471#line 1814 "parser.yy"
    7471     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
    7472     break;
    7473 
    7474   case 466:
    7475 
    7476 /* Line 1806 of yacc.c  */
    7477 #line 1820 "parser.yy"
    7478     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
    7479     break;
    7480 
    7481   case 467:
    7482 
    7483 /* Line 1806 of yacc.c  */
    7484 #line 1823 "parser.yy"
    7485     { (yyval.en) = (yyvsp[(3) - (5)].en); }
    7486     break;
    7487 
    7488   case 468:
    7489 
    7490 /* Line 1806 of yacc.c  */
    7491 #line 1825 "parser.yy"
    7492     { (yyval.en) = (yyvsp[(3) - (5)].en); }
    7493     break;
    7494 
    7495   case 469:
    7496 
    7497 /* Line 1806 of yacc.c  */
    7498 #line 1827 "parser.yy"
    7499     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
    7500     break;
    7501 
    7502   case 470:
    7503 
    7504 /* Line 1806 of yacc.c  */
    7505 #line 1829 "parser.yy"
    7506     { (yyval.en) = (yyvsp[(4) - (6)].en); }
    7507     break;
    7508 
    7509   case 472:
    7510 
    7511 /* Line 1806 of yacc.c  */
    7512 #line 1853 "parser.yy"
    75137472    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75147473    break;
     
    75177476
    75187477/* Line 1806 of yacc.c  */
    7519 #line 1855 "parser.yy"
     7478#line 1816 "parser.yy"
    75207479    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    75217480    break;
     
    75247483
    75257484/* Line 1806 of yacc.c  */
    7526 #line 1857 "parser.yy"
     7485#line 1818 "parser.yy"
    75277486    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    75287487    break;
     
    75317490
    75327491/* Line 1806 of yacc.c  */
    7533 #line 1863 "parser.yy"
     7492#line 1824 "parser.yy"
    75347493    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75357494    break;
     
    75387497
    75397498/* Line 1806 of yacc.c  */
    7540 #line 1865 "parser.yy"
     7499#line 1826 "parser.yy"
    75417500    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    75427501    break;
     
    75457504
    75467505/* Line 1806 of yacc.c  */
    7547 #line 1870 "parser.yy"
     7506#line 1831 "parser.yy"
    75487507    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    75497508    break;
     
    75527511
    75537512/* Line 1806 of yacc.c  */
    7554 #line 1876 "parser.yy"
     7513#line 1837 "parser.yy"
    75557514    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    75567515    break;
     
    75597518
    75607519/* Line 1806 of yacc.c  */
    7561 #line 1881 "parser.yy"
     7520#line 1842 "parser.yy"
    75627521    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    75637522    break;
     
    75667525
    75677526/* Line 1806 of yacc.c  */
    7568 #line 1883 "parser.yy"
     7527#line 1844 "parser.yy"
    75697528    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    75707529    break;
     
    75737532
    75747533/* Line 1806 of yacc.c  */
    7575 #line 1889 "parser.yy"
     7534#line 1850 "parser.yy"
    75767535    { (yyval.tclass) = DeclarationNode::Type; }
    75777536    break;
     
    75807539
    75817540/* Line 1806 of yacc.c  */
    7582 #line 1891 "parser.yy"
     7541#line 1852 "parser.yy"
    75837542    { (yyval.tclass) = DeclarationNode::Ftype; }
    75847543    break;
     
    75877546
    75887547/* Line 1806 of yacc.c  */
    7589 #line 1893 "parser.yy"
     7548#line 1854 "parser.yy"
    75907549    { (yyval.tclass) = DeclarationNode::Dtype; }
    75917550    break;
     
    75947553
    75957554/* Line 1806 of yacc.c  */
    7596 #line 1898 "parser.yy"
     7555#line 1859 "parser.yy"
    75977556    { (yyval.decl) = 0; }
    75987557    break;
     
    76017560
    76027561/* Line 1806 of yacc.c  */
    7603 #line 1900 "parser.yy"
     7562#line 1861 "parser.yy"
    76047563    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    76057564    break;
     
    76087567
    76097568/* Line 1806 of yacc.c  */
    7610 #line 1905 "parser.yy"
     7569#line 1866 "parser.yy"
    76117570    {
    76127571                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
     
    76187577
    76197578/* Line 1806 of yacc.c  */
    7620 #line 1910 "parser.yy"
     7579#line 1871 "parser.yy"
    76217580    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    76227581    break;
     
    76257584
    76267585/* Line 1806 of yacc.c  */
    7627 #line 1912 "parser.yy"
     7586#line 1873 "parser.yy"
    76287587    { (yyval.decl) = 0; }
    76297588    break;
     
    76327591
    76337592/* Line 1806 of yacc.c  */
    7634 #line 1917 "parser.yy"
     7593#line 1878 "parser.yy"
    76357594    { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
    76367595    break;
     
    76397598
    76407599/* Line 1806 of yacc.c  */
    7641 #line 1920 "parser.yy"
     7600#line 1881 "parser.yy"
    76427601    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
    76437602    break;
     
    76467605
    76477606/* Line 1806 of yacc.c  */
    7648 #line 1922 "parser.yy"
     7607#line 1883 "parser.yy"
    76497608    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
    76507609    break;
     
    76537612
    76547613/* Line 1806 of yacc.c  */
    7655 #line 1927 "parser.yy"
     7614#line 1888 "parser.yy"
    76567615    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    76577616    break;
     
    76607619
    76617620/* Line 1806 of yacc.c  */
    7662 #line 1929 "parser.yy"
     7621#line 1890 "parser.yy"
    76637622    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    76647623    break;
     
    76677626
    76687627/* Line 1806 of yacc.c  */
    7669 #line 1931 "parser.yy"
     7628#line 1892 "parser.yy"
    76707629    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    76717630    break;
     
    76747633
    76757634/* Line 1806 of yacc.c  */
    7676 #line 1936 "parser.yy"
     7635#line 1897 "parser.yy"
    76777636    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    76787637    break;
     
    76817640
    76827641/* Line 1806 of yacc.c  */
    7683 #line 1938 "parser.yy"
     7642#line 1899 "parser.yy"
    76847643    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    76857644    break;
     
    76887647
    76897648/* Line 1806 of yacc.c  */
    7690 #line 1943 "parser.yy"
     7649#line 1904 "parser.yy"
    76917650    {
    76927651                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
     
    76987657
    76997658/* Line 1806 of yacc.c  */
    7700 #line 1948 "parser.yy"
     7659#line 1909 "parser.yy"
    77017660    {
    77027661                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
     
    77087667
    77097668/* Line 1806 of yacc.c  */
    7710 #line 1956 "parser.yy"
     7669#line 1917 "parser.yy"
    77117670    {
    77127671                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
     
    77187677
    77197678/* Line 1806 of yacc.c  */
    7720 #line 1961 "parser.yy"
     7679#line 1922 "parser.yy"
    77217680    {
    77227681                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
     
    77287687
    77297688/* Line 1806 of yacc.c  */
    7730 #line 1966 "parser.yy"
     7689#line 1927 "parser.yy"
    77317690    {
    77327691                        typedefTable.leaveTrait();
     
    77397698
    77407699/* Line 1806 of yacc.c  */
    7741 #line 1976 "parser.yy"
     7700#line 1937 "parser.yy"
    77427701    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    77437702    break;
     
    77467705
    77477706/* Line 1806 of yacc.c  */
    7748 #line 1986 "parser.yy"
     7707#line 1947 "parser.yy"
    77497708    {
    77507709                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77567715
    77577716/* Line 1806 of yacc.c  */
    7758 #line 1991 "parser.yy"
     7717#line 1952 "parser.yy"
    77597718    {
    77607719                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77667725
    77677726/* Line 1806 of yacc.c  */
    7768 #line 1996 "parser.yy"
     7727#line 1957 "parser.yy"
    77697728    {
    77707729                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    77767735
    77777736/* Line 1806 of yacc.c  */
    7778 #line 2004 "parser.yy"
     7737#line 1965 "parser.yy"
    77797738    {
    77807739                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77867745
    77877746/* Line 1806 of yacc.c  */
    7788 #line 2009 "parser.yy"
     7747#line 1970 "parser.yy"
    77897748    {
    77907749                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77967755
    77977756/* Line 1806 of yacc.c  */
    7798 #line 2019 "parser.yy"
     7757#line 1980 "parser.yy"
    77997758    {}
    78007759    break;
     
    78037762
    78047763/* Line 1806 of yacc.c  */
    7805 #line 2021 "parser.yy"
     7764#line 1982 "parser.yy"
    78067765    { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl);    }
    78077766    break;
     
    78107769
    78117770/* Line 1806 of yacc.c  */
    7812 #line 2027 "parser.yy"
     7771#line 1988 "parser.yy"
    78137772    { (yyval.decl) = (yyvsp[(1) - (3)].decl) != nullptr ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    78147773    break;
     
    78177776
    78187777/* Line 1806 of yacc.c  */
    7819 #line 2032 "parser.yy"
     7778#line 1993 "parser.yy"
    78207779    { (yyval.decl) = 0; }
    78217780    break;
     
    78247783
    78257784/* Line 1806 of yacc.c  */
    7826 #line 2040 "parser.yy"
     7785#line 2001 "parser.yy"
    78277786    {}
    78287787    break;
     
    78317790
    78327791/* Line 1806 of yacc.c  */
    7833 #line 2042 "parser.yy"
     7792#line 2003 "parser.yy"
    78347793    {
    78357794                        linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
     
    78417800
    78427801/* Line 1806 of yacc.c  */
    7843 #line 2047 "parser.yy"
     7802#line 2008 "parser.yy"
    78447803    {
    78457804                        linkage = linkageStack.top();
     
    78527811
    78537812/* Line 1806 of yacc.c  */
    7854 #line 2053 "parser.yy"
     7813#line 2014 "parser.yy"
    78557814    {   // mark all fields in list
    78567815                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
     
    78637822
    78647823/* Line 1806 of yacc.c  */
    7865 #line 2068 "parser.yy"
     7824#line 2029 "parser.yy"
    78667825    {
    78677826                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78747833
    78757834/* Line 1806 of yacc.c  */
    7876 #line 2074 "parser.yy"
     7835#line 2035 "parser.yy"
    78777836    {
    78787837                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78857844
    78867845/* Line 1806 of yacc.c  */
    7887 #line 2083 "parser.yy"
     7846#line 2044 "parser.yy"
    78887847    {
    78897848                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78967855
    78977856/* Line 1806 of yacc.c  */
    7898 #line 2089 "parser.yy"
     7857#line 2050 "parser.yy"
    78997858    {
    79007859                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79077866
    79087867/* Line 1806 of yacc.c  */
    7909 #line 2095 "parser.yy"
     7868#line 2056 "parser.yy"
    79107869    {
    79117870                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79187877
    79197878/* Line 1806 of yacc.c  */
    7920 #line 2101 "parser.yy"
     7879#line 2062 "parser.yy"
    79217880    {
    79227881                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79297888
    79307889/* Line 1806 of yacc.c  */
    7931 #line 2107 "parser.yy"
     7890#line 2068 "parser.yy"
    79327891    {
    79337892                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79407899
    79417900/* Line 1806 of yacc.c  */
    7942 #line 2115 "parser.yy"
     7901#line 2076 "parser.yy"
    79437902    {
    79447903                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79517910
    79527911/* Line 1806 of yacc.c  */
    7953 #line 2121 "parser.yy"
     7912#line 2082 "parser.yy"
    79547913    {
    79557914                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79627921
    79637922/* Line 1806 of yacc.c  */
    7964 #line 2129 "parser.yy"
     7923#line 2090 "parser.yy"
    79657924    {
    79667925                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79737932
    79747933/* Line 1806 of yacc.c  */
    7975 #line 2135 "parser.yy"
     7934#line 2096 "parser.yy"
    79767935    {
    79777936                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79847943
    79857944/* Line 1806 of yacc.c  */
     7945#line 2111 "parser.yy"
     7946    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     7947    break;
     7948
     7949  case 544:
     7950
     7951/* Line 1806 of yacc.c  */
     7952#line 2116 "parser.yy"
     7953    { delete (yyvsp[(3) - (5)].str); }
     7954    break;
     7955
     7956  case 545:
     7957
     7958/* Line 1806 of yacc.c  */
     7959#line 2121 "parser.yy"
     7960    { (yyval.decl) = 0; }
     7961    break;
     7962
     7963  case 548:
     7964
     7965/* Line 1806 of yacc.c  */
     7966#line 2128 "parser.yy"
     7967    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     7968    break;
     7969
     7970  case 549:
     7971
     7972/* Line 1806 of yacc.c  */
     7973#line 2134 "parser.yy"
     7974    { (yyval.decl) = 0; }
     7975    break;
     7976
     7977  case 554:
     7978
     7979/* Line 1806 of yacc.c  */
     7980#line 2145 "parser.yy"
     7981    { delete (yyvsp[(3) - (4)].en); }
     7982    break;
     7983
     7984  case 555:
     7985
     7986/* Line 1806 of yacc.c  */
     7987#line 2149 "parser.yy"
     7988    { delete (yyvsp[(1) - (1)].tok); }
     7989    break;
     7990
     7991  case 556:
     7992
     7993/* Line 1806 of yacc.c  */
    79867994#line 2150 "parser.yy"
    7987     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    7988     break;
    7989 
    7990   case 544:
    7991 
    7992 /* Line 1806 of yacc.c  */
    7993 #line 2156 "parser.yy"
    7994     { delete (yyvsp[(3) - (5)].str); }
    7995     break;
    7996 
    7997   case 545:
    7998 
    7999 /* Line 1806 of yacc.c  */
    8000 #line 2161 "parser.yy"
    8001     { (yyval.decl) = 0; }
    8002     break;
    8003 
    8004   case 548:
    8005 
    8006 /* Line 1806 of yacc.c  */
    8007 #line 2168 "parser.yy"
    8008     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    8009     break;
    8010 
    8011   case 549:
    8012 
    8013 /* Line 1806 of yacc.c  */
    8014 #line 2174 "parser.yy"
    8015     { (yyval.decl) = 0; }
    8016     break;
    8017 
    8018   case 554:
    8019 
    8020 /* Line 1806 of yacc.c  */
    8021 #line 2186 "parser.yy"
    8022     { delete (yyvsp[(3) - (4)].en); }
    8023     break;
    8024 
    8025   case 555:
     7995    { delete (yyvsp[(1) - (1)].decl); }
     7996    break;
     7997
     7998  case 557:
     7999
     8000/* Line 1806 of yacc.c  */
     8001#line 2151 "parser.yy"
     8002    { delete (yyvsp[(1) - (1)].decl); }
     8003    break;
     8004
     8005  case 558:
     8006
     8007/* Line 1806 of yacc.c  */
     8008#line 2152 "parser.yy"
     8009    { delete (yyvsp[(1) - (1)].decl); }
     8010    break;
     8011
     8012  case 559:
     8013
     8014/* Line 1806 of yacc.c  */
     8015#line 2187 "parser.yy"
     8016    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8017    break;
     8018
     8019  case 561:
    80268020
    80278021/* Line 1806 of yacc.c  */
    80288022#line 2190 "parser.yy"
    8029     { delete (yyvsp[(1) - (1)].tok); }
    8030     break;
    8031 
    8032   case 556:
    8033 
    8034 /* Line 1806 of yacc.c  */
    8035 #line 2191 "parser.yy"
    8036     { delete (yyvsp[(1) - (1)].decl); }
    8037     break;
    8038 
    8039   case 557:
     8023    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8024    break;
     8025
     8026  case 562:
    80408027
    80418028/* Line 1806 of yacc.c  */
    80428029#line 2192 "parser.yy"
    8043     { delete (yyvsp[(1) - (1)].decl); }
    8044     break;
    8045 
    8046   case 558:
    8047 
    8048 /* Line 1806 of yacc.c  */
    8049 #line 2193 "parser.yy"
    8050     { delete (yyvsp[(1) - (1)].decl); }
    8051     break;
    8052 
    8053   case 559:
    8054 
    8055 /* Line 1806 of yacc.c  */
    8056 #line 2228 "parser.yy"
    80578030    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80588031    break;
    80598032
    8060   case 561:
    8061 
    8062 /* Line 1806 of yacc.c  */
    8063 #line 2231 "parser.yy"
    8064     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8065     break;
    8066 
    8067   case 562:
    8068 
    8069 /* Line 1806 of yacc.c  */
    8070 #line 2233 "parser.yy"
    8071     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8072     break;
    8073 
    80748033  case 563:
    80758034
    80768035/* Line 1806 of yacc.c  */
    8077 #line 2238 "parser.yy"
     8036#line 2197 "parser.yy"
    80788037    {
    80798038                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    80858044
    80868045/* Line 1806 of yacc.c  */
    8087 #line 2243 "parser.yy"
     8046#line 2202 "parser.yy"
    80888047    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80898048    break;
     
    80928051
    80938052/* Line 1806 of yacc.c  */
     8053#line 2207 "parser.yy"
     8054    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8055    break;
     8056
     8057  case 566:
     8058
     8059/* Line 1806 of yacc.c  */
     8060#line 2209 "parser.yy"
     8061    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8062    break;
     8063
     8064  case 567:
     8065
     8066/* Line 1806 of yacc.c  */
     8067#line 2211 "parser.yy"
     8068    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8069    break;
     8070
     8071  case 568:
     8072
     8073/* Line 1806 of yacc.c  */
     8074#line 2216 "parser.yy"
     8075    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8076    break;
     8077
     8078  case 569:
     8079
     8080/* Line 1806 of yacc.c  */
     8081#line 2218 "parser.yy"
     8082    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8083    break;
     8084
     8085  case 570:
     8086
     8087/* Line 1806 of yacc.c  */
     8088#line 2220 "parser.yy"
     8089    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8090    break;
     8091
     8092  case 571:
     8093
     8094/* Line 1806 of yacc.c  */
     8095#line 2222 "parser.yy"
     8096    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8097    break;
     8098
     8099  case 572:
     8100
     8101/* Line 1806 of yacc.c  */
     8102#line 2227 "parser.yy"
     8103    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8104    break;
     8105
     8106  case 573:
     8107
     8108/* Line 1806 of yacc.c  */
     8109#line 2229 "parser.yy"
     8110    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8111    break;
     8112
     8113  case 574:
     8114
     8115/* Line 1806 of yacc.c  */
     8116#line 2238 "parser.yy"
     8117    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8118    break;
     8119
     8120  case 576:
     8121
     8122/* Line 1806 of yacc.c  */
     8123#line 2241 "parser.yy"
     8124    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8125    break;
     8126
     8127  case 577:
     8128
     8129/* Line 1806 of yacc.c  */
     8130#line 2246 "parser.yy"
     8131    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8132    break;
     8133
     8134  case 578:
     8135
     8136/* Line 1806 of yacc.c  */
    80948137#line 2248 "parser.yy"
     8138    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8139    break;
     8140
     8141  case 579:
     8142
     8143/* Line 1806 of yacc.c  */
     8144#line 2250 "parser.yy"
     8145    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8146    break;
     8147
     8148  case 580:
     8149
     8150/* Line 1806 of yacc.c  */
     8151#line 2255 "parser.yy"
    80958152    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    80968153    break;
    80978154
    8098   case 566:
    8099 
    8100 /* Line 1806 of yacc.c  */
    8101 #line 2250 "parser.yy"
     8155  case 581:
     8156
     8157/* Line 1806 of yacc.c  */
     8158#line 2257 "parser.yy"
    81028159    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    81038160    break;
    81048161
    8105   case 567:
    8106 
    8107 /* Line 1806 of yacc.c  */
    8108 #line 2252 "parser.yy"
     8162  case 582:
     8163
     8164/* Line 1806 of yacc.c  */
     8165#line 2259 "parser.yy"
    81098166    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81108167    break;
    81118168
    8112   case 568:
    8113 
    8114 /* Line 1806 of yacc.c  */
    8115 #line 2257 "parser.yy"
     8169  case 583:
     8170
     8171/* Line 1806 of yacc.c  */
     8172#line 2264 "parser.yy"
     8173    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8174    break;
     8175
     8176  case 584:
     8177
     8178/* Line 1806 of yacc.c  */
     8179#line 2266 "parser.yy"
     8180    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8181    break;
     8182
     8183  case 585:
     8184
     8185/* Line 1806 of yacc.c  */
     8186#line 2268 "parser.yy"
     8187    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8188    break;
     8189
     8190  case 589:
     8191
     8192/* Line 1806 of yacc.c  */
     8193#line 2283 "parser.yy"
     8194    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
     8195    break;
     8196
     8197  case 590:
     8198
     8199/* Line 1806 of yacc.c  */
     8200#line 2285 "parser.yy"
     8201    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
     8202    break;
     8203
     8204  case 591:
     8205
     8206/* Line 1806 of yacc.c  */
     8207#line 2287 "parser.yy"
     8208    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8209    break;
     8210
     8211  case 592:
     8212
     8213/* Line 1806 of yacc.c  */
     8214#line 2292 "parser.yy"
     8215    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8216    break;
     8217
     8218  case 593:
     8219
     8220/* Line 1806 of yacc.c  */
     8221#line 2294 "parser.yy"
     8222    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8223    break;
     8224
     8225  case 594:
     8226
     8227/* Line 1806 of yacc.c  */
     8228#line 2296 "parser.yy"
     8229    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8230    break;
     8231
     8232  case 595:
     8233
     8234/* Line 1806 of yacc.c  */
     8235#line 2301 "parser.yy"
     8236    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8237    break;
     8238
     8239  case 596:
     8240
     8241/* Line 1806 of yacc.c  */
     8242#line 2303 "parser.yy"
     8243    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8244    break;
     8245
     8246  case 597:
     8247
     8248/* Line 1806 of yacc.c  */
     8249#line 2305 "parser.yy"
     8250    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8251    break;
     8252
     8253  case 598:
     8254
     8255/* Line 1806 of yacc.c  */
     8256#line 2320 "parser.yy"
     8257    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8258    break;
     8259
     8260  case 600:
     8261
     8262/* Line 1806 of yacc.c  */
     8263#line 2323 "parser.yy"
     8264    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8265    break;
     8266
     8267  case 601:
     8268
     8269/* Line 1806 of yacc.c  */
     8270#line 2325 "parser.yy"
     8271    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8272    break;
     8273
     8274  case 603:
     8275
     8276/* Line 1806 of yacc.c  */
     8277#line 2331 "parser.yy"
     8278    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8279    break;
     8280
     8281  case 604:
     8282
     8283/* Line 1806 of yacc.c  */
     8284#line 2336 "parser.yy"
     8285    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8286    break;
     8287
     8288  case 605:
     8289
     8290/* Line 1806 of yacc.c  */
     8291#line 2338 "parser.yy"
     8292    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8293    break;
     8294
     8295  case 606:
     8296
     8297/* Line 1806 of yacc.c  */
     8298#line 2340 "parser.yy"
     8299    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8300    break;
     8301
     8302  case 607:
     8303
     8304/* Line 1806 of yacc.c  */
     8305#line 2345 "parser.yy"
    81168306    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    81178307    break;
    81188308
    8119   case 569:
    8120 
    8121 /* Line 1806 of yacc.c  */
    8122 #line 2259 "parser.yy"
     8309  case 608:
     8310
     8311/* Line 1806 of yacc.c  */
     8312#line 2347 "parser.yy"
    81238313    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81248314    break;
    81258315
    8126   case 570:
    8127 
    8128 /* Line 1806 of yacc.c  */
    8129 #line 2261 "parser.yy"
     8316  case 609:
     8317
     8318/* Line 1806 of yacc.c  */
     8319#line 2349 "parser.yy"
    81308320    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81318321    break;
    81328322
    8133   case 571:
    8134 
    8135 /* Line 1806 of yacc.c  */
    8136 #line 2263 "parser.yy"
     8323  case 610:
     8324
     8325/* Line 1806 of yacc.c  */
     8326#line 2351 "parser.yy"
    81378327    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81388328    break;
    81398329
    8140   case 572:
    8141 
    8142 /* Line 1806 of yacc.c  */
    8143 #line 2268 "parser.yy"
     8330  case 611:
     8331
     8332/* Line 1806 of yacc.c  */
     8333#line 2356 "parser.yy"
     8334    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8335    break;
     8336
     8337  case 612:
     8338
     8339/* Line 1806 of yacc.c  */
     8340#line 2358 "parser.yy"
    81448341    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81458342    break;
    81468343
    8147   case 573:
    8148 
    8149 /* Line 1806 of yacc.c  */
    8150 #line 2270 "parser.yy"
     8344  case 613:
     8345
     8346/* Line 1806 of yacc.c  */
     8347#line 2360 "parser.yy"
    81518348    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81528349    break;
    81538350
    8154   case 574:
    8155 
    8156 /* Line 1806 of yacc.c  */
    8157 #line 2279 "parser.yy"
     8351  case 614:
     8352
     8353/* Line 1806 of yacc.c  */
     8354#line 2370 "parser.yy"
    81588355    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81598356    break;
    81608357
    8161   case 576:
    8162 
    8163 /* Line 1806 of yacc.c  */
    8164 #line 2282 "parser.yy"
     8358  case 616:
     8359
     8360/* Line 1806 of yacc.c  */
     8361#line 2373 "parser.yy"
    81658362    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81668363    break;
    81678364
    8168   case 577:
    8169 
    8170 /* Line 1806 of yacc.c  */
    8171 #line 2287 "parser.yy"
     8365  case 617:
     8366
     8367/* Line 1806 of yacc.c  */
     8368#line 2375 "parser.yy"
     8369    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8370    break;
     8371
     8372  case 618:
     8373
     8374/* Line 1806 of yacc.c  */
     8375#line 2380 "parser.yy"
     8376    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8377    break;
     8378
     8379  case 619:
     8380
     8381/* Line 1806 of yacc.c  */
     8382#line 2382 "parser.yy"
     8383    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8384    break;
     8385
     8386  case 620:
     8387
     8388/* Line 1806 of yacc.c  */
     8389#line 2384 "parser.yy"
     8390    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8391    break;
     8392
     8393  case 621:
     8394
     8395/* Line 1806 of yacc.c  */
     8396#line 2389 "parser.yy"
     8397    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8398    break;
     8399
     8400  case 622:
     8401
     8402/* Line 1806 of yacc.c  */
     8403#line 2391 "parser.yy"
     8404    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8405    break;
     8406
     8407  case 623:
     8408
     8409/* Line 1806 of yacc.c  */
     8410#line 2393 "parser.yy"
     8411    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8412    break;
     8413
     8414  case 624:
     8415
     8416/* Line 1806 of yacc.c  */
     8417#line 2395 "parser.yy"
     8418    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8419    break;
     8420
     8421  case 625:
     8422
     8423/* Line 1806 of yacc.c  */
     8424#line 2400 "parser.yy"
    81728425    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    81738426    break;
    81748427
    8175   case 578:
    8176 
    8177 /* Line 1806 of yacc.c  */
    8178 #line 2289 "parser.yy"
     8428  case 626:
     8429
     8430/* Line 1806 of yacc.c  */
     8431#line 2402 "parser.yy"
    81798432    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81808433    break;
    81818434
    8182   case 579:
    8183 
    8184 /* Line 1806 of yacc.c  */
    8185 #line 2291 "parser.yy"
     8435  case 627:
     8436
     8437/* Line 1806 of yacc.c  */
     8438#line 2404 "parser.yy"
    81868439    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81878440    break;
    81888441
    8189   case 580:
    8190 
    8191 /* Line 1806 of yacc.c  */
    8192 #line 2296 "parser.yy"
    8193     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8194     break;
    8195 
    8196   case 581:
    8197 
    8198 /* Line 1806 of yacc.c  */
    8199 #line 2298 "parser.yy"
    8200     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8201     break;
    8202 
    8203   case 582:
    8204 
    8205 /* Line 1806 of yacc.c  */
    8206 #line 2300 "parser.yy"
    8207     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8208     break;
    8209 
    8210   case 583:
    8211 
    8212 /* Line 1806 of yacc.c  */
    8213 #line 2305 "parser.yy"
    8214     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8215     break;
    8216 
    8217   case 584:
    8218 
    8219 /* Line 1806 of yacc.c  */
    8220 #line 2307 "parser.yy"
    8221     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8222     break;
    8223 
    8224   case 585:
    8225 
    8226 /* Line 1806 of yacc.c  */
    8227 #line 2309 "parser.yy"
    8228     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8229     break;
    8230 
    8231   case 589:
    8232 
    8233 /* Line 1806 of yacc.c  */
    8234 #line 2324 "parser.yy"
    8235     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    8236     break;
    8237 
    8238   case 590:
    8239 
    8240 /* Line 1806 of yacc.c  */
    8241 #line 2326 "parser.yy"
    8242     { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    8243     break;
    8244 
    8245   case 591:
    8246 
    8247 /* Line 1806 of yacc.c  */
    8248 #line 2328 "parser.yy"
    8249     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8250     break;
    8251 
    8252   case 592:
    8253 
    8254 /* Line 1806 of yacc.c  */
    8255 #line 2333 "parser.yy"
    8256     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8257     break;
    8258 
    8259   case 593:
    8260 
    8261 /* Line 1806 of yacc.c  */
    8262 #line 2335 "parser.yy"
    8263     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8264     break;
    8265 
    8266   case 594:
    8267 
    8268 /* Line 1806 of yacc.c  */
    8269 #line 2337 "parser.yy"
    8270     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8271     break;
    8272 
    8273   case 595:
    8274 
    8275 /* Line 1806 of yacc.c  */
    8276 #line 2342 "parser.yy"
    8277     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8278     break;
    8279 
    8280   case 596:
    8281 
    8282 /* Line 1806 of yacc.c  */
    8283 #line 2344 "parser.yy"
    8284     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8285     break;
    8286 
    8287   case 597:
    8288 
    8289 /* Line 1806 of yacc.c  */
    8290 #line 2346 "parser.yy"
    8291     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8292     break;
    8293 
    8294   case 598:
    8295 
    8296 /* Line 1806 of yacc.c  */
    8297 #line 2361 "parser.yy"
     8442  case 628:
     8443
     8444/* Line 1806 of yacc.c  */
     8445#line 2435 "parser.yy"
    82988446    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82998447    break;
    83008448
    8301   case 600:
    8302 
    8303 /* Line 1806 of yacc.c  */
    8304 #line 2364 "parser.yy"
     8449  case 630:
     8450
     8451/* Line 1806 of yacc.c  */
     8452#line 2438 "parser.yy"
    83058453    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83068454    break;
    83078455
    8308   case 601:
    8309 
    8310 /* Line 1806 of yacc.c  */
    8311 #line 2366 "parser.yy"
     8456  case 631:
     8457
     8458/* Line 1806 of yacc.c  */
     8459#line 2440 "parser.yy"
    83128460    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83138461    break;
    83148462
    8315   case 603:
    8316 
    8317 /* Line 1806 of yacc.c  */
    8318 #line 2372 "parser.yy"
    8319     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8320     break;
    8321 
    8322   case 604:
    8323 
    8324 /* Line 1806 of yacc.c  */
    8325 #line 2377 "parser.yy"
    8326     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8327     break;
    8328 
    8329   case 605:
    8330 
    8331 /* Line 1806 of yacc.c  */
    8332 #line 2379 "parser.yy"
    8333     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8334     break;
    8335 
    8336   case 606:
    8337 
    8338 /* Line 1806 of yacc.c  */
    8339 #line 2381 "parser.yy"
    8340     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8341     break;
    8342 
    8343   case 607:
    8344 
    8345 /* Line 1806 of yacc.c  */
    8346 #line 2386 "parser.yy"
    8347     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8348     break;
    8349 
    8350   case 608:
    8351 
    8352 /* Line 1806 of yacc.c  */
    8353 #line 2388 "parser.yy"
    8354     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8355     break;
    8356 
    8357   case 609:
    8358 
    8359 /* Line 1806 of yacc.c  */
    8360 #line 2390 "parser.yy"
    8361     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8362     break;
    8363 
    8364   case 610:
    8365 
    8366 /* Line 1806 of yacc.c  */
    8367 #line 2392 "parser.yy"
    8368     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8369     break;
    8370 
    8371   case 611:
    8372 
    8373 /* Line 1806 of yacc.c  */
    8374 #line 2397 "parser.yy"
    8375     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8376     break;
    8377 
    8378   case 612:
    8379 
    8380 /* Line 1806 of yacc.c  */
    8381 #line 2399 "parser.yy"
    8382     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8383     break;
    8384 
    8385   case 613:
    8386 
    8387 /* Line 1806 of yacc.c  */
    8388 #line 2401 "parser.yy"
    8389     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8390     break;
    8391 
    8392   case 614:
    8393 
    8394 /* Line 1806 of yacc.c  */
    8395 #line 2411 "parser.yy"
    8396     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8397     break;
    8398 
    8399   case 616:
    8400 
    8401 /* Line 1806 of yacc.c  */
    8402 #line 2414 "parser.yy"
    8403     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8404     break;
    8405 
    8406   case 617:
    8407 
    8408 /* Line 1806 of yacc.c  */
    8409 #line 2416 "parser.yy"
    8410     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8411     break;
    8412 
    8413   case 618:
    8414 
    8415 /* Line 1806 of yacc.c  */
    8416 #line 2421 "parser.yy"
    8417     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8418     break;
    8419 
    8420   case 619:
    8421 
    8422 /* Line 1806 of yacc.c  */
    8423 #line 2423 "parser.yy"
    8424     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8425     break;
    8426 
    8427   case 620:
    8428 
    8429 /* Line 1806 of yacc.c  */
    8430 #line 2425 "parser.yy"
    8431     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8432     break;
    8433 
    8434   case 621:
    8435 
    8436 /* Line 1806 of yacc.c  */
    8437 #line 2430 "parser.yy"
    8438     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8439     break;
    8440 
    8441   case 622:
    8442 
    8443 /* Line 1806 of yacc.c  */
    8444 #line 2432 "parser.yy"
    8445     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8446     break;
    8447 
    8448   case 623:
    8449 
    8450 /* Line 1806 of yacc.c  */
    8451 #line 2434 "parser.yy"
    8452     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8453     break;
    8454 
    8455   case 624:
    8456 
    8457 /* Line 1806 of yacc.c  */
    8458 #line 2436 "parser.yy"
    8459     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8460     break;
    8461 
    8462   case 625:
    8463 
    8464 /* Line 1806 of yacc.c  */
    8465 #line 2441 "parser.yy"
    8466     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8467     break;
    8468 
    8469   case 626:
    8470 
    8471 /* Line 1806 of yacc.c  */
    8472 #line 2443 "parser.yy"
    8473     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8474     break;
    8475 
    8476   case 627:
     8463  case 632:
    84778464
    84788465/* Line 1806 of yacc.c  */
    84798466#line 2445 "parser.yy"
    8480     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8481     break;
    8482 
    8483   case 628:
    8484 
    8485 /* Line 1806 of yacc.c  */
    8486 #line 2476 "parser.yy"
    8487     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8488     break;
    8489 
    8490   case 630:
    8491 
    8492 /* Line 1806 of yacc.c  */
    8493 #line 2479 "parser.yy"
    8494     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8495     break;
    8496 
    8497   case 631:
    8498 
    8499 /* Line 1806 of yacc.c  */
    8500 #line 2481 "parser.yy"
    8501     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8502     break;
    8503 
    8504   case 632:
    8505 
    8506 /* Line 1806 of yacc.c  */
    8507 #line 2486 "parser.yy"
    85088467    {
    85098468                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    85158474
    85168475/* Line 1806 of yacc.c  */
    8517 #line 2491 "parser.yy"
     8476#line 2450 "parser.yy"
    85188477    {
    85198478                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    85258484
    85268485/* Line 1806 of yacc.c  */
    8527 #line 2499 "parser.yy"
     8486#line 2458 "parser.yy"
    85288487    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    85298488    break;
     
    85328491
    85338492/* Line 1806 of yacc.c  */
    8534 #line 2501 "parser.yy"
     8493#line 2460 "parser.yy"
    85358494    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    85368495    break;
     
    85398498
    85408499/* Line 1806 of yacc.c  */
    8541 #line 2503 "parser.yy"
     8500#line 2462 "parser.yy"
    85428501    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85438502    break;
     
    85468505
    85478506/* Line 1806 of yacc.c  */
    8548 #line 2508 "parser.yy"
     8507#line 2467 "parser.yy"
    85498508    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    85508509    break;
     
    85538512
    85548513/* Line 1806 of yacc.c  */
    8555 #line 2510 "parser.yy"
     8514#line 2469 "parser.yy"
    85568515    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85578516    break;
     
    85608519
    85618520/* Line 1806 of yacc.c  */
    8562 #line 2515 "parser.yy"
     8521#line 2474 "parser.yy"
    85638522    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    85648523    break;
     
    85678526
    85688527/* Line 1806 of yacc.c  */
    8569 #line 2517 "parser.yy"
     8528#line 2476 "parser.yy"
    85708529    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85718530    break;
     
    85748533
    85758534/* Line 1806 of yacc.c  */
    8576 #line 2532 "parser.yy"
     8535#line 2491 "parser.yy"
    85778536    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85788537    break;
     
    85818540
    85828541/* Line 1806 of yacc.c  */
    8583 #line 2534 "parser.yy"
     8542#line 2493 "parser.yy"
    85848543    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85858544    break;
     
    85888547
    85898548/* Line 1806 of yacc.c  */
     8549#line 2498 "parser.yy"
     8550    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     8551    break;
     8552
     8553  case 645:
     8554
     8555/* Line 1806 of yacc.c  */
     8556#line 2500 "parser.yy"
     8557    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     8558    break;
     8559
     8560  case 646:
     8561
     8562/* Line 1806 of yacc.c  */
     8563#line 2502 "parser.yy"
     8564    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8565    break;
     8566
     8567  case 647:
     8568
     8569/* Line 1806 of yacc.c  */
     8570#line 2504 "parser.yy"
     8571    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8572    break;
     8573
     8574  case 648:
     8575
     8576/* Line 1806 of yacc.c  */
     8577#line 2506 "parser.yy"
     8578    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8579    break;
     8580
     8581  case 650:
     8582
     8583/* Line 1806 of yacc.c  */
     8584#line 2512 "parser.yy"
     8585    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8586    break;
     8587
     8588  case 651:
     8589
     8590/* Line 1806 of yacc.c  */
     8591#line 2514 "parser.yy"
     8592    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8593    break;
     8594
     8595  case 652:
     8596
     8597/* Line 1806 of yacc.c  */
     8598#line 2516 "parser.yy"
     8599    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8600    break;
     8601
     8602  case 653:
     8603
     8604/* Line 1806 of yacc.c  */
     8605#line 2521 "parser.yy"
     8606    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
     8607    break;
     8608
     8609  case 654:
     8610
     8611/* Line 1806 of yacc.c  */
     8612#line 2523 "parser.yy"
     8613    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8614    break;
     8615
     8616  case 655:
     8617
     8618/* Line 1806 of yacc.c  */
     8619#line 2525 "parser.yy"
     8620    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8621    break;
     8622
     8623  case 656:
     8624
     8625/* Line 1806 of yacc.c  */
     8626#line 2531 "parser.yy"
     8627    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     8628    break;
     8629
     8630  case 657:
     8631
     8632/* Line 1806 of yacc.c  */
     8633#line 2533 "parser.yy"
     8634    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
     8635    break;
     8636
     8637  case 659:
     8638
     8639/* Line 1806 of yacc.c  */
    85908640#line 2539 "parser.yy"
     8641    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
     8642    break;
     8643
     8644  case 660:
     8645
     8646/* Line 1806 of yacc.c  */
     8647#line 2541 "parser.yy"
     8648    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
     8649    break;
     8650
     8651  case 661:
     8652
     8653/* Line 1806 of yacc.c  */
     8654#line 2543 "parser.yy"
     8655    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
     8656    break;
     8657
     8658  case 662:
     8659
     8660/* Line 1806 of yacc.c  */
     8661#line 2545 "parser.yy"
     8662    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
     8663    break;
     8664
     8665  case 664:
     8666
     8667/* Line 1806 of yacc.c  */
     8668#line 2560 "parser.yy"
     8669    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8670    break;
     8671
     8672  case 665:
     8673
     8674/* Line 1806 of yacc.c  */
     8675#line 2562 "parser.yy"
     8676    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8677    break;
     8678
     8679  case 666:
     8680
     8681/* Line 1806 of yacc.c  */
     8682#line 2567 "parser.yy"
    85918683    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    85928684    break;
    85938685
    8594   case 645:
    8595 
    8596 /* Line 1806 of yacc.c  */
    8597 #line 2541 "parser.yy"
     8686  case 667:
     8687
     8688/* Line 1806 of yacc.c  */
     8689#line 2569 "parser.yy"
    85988690    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    85998691    break;
    86008692
    8601   case 646:
    8602 
    8603 /* Line 1806 of yacc.c  */
    8604 #line 2543 "parser.yy"
     8693  case 668:
     8694
     8695/* Line 1806 of yacc.c  */
     8696#line 2571 "parser.yy"
    86058697    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    86068698    break;
    86078699
    8608   case 647:
    8609 
    8610 /* Line 1806 of yacc.c  */
    8611 #line 2545 "parser.yy"
     8700  case 669:
     8701
     8702/* Line 1806 of yacc.c  */
     8703#line 2573 "parser.yy"
    86128704    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    86138705    break;
    86148706
    8615   case 648:
    8616 
    8617 /* Line 1806 of yacc.c  */
    8618 #line 2547 "parser.yy"
     8707  case 670:
     8708
     8709/* Line 1806 of yacc.c  */
     8710#line 2575 "parser.yy"
    86198711    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86208712    break;
    86218713
    8622   case 650:
    8623 
    8624 /* Line 1806 of yacc.c  */
    8625 #line 2553 "parser.yy"
     8714  case 672:
     8715
     8716/* Line 1806 of yacc.c  */
     8717#line 2581 "parser.yy"
    86268718    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86278719    break;
    86288720
    8629   case 651:
    8630 
    8631 /* Line 1806 of yacc.c  */
    8632 #line 2555 "parser.yy"
     8721  case 673:
     8722
     8723/* Line 1806 of yacc.c  */
     8724#line 2583 "parser.yy"
    86338725    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86348726    break;
    86358727
    8636   case 652:
    8637 
    8638 /* Line 1806 of yacc.c  */
    8639 #line 2557 "parser.yy"
     8728  case 674:
     8729
     8730/* Line 1806 of yacc.c  */
     8731#line 2585 "parser.yy"
    86408732    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86418733    break;
    86428734
    8643   case 653:
    8644 
    8645 /* Line 1806 of yacc.c  */
    8646 #line 2562 "parser.yy"
     8735  case 675:
     8736