Changeset 1d4580a


Ignore:
Timestamp:
Aug 14, 2016, 8:36:29 AM (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, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc
Children:
777bfcf
Parents:
46b4259
Message:

more refactoring of parser code

Files:
13 edited

Legend:

Unmodified
Added
Removed
  • doc/LaTeXmacros/common.tex

    r46b4259 r1d4580a  
    1111%% Created On       : Sat Apr  9 10:06:17 2016
    1212%% Last Modified By : Peter A. Buhr
    13 %% Last Modified On : Thu Aug  4 13:22:46 2016
    14 %% Update Count     : 230
     13%% Last Modified On : Sun Aug 14 08:27:29 2016
     14%% Update Count     : 231
    1515%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    1616
     
    154154}%
    155155\newcommand{\etal}{%
    156         \@ifnextchar{.}{\abbrevFont{et al}}%
     156        \@ifnextchar{.}{\abbrevFont{et~al}}%
    157157                {\abbrevFont{et al}.\xspace}%
    158158}%
  • src/Parser/DeclarationNode.cc

    r46b4259 r1d4580a  
    1010// Created On       : Sat May 16 12:34:05 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Aug  9 08:39:20 2016
    13 // Update Count     : 169
     12// Last Modified On : Sat Aug 13 18:56:58 2016
     13// Update Count     : 171
    1414//
    1515
     
    470470
    471471                // there may be typedefs chained onto the type
    472                 if ( o->get_link() ) {
    473                         set_link( o->get_link()->clone() );
     472                if ( o->get_next() ) {
     473                        set_last( o->get_next()->clone() );
    474474                } // if
    475475        } // if
     
    757757DeclarationNode *DeclarationNode::appendList( DeclarationNode *node ) {
    758758        if ( node != 0 ) {
    759                 set_link( node );
     759                set_last( node );
    760760        } // if
    761761        return this;
     
    794794                        errors.append( e );
    795795                } // try
    796                 cur = dynamic_cast<DeclarationNode *>( cur->get_link() );
     796                cur = dynamic_cast<DeclarationNode *>( cur->get_next() );
    797797        } // while
    798798        if ( ! errors.isEmpty() ) {
     
    831831                        errors.append( e );
    832832                } // try
    833                 cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
     833                cur = dynamic_cast< DeclarationNode *>( cur->get_next() );
    834834        } // while
    835835        if ( ! errors.isEmpty() ) {
     
    848848                        errors.append( e );
    849849                } // try
    850                 cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
     850                cur = dynamic_cast< DeclarationNode *>( cur->get_next() );
    851851        } // while
    852852        if ( ! errors.isEmpty() ) {
  • src/Parser/ExpressionNode.cc

    r46b4259 r1d4580a  
    1010// Created On       : Sat May 16 13:17:07 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Aug 10 11:07:38 2016
    13 // Update Count     : 486
     12// Last Modified On : Thu Aug 11 20:24:36 2016
     13// Update Count     : 487
    1414//
    1515
     
    309309
    310310//##############################################################################
    311  
    312 // ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
    313 //      if ( init_ == 0 )
    314 //              init = 0;
    315 //      else {
    316 //              DeclarationNode *decl;
    317 //              ExpressionNode *exp;
    318 
    319 //              if (( decl = dynamic_cast<DeclarationNode *>(init_) ) != 0)
    320 //                      init = new StatementNode( decl );
    321 //              else if (( exp = dynamic_cast<ExpressionNode *>( init_)) != 0)
    322 //                      init = new StatementNode( StatementNode::Exp, exp );
    323 //              else
    324 //                      throw SemanticError("Error in for control expression");
    325 //      }
    326 // }
    327 
    328 // ForCtlExprNode::ForCtlExprNode( const ForCtlExprNode &other )
    329 //      : ExpressionNode( other ), init( maybeClone( other.init ) ), condition( maybeClone( other.condition ) ), change( maybeClone( other.change ) ) {
    330 // }
    331 
    332 // ForCtlExprNode::~ForCtlExprNode() {
    333 //      delete init;
    334 //      delete condition;
    335 //      delete change;
    336 // }
    337 
    338 // Expression *ForCtlExprNode::build() const {
    339 //      // this shouldn't be used!
    340 //      assert( false );
    341 //      return 0;
    342 // }
    343 
    344 // void ForCtlExprNode::print( std::ostream &os, int indent ) const{
    345 //      os << string( indent,' ' ) << "For Control Expression -- :" << endl;
    346 
    347 //      os << string( indent + 2, ' ' ) << "initialization:" << endl;
    348 //      if ( init != 0 )
    349 //              init->printList( os, indent + 4 );
    350 
    351 //      os << string( indent + 2, ' ' ) << "condition: " << endl;
    352 //      if ( condition != 0 )
    353 //              condition->print( os, indent + 4 );
    354 //      os << string( indent + 2, ' ' ) << "increment: " << endl;
    355 //      if ( change != 0 )
    356 //              change->print( os, indent + 4 );
    357 // }
    358 
    359 // void ForCtlExprNode::printOneLine( std::ostream &, int indent ) const {
    360 //      assert( false );
    361 // }
    362 
    363 //##############################################################################
    364311
    365312Expression *build_typevalue( DeclarationNode *decl ) {
  • src/Parser/InitializerNode.cc

    r46b4259 r1d4580a  
    1010// Created On       : Sat May 16 13:20:24 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Jul  4 15:37:15 2016
    13 // Update Count     : 15
     12// Last Modified On : Sat Aug 13 18:55:11 2016
     13// Update Count     : 18
    1414//
    1515
     
    2525        : expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
    2626        if ( aggrp )
    27                 kids = dynamic_cast< InitializerNode *>( get_link() );
     27                kids = dynamic_cast< InitializerNode *>( get_next() );
    2828
    2929        if ( kids != 0 )
    30                 set_link( 0 );
     30                set_last( 0 );
    3131}
    3232
     
    3434        : expr( 0 ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
    3535        if ( init != 0 )
    36                 set_link(init);
     36                set_last( init );
    3737
    3838        if ( aggrp )
    39                 kids = dynamic_cast< InitializerNode *>( get_link() );
     39                kids = dynamic_cast< InitializerNode *>( get_next() );
    4040
    4141        if ( kids != 0 )
     
    5858                        while ( curdes != 0) {
    5959                                curdes->printOneLine(os);
    60                                 curdes = (ExpressionNode *)(curdes->get_link());
     60                                curdes = (ExpressionNode *)(curdes->get_next());
    6161                                if ( curdes ) os << ", ";
    6262                        } // while
     
    7272
    7373        InitializerNode *moreInit;
    74         if  ( get_link() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_link() ) ) != 0) )
     74        if  ( get_next() != 0 && ((moreInit = dynamic_cast< InitializerNode * >( get_next() ) ) != 0) )
    7575                moreInit->printOneLine( os );
    7676}
  • src/Parser/ParseNode.cc

    r46b4259 r1d4580a  
    1010// Created On       : Sat May 16 13:26:29 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Aug  7 23:32:47 2016
    13 // Update Count     : 94
     12// Last Modified On : Sat Aug 13 18:55:35 2016
     13// Update Count     : 98
    1414//
    1515
     
    3131        ParseNode *current = this;
    3232
    33         while ( current->get_link() != 0 )
    34         current = current->get_link();
    35 
     33        while ( current->get_next() != 0 )
     34        current = current->get_next();
    3635        return current;
    3736}
    3837
    39 ParseNode *ParseNode::set_link( ParseNode *next_ ) {
     38ParseNode *ParseNode::set_last( ParseNode *next_ ) {
    4039        if ( next_ != 0 ) get_last()->next = next_;
    4140        return this;
     
    5453
    5554ParseNode &ParseNode::operator,( ParseNode &p ) {
    56         set_link( &p );
    57 
     55        set_last( &p );
    5856        return *this;
    5957}
  • src/Parser/ParseNode.h

    r46b4259 r1d4580a  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 11 12:24:11 2016
    13 // Update Count     : 443
     12// Last Modified On : Sun Aug 14 08:09:54 2016
     13// Update Count     : 469
    1414//
    1515
     
    4545        virtual ~ParseNode();
    4646
    47         ParseNode *get_link() const { return next; }
     47        ParseNode *get_next() const { return next; }
     48        ParseNode *set_next( ParseNode *newlink ) { next = newlink; return this; }
    4849        ParseNode *get_last();
    49         ParseNode *set_link( ParseNode * );
    50         void set_next( ParseNode *newlink ) { next = newlink; }
     50        ParseNode *set_last( ParseNode * );
    5151
    5252        virtual ParseNode *clone() const { return 0; };
     
    343343        ~StatementNode();
    344344
    345         static StatementNode *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
    346 
    347345        StatementNode *set_block( StatementNode *b ) { block = b; return this; }
    348346        StatementNode *get_block() const { return block; }
     
    357355
    358356        void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
    359         void setCatchRest( bool newVal ) { isCatchRest = newVal; }
    360 
    361         std::string get_target() const;
     357
     358        void setCatchRest( bool newVal ) { catchAny = newVal; }
    362359
    363360        // StatementNode *add_controlexp( ExpressionNode * );
     
    368365        virtual StatementNode *clone() const;
    369366        virtual Statement *build() const;
    370   private:
     367  public:
    371368        static const char *StType[];
    372369        Type type;
     
    374371        StatementNode *block;
    375372        std::list<std::string> labels;
    376         std::string *target;                            // target label for jump statements
     373        std::string *target;                                                            // target label for jump statements
    377374        DeclarationNode *decl;
    378         bool isCatchRest;
     375        bool catchAny;
    379376}; // StatementNode
    380377
    381378class StatementNode2 : public StatementNode {
    382379  public:
    383         StatementNode2() {}
     380        StatementNode2() { stmt = nullptr; }
    384381        StatementNode2( Statement *stmt ) : stmt( stmt ) {}
     382        StatementNode2( DeclarationNode *decl );
    385383        virtual ~StatementNode2() {}
    386384
     
    392390                return this;
    393391        }
     392        virtual std::list<std::string> get_labels() const { assert( false ); return StatementNode::get_labels(); }
     393
    394394        virtual StatementNode *append_last_case( StatementNode * );
    395         virtual std::list<std::string> get_labels() const { assert( false ); return StatementNode::get_labels(); }
    396395
    397396        virtual void print( std::ostream &os, int indent = 0 ) {}
     
    401400}; // StatementNode
    402401
     402Statement *build_expr( ExpressionNode *ctl );
     403
    403404struct ForCtl {
    404405        ForCtl( ExpressionNode *expr, ExpressionNode *condition, ExpressionNode *change ) :
    405                 init( new StatementNode( StatementNode::Exp, expr ) ), condition( condition ), change( change ) {}
     406                init( new StatementNode2( build_expr( expr ) ) ), condition( condition ), change( change ) {}
    406407        ForCtl( DeclarationNode *decl, ExpressionNode *condition, ExpressionNode *change ) :
    407                 init( new StatementNode( decl ) ), condition( condition ), change( change ) {}
     408                init( new StatementNode2( decl ) ), condition( condition ), change( change ) {}
    408409
    409410        StatementNode *init;
     
    412413};
    413414
    414 Statement *build_expr( ExpressionNode *ctl );
    415415Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt );
    416416Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt );
     
    423423Statement *build_return( ExpressionNode *ctl );
    424424Statement *build_throw( ExpressionNode *ctl );
     425Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt );
     426Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny = false );
     427Statement *build_finally( StatementNode *stmt );
    425428
    426429//##############################################################################
     
    429432  public:
    430433        CompoundStmtNode();
    431         CompoundStmtNode( const std::string * );
    432434        CompoundStmtNode( StatementNode * );
    433435        ~CompoundStmtNode();
     
    477479                        errors.append( e );
    478480                } // try
    479                 cur = dynamic_cast< NodeType *>( cur->get_link() );
     481                cur = dynamic_cast< NodeType *>( cur->get_next() );
    480482        } // while
    481483        if ( ! errors.isEmpty() ) {
  • src/Parser/StatementNode.cc

    r46b4259 r1d4580a  
    1010// Created On       : Sat May 16 14:59:41 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 11 16:19:45 2016
    13 // Update Count     : 210
     12// Last Modified On : Sun Aug 14 08:09:31 2016
     13// Update Count     : 271
    1414//
    1515
     
    3434};
    3535
    36 StatementNode::StatementNode() : ParseNode(), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
    37 
    38 StatementNode::StatementNode( const string *name ) : ParseNode( name ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {}
    39 
    40 StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), isCatchRest ( false ) {
     36StatementNode::StatementNode() : ParseNode(), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), catchAny( false ) {}
     37
     38StatementNode::StatementNode( const string *name ) : ParseNode( name ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), decl( 0 ), catchAny( false ) { assert( false ); }
     39
     40StatementNode::StatementNode( DeclarationNode *decl ) : type( Decl ), control( 0 ), block( 0 ), labels( 0 ), target( 0 ), catchAny( false ) {
     41        assert( false );
    4142        if ( decl ) {
    4243                if ( DeclarationNode *agg = decl->extractAggregate() ) {
     
    4647                        nextStmt->decl = decl;
    4748                        next = nextStmt;
    48                         if ( decl->get_link() ) {
    49                                 next->set_next( new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) ) );
     49                        if ( decl->get_next() ) {
     50                                next->set_next( new StatementNode( dynamic_cast<DeclarationNode *>( decl->get_next() ) ) );
    5051                                decl->set_next( 0 );
    5152                        } // if
    5253                } else {
    53                         if ( decl->get_link() ) {
    54                                 next = new StatementNode( dynamic_cast< DeclarationNode* >( decl->get_link() ) );
     54                        if ( decl->get_next() ) {
     55                                next = new StatementNode( dynamic_cast<DeclarationNode *>( decl->get_next() ) );
    5556                                decl->set_next( 0 );
    5657                        } // if
     
    6061}
    6162
    62 StatementNode::StatementNode( Type t, ExpressionNode *ctrl_label, StatementNode *block ) : type( t ), control( ctrl_label ), block( block ), labels( 0 ), target( 0 ), decl( 0 ), isCatchRest ( false ) {
     63StatementNode2::StatementNode2( DeclarationNode *decl ) {
     64        if ( decl ) {
     65                DeclarationNode *agg = decl->extractAggregate();
     66                if ( agg ) {
     67                        StatementNode *nextStmt = new StatementNode;
     68                        nextStmt->type = Decl;
     69                        nextStmt->decl = decl;
     70                        next = nextStmt;
     71                        if ( decl->get_next() ) {
     72                                next->set_next( new StatementNode2( dynamic_cast<DeclarationNode *>(decl->get_next()) ) );
     73                                decl->set_next( 0 );
     74                        } // if
     75                } else {
     76                        if ( decl->get_next() ) {
     77                                next = new StatementNode2( dynamic_cast<DeclarationNode *>( decl->get_next() ) );
     78                                decl->set_next( 0 );
     79                        } // if
     80                        agg = decl;
     81                } // if
     82                stmt = new DeclStmt( noLabels, maybeBuild<Declaration>(agg) );
     83        } else {
     84                assert( false );
     85        } // if
     86}
     87
     88StatementNode::StatementNode( Type t, ExpressionNode *ctrl_label, StatementNode *block ) : type( t ), control( ctrl_label ), block( block ), labels( 0 ), target( 0 ), decl( 0 ), catchAny( false ) {
    6389        this->control = ( t == Default ) ? 0 : control;
    6490}
    6591
    66 StatementNode::StatementNode( Type t, string *target ) : type( t ), control( 0 ), block( 0 ), labels( 0 ), target( target ), decl( 0 ), isCatchRest ( false ) {}
     92StatementNode::StatementNode( Type t, string *target ) : type( t ), control( 0 ), block( 0 ), labels( 0 ), target( target ), decl( 0 ), catchAny( false ) {}
    6793
    6894StatementNode::~StatementNode() {
     
    7399}
    74100
    75 StatementNode * StatementNode::newCatchStmt( DeclarationNode *d, StatementNode *s, bool catchRestP ) {
    76         StatementNode *ret = new StatementNode( StatementNode::Catch, 0, s );
    77         ret->addDeclaration( d );
    78         ret->setCatchRest( catchRestP );
    79 
    80         return ret;
    81 }
    82 
    83 std::string StatementNode::get_target() const{
    84         if ( target )
    85                 return *target;
    86 
    87         return string("");
    88 }
    89 
    90101StatementNode * StatementNode::clone() const {
     102        assert( false );
    91103        StatementNode *newnode = new StatementNode( type, maybeClone( control ), maybeClone( block ) );
    92104        if ( target ) {
     
    112124                        block = stmt;
    113125                else
    114                         block->set_link( stmt );
     126                        block->set_last( stmt );
    115127        } // if
    116128        return this;
     
    120132        assert( false );
    121133        if ( stmt != 0 ) {
    122                 StatementNode *next = ( StatementNode *)get_link();
     134                StatementNode *next = ( StatementNode *)get_next();
    123135                if ( next && ( next->get_type() == StatementNode::Case || next->get_type() == StatementNode::Default ) )
    124136                        next->append_last_case( stmt );
     
    127139                                block = stmt;
    128140                        else
    129                                 block->set_link( stmt );
     141                                block->set_last( stmt );
    130142        } // if
    131143        return this;
     
    134146StatementNode *StatementNode2::append_last_case( StatementNode *stmt ) {
    135147        StatementNode *prev = this;
    136         for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_link() ) {
     148        // find end of list and maintain previous pointer
     149        for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
    137150                StatementNode2 *node = dynamic_cast<StatementNode2 *>(curr);
    138151                assert( node );
     
    140153                prev = curr;
    141154        } // for
     155        // conver from StatementNode list to Statement list
    142156        StatementNode2 *node = dynamic_cast<StatementNode2 *>(prev);
    143157        std::list<Statement *> stmts;
    144158        buildList( stmt, stmts );
    145         CaseStmt * caseStmt;
    146         caseStmt = dynamic_cast<CaseStmt *>(node->stmt);
     159        // splice any new Statements to end of currents Statements
     160        CaseStmt * caseStmt = dynamic_cast<CaseStmt *>(node->stmt);
    147161        caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
    148162        return this;
     
    177191                                os << string( indent + ParseNode::indent_by, ' ' ) << "Declaration: " << endl;
    178192                                decl->print( os, indent + 2 * ParseNode::indent_by );
    179                         } else if ( isCatchRest ) {
     193                        } else if ( catchAny ) {
    180194                                os << string( indent + ParseNode::indent_by, ' ' ) << "Catches the rest " << endl;
    181195                        } else {
     
    191205                        block->printList( os, indent + 2 * ParseNode::indent_by );
    192206                } // if
    193                 if ( target ) {
    194                         os << string( indent + ParseNode::indent_by, ' ' ) << "Target: " << get_target() << endl;
    195                 } // if
    196207                break;
    197208        } // switch
     
    208219        } // if
    209220
    210         // try {
    211221        buildList<Statement, StatementNode>( get_block(), branches );
    212222
     
    214224          case Decl:
    215225                return new DeclStmt( labs, maybeBuild< Declaration >( decl ) );
     226                assert( false );
    216227          case Exp:
    217                 {
    218                         Expression *e = maybeBuild< Expression >( get_control() );
    219 
    220                         if ( e )
    221                                 return new ExprStmt( labs, e );
    222                         else
    223                                 return new NullStmt( labs );
    224                 }
     228                // {
     229                //      Expression *e = maybeBuild< Expression >( get_control() );
     230
     231                //      if ( e )
     232                //              return new ExprStmt( labs, e );
     233                //      else
     234                //              return new NullStmt( labs );
     235                // }
    225236                assert( false );
    226237          case If:
     
    279290                assert( false );
    280291          case Goto:
    281                 // {
    282                 //      if ( get_target() == "" ) {                                     // computed goto
    283                 //              assert( get_control() != 0 );
    284                 //              return new BranchStmt( labs, maybeBuild<Expression>(get_control()), BranchStmt::Goto );
    285                 //      } // if
    286 
    287                 //      return new BranchStmt( labs, get_target(), BranchStmt::Goto );
    288                 // }
    289292                assert( false );
    290293          case Break:
    291                 // return new BranchStmt( labs, get_target(), BranchStmt::Break );
    292294                assert( false );
    293295          case Continue:
    294                 // return new BranchStmt( labs, get_target(), BranchStmt::Continue );
    295296                assert( false );
    296297          case Return:
     
    303304                assert( false );
    304305          case Try:
    305                 {
    306                         assert( branches.size() >= 0 );
    307                         CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>( branches.front());
    308                         branches.pop_front();
    309                         FinallyStmt *finallyBlock = 0;
    310                         if ( ( finallyBlock = dynamic_cast<FinallyStmt *>( branches.back())) ) {
    311                                 branches.pop_back();
    312                         } // if
    313                         return new TryStmt( labs, tryBlock, branches, finallyBlock );
    314                 }
     306                // {
     307                //      assert( branches.size() >= 0 );
     308                //      CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>( branches.front());
     309                //      branches.pop_front();
     310                //      FinallyStmt *finallyBlock = 0;
     311                //      if ( ( finallyBlock = dynamic_cast<FinallyStmt *>( branches.back())) ) {
     312                //              branches.pop_back();
     313                //      } // if
     314                //      return new TryStmt( labs, tryBlock, branches, finallyBlock );
     315                // }
     316                assert( false );
    315317          case Catch:
    316                 {
    317                         assert( branches.size() == 1 );
    318 
    319                         return new CatchStmt( labs, maybeBuild< Declaration >( decl ), branches.front(), isCatchRest );
    320                 }
     318                // {
     319                //      assert( branches.size() == 1 );
     320
     321                //      return new CatchStmt( labs, maybeBuild< Declaration >( decl ), branches.front(), catchAny );
     322                // }
     323                assert( false );
    321324          case Finally:
    322                 {
    323                         assert( branches.size() == 1 );
    324                         CompoundStmt *block = dynamic_cast<CompoundStmt *>( branches.front() );
    325                         assert( block != 0 );
    326 
    327                         return new FinallyStmt( labs, block );
    328                 }
     325                // {
     326                //      assert( branches.size() == 1 );
     327                //      CompoundStmt *block = dynamic_cast<CompoundStmt *>( branches.front() );
     328                //      assert( block != 0 );
     329
     330                //      return new FinallyStmt( labs, block );
     331                // }
     332                assert( false );
    329333          case Asm:
    330334                assert( false );
    331335          default:
    332                 // shouldn't be here
     336                assert( false );
    333337                return 0;
    334338        } // switch
     
    422426}
    423427
     428Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) {
     429        std::list<Statement *> branches;
     430        buildList<Statement, StatementNode>( catch_stmt, branches );
     431        CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>(maybeBuild<Statement>(try_stmt));
     432        assert( tryBlock );
     433        FinallyStmt *finallyBlock = dynamic_cast<FinallyStmt *>(maybeBuild<Statement>(finally_stmt) );
     434        return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
     435}
     436Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny ) {
     437        std::list<Statement *> branches;
     438        buildList<Statement, StatementNode>( stmt, branches );
     439        assert( branches.size() == 1 );
     440        return new CatchStmt( noLabels, maybeBuild<Declaration>(decl), branches.front(), catchAny );
     441}
     442Statement *build_finally( StatementNode *stmt ) {
     443        std::list<Statement *> branches;
     444        buildList<Statement, StatementNode>( stmt, branches );
     445        assert( branches.size() == 1 );
     446        return new FinallyStmt( noLabels, dynamic_cast<CompoundStmt *>( branches.front() ) );
     447}
     448
    424449
    425450CompoundStmtNode::CompoundStmtNode() : first( 0 ), last( 0 ) {}
    426 
    427 CompoundStmtNode::CompoundStmtNode( const string *name_ ) : StatementNode( name_ ), first( 0 ), last( 0 ) {}
    428451
    429452CompoundStmtNode::CompoundStmtNode( StatementNode *stmt ) : first( stmt ) {
     
    441464void CompoundStmtNode::add_statement( StatementNode *stmt ) {
    442465        if ( stmt != 0 ) {
    443                 last->set_link( stmt );
    444                 last = ( StatementNode *)( stmt->get_link());
     466                last->set_last( stmt );
     467                last = ( StatementNode *)( stmt->get_next());
    445468        } // if
    446469}
  • src/Parser/TypeData.cc

    r46b4259 r1d4580a  
    1010// Created On       : Sat May 16 15:12:51 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Aug  7 07:51:48 2016
    13 // Update Count     : 58
     12// Last Modified On : Sat Aug 13 18:38:41 2016
     13// Update Count     : 59
    1414//
    1515
     
    495495                        decl = new FunctionDecl( name, sc, linkage, buildFunction(), 0, isInline, isNoreturn );
    496496                } // if
    497                 for ( DeclarationNode *cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_link() ) ) {
     497                for ( DeclarationNode *cur = function->idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
    498498                        if ( cur->get_name() != "" ) {
    499499                                decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->get_name() );
     
    909909        buildList( enumeration->constants, ret->get_members() );
    910910        std::list< Declaration * >::iterator members = ret->get_members().begin();
    911         for ( const DeclarationNode *cur = enumeration->constants; cur != NULL; cur = dynamic_cast<DeclarationNode *>( cur->get_link() ), ++members ) {
     911        for ( const DeclarationNode *cur = enumeration->constants; cur != NULL; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ), ++members ) {
    912912                if ( cur->get_enumeratorValue() != NULL ) {
    913913                        ObjectDecl *member = dynamic_cast<ObjectDecl *>(*members);
  • src/Parser/parser.cc

    r46b4259 r1d4580a  
    10351035     657,   658,   659,   660,   661,   662,   663,   673,   680,   682,
    10361036     692,   693,   698,   700,   706,   708,   712,   713,   718,   723,
    1037      726,   728,   730,   740,   742,   753,   754,   756,   761,   763,
    1038      767,   768,   773,   774,   778,   783,   784,   788,   790,   796,
    1039      797,   801,   803,   805,   807,   813,   814,   818,   820,   825,
    1040      827,   829,   834,   836,   841,   843,   847,   850,   854,   857,
    1041      861,   863,   865,   867,   872,   874,   876,   885,   887,   889,
    1042      891,   893,   898,   900,   902,   904,   909,   922,   923,   928,
    1043      930,   935,   939,   941,   943,   945,   947,   953,   954,   960,
    1044      961,   965,   966,   971,   973,   979,   980,   982,   987,   989,
    1045      996,   998,  1002,  1003,  1008,  1010,  1014,  1015,  1019,  1021,
    1046     1025,  1026,  1030,  1031,  1035,  1036,  1051,  1052,  1053,  1054,
    1047     1055,  1059,  1064,  1071,  1081,  1086,  1091,  1099,  1104,  1109,
    1048     1114,  1119,  1127,  1149,  1154,  1161,  1163,  1170,  1175,  1180,
    1049     1191,  1196,  1201,  1206,  1211,  1220,  1225,  1233,  1234,  1235,
    1050     1236,  1242,  1247,  1255,  1256,  1257,  1258,  1262,  1263,  1264,
    1051     1265,  1270,  1271,  1280,  1281,  1286,  1287,  1292,  1294,  1296,
    1052     1298,  1300,  1303,  1302,  1314,  1315,  1317,  1327,  1328,  1333,
    1053     1337,  1339,  1341,  1343,  1345,  1347,  1349,  1351,  1356,  1358,
    1054     1360,  1362,  1364,  1366,  1368,  1370,  1372,  1374,  1376,  1378,
    1055     1380,  1386,  1387,  1389,  1391,  1393,  1398,  1399,  1405,  1406,
    1056     1408,  1410,  1415,  1417,  1419,  1421,  1426,  1427,  1429,  1431,
    1057     1436,  1437,  1439,  1444,  1445,  1447,  1449,  1454,  1456,  1458,
    1058     1463,  1464,  1468,  1470,  1476,  1475,  1479,  1481,  1486,  1488,
    1059     1494,  1495,  1500,  1501,  1503,  1504,  1513,  1514,  1516,  1518,
    1060     1523,  1525,  1531,  1532,  1534,  1537,  1540,  1545,  1546,  1551,
    1061     1556,  1560,  1562,  1568,  1567,  1574,  1576,  1582,  1583,  1591,
    1062     1592,  1596,  1597,  1598,  1600,  1602,  1609,  1610,  1612,  1614,
    1063     1619,  1620,  1626,  1627,  1631,  1632,  1637,  1638,  1639,  1641,
    1064     1649,  1650,  1652,  1655,  1657,  1661,  1662,  1663,  1665,  1667,
    1065     1671,  1676,  1684,  1685,  1694,  1696,  1701,  1702,  1703,  1707,
    1066     1708,  1709,  1713,  1714,  1715,  1719,  1720,  1721,  1726,  1727,
    1067     1728,  1729,  1735,  1736,  1738,  1743,  1744,  1749,  1750,  1751,
    1068     1752,  1753,  1768,  1769,  1774,  1775,  1781,  1783,  1786,  1788,
    1069     1790,  1813,  1814,  1816,  1818,  1823,  1824,  1826,  1831,  1836,
    1070     1837,  1843,  1842,  1846,  1850,  1852,  1854,  1860,  1861,  1866,
    1071     1871,  1873,  1878,  1880,  1881,  1883,  1888,  1890,  1892,  1897,
    1072     1899,  1904,  1909,  1917,  1923,  1922,  1936,  1937,  1942,  1943,
    1073     1947,  1952,  1957,  1965,  1970,  1981,  1982,  1993,  1994,  2000,
    1074     2001,  2005,  2006,  2007,  2010,  2009,  2020,  2029,  2035,  2041,
    1075     2050,  2056,  2062,  2068,  2074,  2082,  2088,  2096,  2102,  2111,
    1076     2112,  2113,  2117,  2121,  2123,  2128,  2129,  2133,  2134,  2139,
    1077     2145,  2146,  2149,  2151,  2152,  2156,  2157,  2158,  2159,  2193,
    1078     2195,  2196,  2198,  2203,  2208,  2213,  2215,  2217,  2222,  2224,
    1079     2226,  2228,  2233,  2235,  2244,  2246,  2247,  2252,  2254,  2256,
    1080     2261,  2263,  2265,  2270,  2272,  2274,  2283,  2284,  2285,  2289,
    1081     2291,  2293,  2298,  2300,  2302,  2307,  2309,  2311,  2326,  2328,
    1082     2329,  2331,  2336,  2337,  2342,  2344,  2346,  2351,  2353,  2355,
    1083     2357,  2362,  2364,  2366,  2376,  2378,  2379,  2381,  2386,  2388,
    1084     2390,  2395,  2397,  2399,  2401,  2406,  2408,  2410,  2441,  2443,
    1085     2444,  2446,  2451,  2456,  2464,  2466,  2468,  2473,  2475,  2480,
    1086     2482,  2496,  2497,  2499,  2504,  2506,  2508,  2510,  2512,  2517,
    1087     2518,  2520,  2522,  2527,  2529,  2531,  2537,  2539,  2541,  2545,
    1088     2547,  2549,  2551,  2565,  2566,  2568,  2573,  2575,  2577,  2579,
    1089     2581,  2586,  2587,  2589,  2591,  2596,  2598,  2600,  2606,  2607,
    1090     2609,  2618,  2621,  2623,  2626,  2628,  2630,  2643,  2644,  2646,
    1091     2651,  2653,  2655,  2657,  2659,  2664,  2665,  2667,  2669,  2674,
    1092     2676,  2684,  2685,  2686,  2691,  2692,  2696,  2698,  2700,  2702,
    1093     2704,  2706,  2713,  2715,  2717,  2719,  2721,  2723,  2725,  2727,
    1094     2729,  2731,  2736,  2738,  2740,  2745,  2771,  2772,  2774,  2778,
    1095     2779,  2783,  2785,  2787,  2789,  2791,  2793,  2800,  2802,  2804,
    1096     2806,  2808,  2810,  2815,  2820,  2822,  2824,  2842,  2844,  2849,
    1097     2850
     1037     726,   728,   730,   740,   742,   753,   754,   756,   760,   762,
     1038     766,   767,   772,   773,   777,   782,   783,   787,   789,   795,
     1039     796,   800,   802,   804,   806,   812,   813,   817,   819,   824,
     1040     826,   828,   833,   835,   840,   842,   846,   849,   853,   856,
     1041     860,   862,   864,   866,   871,   873,   875,   880,   882,   884,
     1042     886,   888,   893,   895,   897,   899,   904,   916,   917,   922,
     1043     924,   929,   933,   935,   937,   939,   941,   947,   948,   954,
     1044     955,   959,   960,   965,   967,   973,   974,   976,   981,   983,
     1045     990,   992,   996,   997,  1002,  1004,  1008,  1009,  1013,  1015,
     1046    1019,  1020,  1024,  1025,  1029,  1030,  1045,  1046,  1047,  1048,
     1047    1049,  1053,  1058,  1065,  1075,  1080,  1085,  1093,  1098,  1103,
     1048    1108,  1113,  1121,  1143,  1148,  1155,  1157,  1164,  1169,  1174,
     1049    1185,  1190,  1195,  1200,  1205,  1214,  1219,  1227,  1228,  1229,
     1050    1230,  1236,  1241,  1249,  1250,  1251,  1252,  1256,  1257,  1258,
     1051    1259,  1264,  1265,  1274,  1275,  1280,  1281,  1286,  1288,  1290,
     1052    1292,  1294,  1297,  1296,  1308,  1309,  1311,  1321,  1322,  1327,
     1053    1331,  1333,  1335,  1337,  1339,  1341,  1343,  1345,  1350,  1352,
     1054    1354,  1356,  1358,  1360,  1362,  1364,  1366,  1368,  1370,  1372,
     1055    1374,  1380,  1381,  1383,  1385,  1387,  1392,  1393,  1399,  1400,
     1056    1402,  1404,  1409,  1411,  1413,  1415,  1420,  1421,  1423,  1425,
     1057    1430,  1431,  1433,  1438,  1439,  1441,  1443,  1448,  1450,  1452,
     1058    1457,  1458,  1462,  1464,  1470,  1469,  1473,  1475,  1480,  1482,
     1059    1488,  1489,  1494,  1495,  1497,  1498,  1507,  1508,  1510,  1512,
     1060    1517,  1519,  1525,  1526,  1528,  1531,  1534,  1539,  1540,  1545,
     1061    1550,  1554,  1556,  1562,  1561,  1568,  1570,  1576,  1577,  1585,
     1062    1586,  1590,  1591,  1592,  1594,  1596,  1603,  1604,  1606,  1608,
     1063    1613,  1614,  1620,  1621,  1625,  1626,  1631,  1632,  1633,  1635,
     1064    1643,  1644,  1646,  1649,  1651,  1655,  1656,  1657,  1659,  1661,
     1065    1665,  1670,  1678,  1679,  1688,  1690,  1695,  1696,  1697,  1701,
     1066    1702,  1703,  1707,  1708,  1709,  1713,  1714,  1715,  1720,  1721,
     1067    1722,  1723,  1729,  1730,  1732,  1737,  1738,  1743,  1744,  1745,
     1068    1746,  1747,  1762,  1763,  1768,  1769,  1775,  1777,  1780,  1782,
     1069    1784,  1807,  1808,  1810,  1812,  1817,  1818,  1820,  1825,  1830,
     1070    1831,  1837,  1836,  1840,  1844,  1846,  1848,  1854,  1855,  1860,
     1071    1865,  1867,  1872,  1874,  1875,  1877,  1882,  1884,  1886,  1891,
     1072    1893,  1898,  1903,  1911,  1917,  1916,  1930,  1931,  1936,  1937,
     1073    1941,  1946,  1951,  1959,  1964,  1975,  1976,  1987,  1988,  1994,
     1074    1995,  1999,  2000,  2001,  2004,  2003,  2014,  2023,  2029,  2035,
     1075    2044,  2050,  2056,  2062,  2068,  2076,  2082,  2090,  2096,  2105,
     1076    2106,  2107,  2111,  2115,  2117,  2122,  2123,  2127,  2128,  2133,
     1077    2139,  2140,  2143,  2145,  2146,  2150,  2151,  2152,  2153,  2187,
     1078    2189,  2190,  2192,  2197,  2202,  2207,  2209,  2211,  2216,  2218,
     1079    2220,  2222,  2227,  2229,  2238,  2240,  2241,  2246,  2248,  2250,
     1080    2255,  2257,  2259,  2264,  2266,  2268,  2277,  2278,  2279,  2283,
     1081    2285,  2287,  2292,  2294,  2296,  2301,  2303,  2305,  2320,  2322,
     1082    2323,  2325,  2330,  2331,  2336,  2338,  2340,  2345,  2347,  2349,
     1083    2351,  2356,  2358,  2360,  2370,  2372,  2373,  2375,  2380,  2382,
     1084    2384,  2389,  2391,  2393,  2395,  2400,  2402,  2404,  2435,  2437,
     1085    2438,  2440,  2445,  2450,  2458,  2460,  2462,  2467,  2469,  2474,
     1086    2476,  2490,  2491,  2493,  2498,  2500,  2502,  2504,  2506,  2511,
     1087    2512,  2514,  2516,  2521,  2523,  2525,  2531,  2533,  2535,  2539,
     1088    2541,  2543,  2545,  2559,  2560,  2562,  2567,  2569,  2571,  2573,
     1089    2575,  2580,  2581,  2583,  2585,  2590,  2592,  2594,  2600,  2601,
     1090    2603,  2612,  2615,  2617,  2620,  2622,  2624,  2637,  2638,  2640,
     1091    2645,  2647,  2649,  2651,  2653,  2658,  2659,  2661,  2663,  2668,
     1092    2670,  2678,  2679,  2680,  2685,  2686,  2690,  2692,  2694,  2696,
     1093    2698,  2700,  2707,  2709,  2711,  2713,  2715,  2717,  2719,  2721,
     1094    2723,  2725,  2730,  2732,  2734,  2739,  2765,  2766,  2768,  2772,
     1095    2773,  2777,  2779,  2781,  2783,  2785,  2787,  2794,  2796,  2798,
     1096    2800,  2802,  2804,  2809,  2814,  2816,  2818,  2836,  2838,  2843,
     1097    2844
    10981098};
    10991099#endif
     
    50985098                        Token fn;
    50995099                        fn.str = new std::string( "?{}" ); // location undefined
    5100                         (yyval.en) = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_link( (yyvsp[(3) - (4)].en) ) ) );
     5100                        (yyval.en) = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(1) - (4)].en) )->set_last( (yyvsp[(3) - (4)].en) ) ) );
    51015101                }
    51025102    break;
     
    51065106/* Line 1806 of yacc.c  */
    51075107#line 398 "parser.yy"
    5108     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
     5108    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
    51095109    break;
    51105110
     
    51205120/* Line 1806 of yacc.c  */
    51215121#line 409 "parser.yy"
    5122     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
     5122    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    51235123    break;
    51245124
     
    55935593/* Line 1806 of yacc.c  */
    55945594#line 629 "parser.yy"
    5595     { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_link( (yyvsp[(4) - (6)].en) ) ) ); }
     5595    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); }
    55965596    break;
    55975597
     
    56005600/* Line 1806 of yacc.c  */
    56015601#line 631 "parser.yy"
    5602     { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_link( (yyvsp[(5) - (7)].en) ) ) ); }
     5602    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
    56035603    break;
    56045604
     
    56075607/* Line 1806 of yacc.c  */
    56085608#line 637 "parser.yy"
    5609     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
     5609    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    56105610    break;
    56115611
     
    56385638                        Token fn;
    56395639                        fn.str = new std::string( "^?{}" ); // location undefined
    5640                         (yyval.sn) = new StatementNode2( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_link( (yyvsp[(4) - (6)].en) ) ) ) ) );
     5640                        (yyval.sn) = new StatementNode2( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( (yyvsp[(2) - (6)].en) )->set_last( (yyvsp[(4) - (6)].en) ) ) ) ) );
    56415641                }
    56425642    break;
     
    56695669/* Line 1806 of yacc.c  */
    56705670#line 694 "parser.yy"
    5671     { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
     5671    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    56725672    break;
    56735673
     
    56765676/* Line 1806 of yacc.c  */
    56775677#line 699 "parser.yy"
    5678     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
     5678    { (yyval.sn) = new StatementNode2( (yyvsp[(1) - (1)].decl) ); }
    56795679    break;
    56805680
     
    56845684#line 701 "parser.yy"
    56855685    {   // mark all fields in list
    5686                         for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     5686                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_next() )
    56875687                                iter->set_extension( true );
    5688                         (yyval.sn) = new StatementNode( (yyvsp[(2) - (2)].decl) );
     5688                        (yyval.sn) = new StatementNode2( (yyvsp[(2) - (2)].decl) );
    56895689                }
    56905690    break;
     
    56945694/* Line 1806 of yacc.c  */
    56955695#line 707 "parser.yy"
    5696     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
     5696    { (yyval.sn) = new StatementNode2( (yyvsp[(1) - (1)].decl) ); }
    56975697    break;
    56985698
     
    57015701/* Line 1806 of yacc.c  */
    57025702#line 714 "parser.yy"
    5703     { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
     5703    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    57045704    break;
    57055705
     
    57435743                        // therefore, are removed from the grammar even though C allows it. The change also applies to choose
    57445744                        // statement.
    5745                         (yyval.sn) = (yyvsp[(7) - (9)].decl) != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( (yyvsp[(7) - (9)].decl) ))->set_link( sw )) ) : sw;
     5745                        (yyval.sn) = (yyvsp[(7) - (9)].decl) != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode2( (yyvsp[(7) - (9)].decl) ))->set_last( sw )) ) : sw;
    57465746                }
    57475747    break;
     
    57605760    {
    57615761                        StatementNode *sw = new StatementNode2( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
    5762                         (yyval.sn) = (yyvsp[(7) - (9)].decl) != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( (yyvsp[(7) - (9)].decl) ))->set_link( sw )) ) : sw;
     5762                        (yyval.sn) = (yyvsp[(7) - (9)].decl) != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode2( (yyvsp[(7) - (9)].decl) ))->set_last( sw )) ) : sw;
    57635763                }
    57645764    break;
     
    57815781
    57825782/* Line 1806 of yacc.c  */
    5783 #line 761 "parser.yy"
     5783#line 760 "parser.yy"
    57845784    { (yyval.sn) = new StatementNode2( build_case( (yyvsp[(1) - (1)].en) ) ); }
    57855785    break;
     
    57885788
    57895789/* Line 1806 of yacc.c  */
    5790 #line 763 "parser.yy"
    5791     { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_link( new StatementNode2( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
     5790#line 762 "parser.yy"
     5791    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode2( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
    57925792    break;
    57935793
     
    57955795
    57965796/* Line 1806 of yacc.c  */
     5797#line 766 "parser.yy"
     5798    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
     5799    break;
     5800
     5801  case 161:
     5802
     5803/* Line 1806 of yacc.c  */
    57975804#line 767 "parser.yy"
    5798     { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    5799     break;
    5800 
    5801   case 161:
    5802 
    5803 /* Line 1806 of yacc.c  */
    5804 #line 768 "parser.yy"
    58055805    { (yyval.sn) = new StatementNode2( build_default() ); }
    58065806    break;
     
    58095809
    58105810/* Line 1806 of yacc.c  */
    5811 #line 774 "parser.yy"
    5812     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_link( (yyvsp[(2) - (2)].sn) )); }
     5811#line 773 "parser.yy"
     5812    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); }
    58135813    break;
    58145814
     
    58165816
    58175817/* Line 1806 of yacc.c  */
    5818 #line 778 "parser.yy"
     5818#line 777 "parser.yy"
    58195819    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    58205820    break;
     
    58235823
    58245824/* Line 1806 of yacc.c  */
    5825 #line 783 "parser.yy"
     5825#line 782 "parser.yy"
    58265826    { (yyval.sn) = 0; }
    58275827    break;
     
    58305830
    58315831/* Line 1806 of yacc.c  */
    5832 #line 789 "parser.yy"
     5832#line 788 "parser.yy"
    58335833    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(2) - (2)].sn) ) ); }
    58345834    break;
     
    58375837
    58385838/* Line 1806 of yacc.c  */
    5839 #line 791 "parser.yy"
    5840     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
     5839#line 790 "parser.yy"
     5840    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new CompoundStmtNode( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    58415841    break;
    58425842
     
    58445844
    58455845/* Line 1806 of yacc.c  */
    5846 #line 796 "parser.yy"
     5846#line 795 "parser.yy"
    58475847    { (yyval.sn) = 0; }
    58485848    break;
     
    58515851
    58525852/* Line 1806 of yacc.c  */
    5853 #line 802 "parser.yy"
     5853#line 801 "parser.yy"
    58545854    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    58555855    break;
     
    58585858
    58595859/* Line 1806 of yacc.c  */
    5860 #line 804 "parser.yy"
     5860#line 803 "parser.yy"
    58615861    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(2) - (3)].sn), *(yyvsp[(3) - (3)].sn) ) ) ) ); }
    58625862    break;
     
    58655865
    58665866/* Line 1806 of yacc.c  */
    5867 #line 806 "parser.yy"
    5868     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_link( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
     5867#line 805 "parser.yy"
     5868    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    58695869    break;
    58705870
     
    58725872
    58735873/* Line 1806 of yacc.c  */
    5874 #line 808 "parser.yy"
    5875     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_link( (yyvsp[(2) - (4)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(3) - (4)].sn), *(yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
     5874#line 807 "parser.yy"
     5875    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*(yyvsp[(3) - (4)].sn), *(yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
    58765876    break;
    58775877
     
    58795879
    58805880/* Line 1806 of yacc.c  */
    5881 #line 813 "parser.yy"
     5881#line 812 "parser.yy"
    58825882    { (yyval.sn) = new StatementNode2( build_branch( "", BranchStmt::Break ) ); }
    58835883    break;
     
    58865886
    58875887/* Line 1806 of yacc.c  */
    5888 #line 819 "parser.yy"
     5888#line 818 "parser.yy"
    58895889    { (yyval.sn) = 0; }
    58905890    break;
     
    58935893
    58945894/* Line 1806 of yacc.c  */
    5895 #line 821 "parser.yy"
     5895#line 820 "parser.yy"
    58965896    { (yyval.sn) = 0; }
    58975897    break;
     
    59005900
    59015901/* Line 1806 of yacc.c  */
    5902 #line 826 "parser.yy"
     5902#line 825 "parser.yy"
    59035903    { (yyval.sn) = new StatementNode2( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    59045904    break;
     
    59075907
    59085908/* Line 1806 of yacc.c  */
    5909 #line 828 "parser.yy"
     5909#line 827 "parser.yy"
    59105910    { (yyval.sn) = new StatementNode2( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn) ) ); }
    59115911    break;
     
    59145914
    59155915/* Line 1806 of yacc.c  */
    5916 #line 830 "parser.yy"
     5916#line 829 "parser.yy"
    59175917    { (yyval.sn) = new StatementNode2( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
    59185918    break;
     
    59215921
    59225922/* Line 1806 of yacc.c  */
    5923 #line 835 "parser.yy"
     5923#line 834 "parser.yy"
    59245924    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    59255925    break;
     
    59285928
    59295929/* Line 1806 of yacc.c  */
    5930 #line 837 "parser.yy"
     5930#line 836 "parser.yy"
    59315931    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    59325932    break;
     
    59355935
    59365936/* Line 1806 of yacc.c  */
    5937 #line 842 "parser.yy"
     5937#line 841 "parser.yy"
    59385938    { (yyval.sn) = new StatementNode2( build_branch( *(yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
    59395939    break;
     
    59425942
    59435943/* Line 1806 of yacc.c  */
    5944 #line 846 "parser.yy"
     5944#line 845 "parser.yy"
    59455945    { (yyval.sn) = new StatementNode2( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
    59465946    break;
     
    59495949
    59505950/* Line 1806 of yacc.c  */
    5951 #line 849 "parser.yy"
     5951#line 848 "parser.yy"
    59525952    { (yyval.sn) = new StatementNode2( build_branch( "", BranchStmt::Continue ) ); }
    59535953    break;
     
    59565956
    59575957/* Line 1806 of yacc.c  */
    5958 #line 853 "parser.yy"
     5958#line 852 "parser.yy"
    59595959    { (yyval.sn) = new StatementNode2( build_branch( *(yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); delete (yyvsp[(2) - (3)].tok); }
    59605960    break;
     
    59635963
    59645964/* Line 1806 of yacc.c  */
    5965 #line 856 "parser.yy"
     5965#line 855 "parser.yy"
    59665966    { (yyval.sn) = new StatementNode2( build_branch( "", BranchStmt::Break ) ); }
    59675967    break;
     
    59705970
    59715971/* Line 1806 of yacc.c  */
    5972 #line 860 "parser.yy"
     5972#line 859 "parser.yy"
    59735973    { (yyval.sn) = new StatementNode2( build_branch( *(yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); delete (yyvsp[(2) - (3)].tok); }
    59745974    break;
     
    59775977
    59785978/* Line 1806 of yacc.c  */
    5979 #line 862 "parser.yy"
     5979#line 861 "parser.yy"
    59805980    { (yyval.sn) = new StatementNode2( build_return( (yyvsp[(2) - (3)].en) ) ); }
    59815981    break;
     
    59845984
    59855985/* Line 1806 of yacc.c  */
    5986 #line 864 "parser.yy"
     5986#line 863 "parser.yy"
    59875987    { (yyval.sn) = new StatementNode2( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    59885988    break;
     
    59915991
    59925992/* Line 1806 of yacc.c  */
    5993 #line 866 "parser.yy"
     5993#line 865 "parser.yy"
    59945994    { (yyval.sn) = new StatementNode2( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    59955995    break;
     
    59985998
    59995999/* Line 1806 of yacc.c  */
    6000 #line 868 "parser.yy"
     6000#line 867 "parser.yy"
    60016001    { (yyval.sn) = new StatementNode2( build_throw( (yyvsp[(2) - (5)].en) ) ); }
    60026002    break;
     
    60056005
    60066006/* Line 1806 of yacc.c  */
    6007 #line 873 "parser.yy"
    6008     { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
     6007#line 872 "parser.yy"
     6008    { (yyval.sn) = new StatementNode2( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); }
    60096009    break;
    60106010
     
    60126012
    60136013/* Line 1806 of yacc.c  */
    6014 #line 875 "parser.yy"
    6015     { (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (3)].sn),*(yyvsp[(3) - (3)].pn) )))); }
     6014#line 874 "parser.yy"
     6015    { (yyval.sn) = new StatementNode2( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); }
    60166016    break;
    60176017
     
    60196019
    60206020/* Line 1806 of yacc.c  */
    6021 #line 877 "parser.yy"
     6021#line 876 "parser.yy"
     6022    { (yyval.sn) = new StatementNode2( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); }
     6023    break;
     6024
     6025  case 198:
     6026
     6027/* Line 1806 of yacc.c  */
     6028#line 883 "parser.yy"
     6029    { (yyval.sn) = new StatementNode2( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
     6030    break;
     6031
     6032  case 199:
     6033
     6034/* Line 1806 of yacc.c  */
     6035#line 885 "parser.yy"
     6036    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode2( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
     6037    break;
     6038
     6039  case 200:
     6040
     6041/* Line 1806 of yacc.c  */
     6042#line 887 "parser.yy"
     6043    { (yyval.sn) = new StatementNode2( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
     6044    break;
     6045
     6046  case 201:
     6047
     6048/* Line 1806 of yacc.c  */
     6049#line 889 "parser.yy"
     6050    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode2( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
     6051    break;
     6052
     6053  case 202:
     6054
     6055/* Line 1806 of yacc.c  */
     6056#line 894 "parser.yy"
     6057    { (yyval.sn) = new StatementNode2( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
     6058    break;
     6059
     6060  case 203:
     6061
     6062/* Line 1806 of yacc.c  */
     6063#line 896 "parser.yy"
     6064    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode2( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
     6065    break;
     6066
     6067  case 204:
     6068
     6069/* Line 1806 of yacc.c  */
     6070#line 898 "parser.yy"
     6071    { (yyval.sn) = new StatementNode2( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
     6072    break;
     6073
     6074  case 205:
     6075
     6076/* Line 1806 of yacc.c  */
     6077#line 900 "parser.yy"
     6078    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode2( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
     6079    break;
     6080
     6081  case 206:
     6082
     6083/* Line 1806 of yacc.c  */
     6084#line 905 "parser.yy"
    60226085    {
    6023                         (yyvsp[(3) - (4)].pn)->set_link( (yyvsp[(4) - (4)].pn) );
    6024                         (yyval.sn) = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*(yyvsp[(2) - (4)].sn),*(yyvsp[(3) - (4)].pn) ))));
     6086                        (yyval.sn) = new StatementNode2( build_finally( (yyvsp[(2) - (2)].sn) ) );
    60256087                }
    60266088    break;
    60276089
    6028   case 198:
    6029 
    6030 /* Line 1806 of yacc.c  */
    6031 #line 888 "parser.yy"
    6032     { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    6033     break;
    6034 
    6035   case 199:
    6036 
    6037 /* Line 1806 of yacc.c  */
    6038 #line 890 "parser.yy"
    6039     { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    6040     break;
    6041 
    6042   case 200:
    6043 
    6044 /* Line 1806 of yacc.c  */
    6045 #line 892 "parser.yy"
    6046     { (yyval.pn) = StatementNode::newCatchStmt( 0, (yyvsp[(5) - (5)].sn), true ); }
    6047     break;
    6048 
    6049   case 201:
    6050 
    6051 /* Line 1806 of yacc.c  */
    6052 #line 894 "parser.yy"
    6053     { (yyval.pn) = (yyvsp[(1) - (6)].pn)->set_link( StatementNode::newCatchStmt( 0, (yyvsp[(6) - (6)].sn), true ) ); }
    6054     break;
    6055 
    6056   case 202:
    6057 
    6058 /* Line 1806 of yacc.c  */
    6059 #line 899 "parser.yy"
    6060     { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    6061     break;
    6062 
    6063   case 203:
    6064 
    6065 /* Line 1806 of yacc.c  */
    6066 #line 901 "parser.yy"
    6067     { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    6068     break;
    6069 
    6070   case 204:
    6071 
    6072 /* Line 1806 of yacc.c  */
    6073 #line 903 "parser.yy"
    6074     { (yyval.pn) = StatementNode::newCatchStmt( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ); }
    6075     break;
    6076 
    6077   case 205:
    6078 
    6079 /* Line 1806 of yacc.c  */
    6080 #line 905 "parser.yy"
    6081     { (yyval.pn) = (yyvsp[(1) - (10)].pn)->set_link( StatementNode::newCatchStmt( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ); }
    6082     break;
    6083 
    6084   case 206:
    6085 
    6086 /* Line 1806 of yacc.c  */
    6087 #line 910 "parser.yy"
    6088     {
    6089                         (yyval.pn) = new StatementNode( StatementNode::Finally, 0, (yyvsp[(2) - (2)].sn) );
    6090                         std::cout << "Just created a finally node" << std::endl;
    6091                 }
    6092     break;
    6093 
    60946090  case 208:
    60956091
    60966092/* Line 1806 of yacc.c  */
    6097 #line 924 "parser.yy"
     6093#line 918 "parser.yy"
    60986094    {
    60996095                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61056101
    61066102/* Line 1806 of yacc.c  */
    6107 #line 929 "parser.yy"
     6103#line 923 "parser.yy"
    61086104    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    61096105    break;
     
    61126108
    61136109/* Line 1806 of yacc.c  */
    6114 #line 931 "parser.yy"
     6110#line 925 "parser.yy"
    61156111    {
    61166112                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    61226118
    61236119/* Line 1806 of yacc.c  */
     6120#line 934 "parser.yy"
     6121    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
     6122    break;
     6123
     6124  case 213:
     6125
     6126/* Line 1806 of yacc.c  */
     6127#line 936 "parser.yy"
     6128    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
     6129    break;
     6130
     6131  case 214:
     6132
     6133/* Line 1806 of yacc.c  */
     6134#line 938 "parser.yy"
     6135    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
     6136    break;
     6137
     6138  case 215:
     6139
     6140/* Line 1806 of yacc.c  */
    61246141#line 940 "parser.yy"
    6125     { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ); }
    6126     break;
    6127 
    6128   case 213:
     6142    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ); }
     6143    break;
     6144
     6145  case 216:
    61296146
    61306147/* Line 1806 of yacc.c  */
    61316148#line 942 "parser.yy"
    6132     { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ); }
    6133     break;
    6134 
    6135   case 214:
    6136 
    6137 /* Line 1806 of yacc.c  */
    6138 #line 944 "parser.yy"
    6139     { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ); }
    6140     break;
    6141 
    6142   case 215:
    6143 
    6144 /* Line 1806 of yacc.c  */
    6145 #line 946 "parser.yy"
    6146     { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ); }
    6147     break;
    6148 
    6149   case 216:
    6150 
    6151 /* Line 1806 of yacc.c  */
    6152 #line 948 "parser.yy"
    61536149    { (yyval.sn) = new AsmStmtNode( StatementNode::Asm, (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ); }
    61546150    break;
     
    61576153
    61586154/* Line 1806 of yacc.c  */
    6159 #line 953 "parser.yy"
     6155#line 947 "parser.yy"
    61606156    { (yyval.flag) = false; }
    61616157    break;
     
    61646160
    61656161/* Line 1806 of yacc.c  */
    6166 #line 955 "parser.yy"
     6162#line 949 "parser.yy"
    61676163    { (yyval.flag) = true; }
    61686164    break;
     
    61716167
    61726168/* Line 1806 of yacc.c  */
    6173 #line 960 "parser.yy"
     6169#line 954 "parser.yy"
    61746170    { (yyval.en) = 0; }
    61756171    break;
     
    61786174
    61796175/* Line 1806 of yacc.c  */
    6180 #line 967 "parser.yy"
    6181     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) ); }
     6176#line 961 "parser.yy"
     6177    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    61826178    break;
    61836179
     
    61856181
    61866182/* Line 1806 of yacc.c  */
    6187 #line 972 "parser.yy"
     6183#line 966 "parser.yy"
    61886184    { (yyval.en) = new ExpressionNode( build_asm( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
    61896185    break;
     
    61926188
    61936189/* Line 1806 of yacc.c  */
    6194 #line 974 "parser.yy"
     6190#line 968 "parser.yy"
    61956191    { (yyval.en) = new ExpressionNode( build_asm( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
    61966192    break;
     
    61996195
    62006196/* Line 1806 of yacc.c  */
    6201 #line 979 "parser.yy"
     6197#line 973 "parser.yy"
    62026198    { (yyval.en) = 0; }
    62036199    break;
     
    62066202
    62076203/* Line 1806 of yacc.c  */
    6208 #line 981 "parser.yy"
     6204#line 975 "parser.yy"
    62096205    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    62106206    break;
     
    62136209
    62146210/* Line 1806 of yacc.c  */
    6215 #line 983 "parser.yy"
    6216     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_link( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
     6211#line 977 "parser.yy"
     6212    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
    62176213    break;
    62186214
     
    62206216
    62216217/* Line 1806 of yacc.c  */
    6222 #line 988 "parser.yy"
     6218#line 982 "parser.yy"
    62236219    { (yyval.label) = new LabelNode(); (yyval.label)->append_label( (yyvsp[(1) - (1)].tok) ); }
    62246220    break;
     
    62276223
    62286224/* Line 1806 of yacc.c  */
    6229 #line 990 "parser.yy"
     6225#line 984 "parser.yy"
    62306226    { (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->append_label( (yyvsp[(3) - (3)].tok) ); }
    62316227    break;
     
    62346230
    62356231/* Line 1806 of yacc.c  */
    6236 #line 997 "parser.yy"
     6232#line 991 "parser.yy"
    62376233    { (yyval.decl) = 0; }
    62386234    break;
     
    62416237
    62426238/* Line 1806 of yacc.c  */
    6243 #line 1004 "parser.yy"
     6239#line 998 "parser.yy"
    62446240    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    62456241    break;
     
    62486244
    62496245/* Line 1806 of yacc.c  */
    6250 #line 1009 "parser.yy"
     6246#line 1003 "parser.yy"
    62516247    { (yyval.decl) = 0; }
    62526248    break;
     
    62556251
    62566252/* Line 1806 of yacc.c  */
    6257 #line 1016 "parser.yy"
     6253#line 1010 "parser.yy"
    62586254    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    62596255    break;
     
    62626258
    62636259/* Line 1806 of yacc.c  */
    6264 #line 1030 "parser.yy"
     6260#line 1024 "parser.yy"
    62656261    {}
    62666262    break;
     
    62696265
    62706266/* Line 1806 of yacc.c  */
    6271 #line 1031 "parser.yy"
     6267#line 1025 "parser.yy"
    62726268    {}
    62736269    break;
     
    62766272
    62776273/* Line 1806 of yacc.c  */
    6278 #line 1060 "parser.yy"
     6274#line 1054 "parser.yy"
    62796275    {
    62806276                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    62866282
    62876283/* Line 1806 of yacc.c  */
    6288 #line 1067 "parser.yy"
     6284#line 1061 "parser.yy"
    62896285    {
    62906286                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    62966292
    62976293/* Line 1806 of yacc.c  */
    6298 #line 1072 "parser.yy"
     6294#line 1066 "parser.yy"
    62996295    {
    63006296                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
     
    63066302
    63076303/* Line 1806 of yacc.c  */
    6308 #line 1082 "parser.yy"
     6304#line 1076 "parser.yy"
    63096305    {
    63106306                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63166312
    63176313/* Line 1806 of yacc.c  */
    6318 #line 1087 "parser.yy"
     6314#line 1081 "parser.yy"
    63196315    {
    63206316                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
     
    63266322
    63276323/* Line 1806 of yacc.c  */
    6328 #line 1092 "parser.yy"
     6324#line 1086 "parser.yy"
    63296325    {
    63306326                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
     
    63366332
    63376333/* Line 1806 of yacc.c  */
    6338 #line 1100 "parser.yy"
     6334#line 1094 "parser.yy"
    63396335    {
    63406336                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63466342
    63476343/* Line 1806 of yacc.c  */
    6348 #line 1105 "parser.yy"
     6344#line 1099 "parser.yy"
    63496345    {
    63506346                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63566352
    63576353/* Line 1806 of yacc.c  */
    6358 #line 1110 "parser.yy"
     6354#line 1104 "parser.yy"
    63596355    {
    63606356                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63666362
    63676363/* Line 1806 of yacc.c  */
    6368 #line 1115 "parser.yy"
     6364#line 1109 "parser.yy"
    63696365    {
    63706366                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    63766372
    63776373/* Line 1806 of yacc.c  */
    6378 #line 1120 "parser.yy"
     6374#line 1114 "parser.yy"
    63796375    {
    63806376                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    63866382
    63876383/* Line 1806 of yacc.c  */
    6388 #line 1128 "parser.yy"
     6384#line 1122 "parser.yy"
    63896385    {
    63906386                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
     
    63956391
    63966392/* Line 1806 of yacc.c  */
    6397 #line 1151 "parser.yy"
     6393#line 1145 "parser.yy"
    63986394    {
    63996395                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    64046400
    64056401/* Line 1806 of yacc.c  */
    6406 #line 1155 "parser.yy"
     6402#line 1149 "parser.yy"
    64076403    {
    64086404                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
     
    64136409
    64146410/* Line 1806 of yacc.c  */
    6415 #line 1162 "parser.yy"
     6411#line 1156 "parser.yy"
    64166412    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    64176413    break;
     
    64206416
    64216417/* Line 1806 of yacc.c  */
    6422 #line 1166 "parser.yy"
     6418#line 1160 "parser.yy"
    64236419    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    64246420    break;
     
    64276423
    64286424/* Line 1806 of yacc.c  */
    6429 #line 1171 "parser.yy"
     6425#line 1165 "parser.yy"
    64306426    {
    64316427                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64376433
    64386434/* Line 1806 of yacc.c  */
    6439 #line 1176 "parser.yy"
     6435#line 1170 "parser.yy"
    64406436    {
    64416437                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64476443
    64486444/* Line 1806 of yacc.c  */
    6449 #line 1181 "parser.yy"
     6445#line 1175 "parser.yy"
    64506446    {
    64516447                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
     
    64576453
    64586454/* Line 1806 of yacc.c  */
    6459 #line 1192 "parser.yy"
     6455#line 1186 "parser.yy"
    64606456    {
    64616457                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64676463
    64686464/* Line 1806 of yacc.c  */
    6469 #line 1197 "parser.yy"
     6465#line 1191 "parser.yy"
    64706466    {
    64716467                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64776473
    64786474/* Line 1806 of yacc.c  */
    6479 #line 1202 "parser.yy"
     6475#line 1196 "parser.yy"
    64806476    {
    64816477                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64876483
    64886484/* Line 1806 of yacc.c  */
    6489 #line 1207 "parser.yy"
     6485#line 1201 "parser.yy"
    64906486    {
    64916487                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    64976493
    64986494/* Line 1806 of yacc.c  */
    6499 #line 1212 "parser.yy"
     6495#line 1206 "parser.yy"
    65006496    {
    65016497                        typedefTable.addToEnclosingScope( TypedefTable::TD );
     
    65076503
    65086504/* Line 1806 of yacc.c  */
    6509 #line 1221 "parser.yy"
     6505#line 1215 "parser.yy"
    65106506    {
    65116507                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
     
    65176513
    65186514/* Line 1806 of yacc.c  */
    6519 #line 1226 "parser.yy"
     6515#line 1220 "parser.yy"
    65206516    {
    65216517                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
     
    65276523
    65286524/* Line 1806 of yacc.c  */
    6529 #line 1243 "parser.yy"
     6525#line 1237 "parser.yy"
    65306526    {
    65316527                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65376533
    65386534/* Line 1806 of yacc.c  */
    6539 #line 1248 "parser.yy"
     6535#line 1242 "parser.yy"
    65406536    {
    65416537                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    65476543
    65486544/* Line 1806 of yacc.c  */
    6549 #line 1270 "parser.yy"
     6545#line 1264 "parser.yy"
    65506546    { (yyval.decl) = 0; }
    65516547    break;
     
    65546550
    65556551/* Line 1806 of yacc.c  */
    6556 #line 1282 "parser.yy"
     6552#line 1276 "parser.yy"
    65576553    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    65586554    break;
     
    65616557
    65626558/* Line 1806 of yacc.c  */
     6559#line 1287 "parser.yy"
     6560    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
     6561    break;
     6562
     6563  case 298:
     6564
     6565/* Line 1806 of yacc.c  */
     6566#line 1289 "parser.yy"
     6567    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
     6568    break;
     6569
     6570  case 299:
     6571
     6572/* Line 1806 of yacc.c  */
     6573#line 1291 "parser.yy"
     6574    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
     6575    break;
     6576
     6577  case 300:
     6578
     6579/* Line 1806 of yacc.c  */
    65636580#line 1293 "parser.yy"
    6564     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    6565     break;
    6566 
    6567   case 298:
     6581    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
     6582    break;
     6583
     6584  case 301:
    65686585
    65696586/* Line 1806 of yacc.c  */
    65706587#line 1295 "parser.yy"
    6571     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    6572     break;
    6573 
    6574   case 299:
     6588    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
     6589    break;
     6590
     6591  case 302:
    65756592
    65766593/* Line 1806 of yacc.c  */
    65776594#line 1297 "parser.yy"
    6578     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    6579     break;
    6580 
    6581   case 300:
    6582 
    6583 /* Line 1806 of yacc.c  */
    6584 #line 1299 "parser.yy"
    6585     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    6586     break;
    6587 
    6588   case 301:
    6589 
    6590 /* Line 1806 of yacc.c  */
    6591 #line 1301 "parser.yy"
    6592     { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    6593     break;
    6594 
    6595   case 302:
    6596 
    6597 /* Line 1806 of yacc.c  */
    6598 #line 1303 "parser.yy"
    65996595    {
    66006596                        typedefTable.enterScope();
     
    66056601
    66066602/* Line 1806 of yacc.c  */
    6607 #line 1307 "parser.yy"
     6603#line 1301 "parser.yy"
    66086604    {
    66096605                        typedefTable.leaveScope();
     
    66156611
    66166612/* Line 1806 of yacc.c  */
    6617 #line 1316 "parser.yy"
     6613#line 1310 "parser.yy"
    66186614    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66196615    break;
     
    66226618
    66236619/* Line 1806 of yacc.c  */
    6624 #line 1318 "parser.yy"
     6620#line 1312 "parser.yy"
    66256621    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    66266622    break;
     
    66296625
    66306626/* Line 1806 of yacc.c  */
    6631 #line 1329 "parser.yy"
     6627#line 1323 "parser.yy"
    66326628    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66336629    break;
     
    66366632
    66376633/* Line 1806 of yacc.c  */
     6634#line 1332 "parser.yy"
     6635    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
     6636    break;
     6637
     6638  case 311:
     6639
     6640/* Line 1806 of yacc.c  */
     6641#line 1334 "parser.yy"
     6642    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
     6643    break;
     6644
     6645  case 312:
     6646
     6647/* Line 1806 of yacc.c  */
     6648#line 1336 "parser.yy"
     6649    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
     6650    break;
     6651
     6652  case 313:
     6653
     6654/* Line 1806 of yacc.c  */
    66386655#line 1338 "parser.yy"
    6639     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    6640     break;
    6641 
    6642   case 311:
     6656    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     6657    break;
     6658
     6659  case 314:
    66436660
    66446661/* Line 1806 of yacc.c  */
    66456662#line 1340 "parser.yy"
    6646     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    6647     break;
    6648 
    6649   case 312:
     6663    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
     6664    break;
     6665
     6666  case 315:
    66506667
    66516668/* Line 1806 of yacc.c  */
    66526669#line 1342 "parser.yy"
    6653     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    6654     break;
    6655 
    6656   case 313:
     6670    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
     6671    break;
     6672
     6673  case 316:
    66576674
    66586675/* Line 1806 of yacc.c  */
    66596676#line 1344 "parser.yy"
    6660     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    6661     break;
    6662 
    6663   case 314:
     6677    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
     6678    break;
     6679
     6680  case 317:
    66646681
    66656682/* Line 1806 of yacc.c  */
    66666683#line 1346 "parser.yy"
    6667     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
    6668     break;
    6669 
    6670   case 315:
    6671 
    6672 /* Line 1806 of yacc.c  */
    6673 #line 1348 "parser.yy"
    6674     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    6675     break;
    6676 
    6677   case 316:
    6678 
    6679 /* Line 1806 of yacc.c  */
    6680 #line 1350 "parser.yy"
    6681     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
    6682     break;
    6683 
    6684   case 317:
    6685 
    6686 /* Line 1806 of yacc.c  */
    6687 #line 1352 "parser.yy"
    66886684    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    66896685    break;
     
    66926688
    66936689/* Line 1806 of yacc.c  */
     6690#line 1351 "parser.yy"
     6691    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
     6692    break;
     6693
     6694  case 319:
     6695
     6696/* Line 1806 of yacc.c  */
     6697#line 1353 "parser.yy"
     6698    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
     6699    break;
     6700
     6701  case 320:
     6702
     6703/* Line 1806 of yacc.c  */
     6704#line 1355 "parser.yy"
     6705    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
     6706    break;
     6707
     6708  case 321:
     6709
     6710/* Line 1806 of yacc.c  */
    66946711#line 1357 "parser.yy"
    6695     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    6696     break;
    6697 
    6698   case 319:
     6712    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
     6713    break;
     6714
     6715  case 322:
    66996716
    67006717/* Line 1806 of yacc.c  */
    67016718#line 1359 "parser.yy"
    6702     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    6703     break;
    6704 
    6705   case 320:
     6719    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
     6720    break;
     6721
     6722  case 323:
    67066723
    67076724/* Line 1806 of yacc.c  */
    67086725#line 1361 "parser.yy"
    6709     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    6710     break;
    6711 
    6712   case 321:
     6726    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
     6727    break;
     6728
     6729  case 324:
    67136730
    67146731/* Line 1806 of yacc.c  */
    67156732#line 1363 "parser.yy"
    6716     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    6717     break;
    6718 
    6719   case 322:
     6733    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
     6734    break;
     6735
     6736  case 325:
    67206737
    67216738/* Line 1806 of yacc.c  */
    67226739#line 1365 "parser.yy"
    6723     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Long ); }
    6724     break;
    6725 
    6726   case 323:
     6740    { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
     6741    break;
     6742
     6743  case 326:
    67276744
    67286745/* Line 1806 of yacc.c  */
    67296746#line 1367 "parser.yy"
    6730     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Short ); }
    6731     break;
    6732 
    6733   case 324:
     6747    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
     6748    break;
     6749
     6750  case 327:
    67346751
    67356752/* Line 1806 of yacc.c  */
    67366753#line 1369 "parser.yy"
    6737     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Signed ); }
    6738     break;
    6739 
    6740   case 325:
     6754    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
     6755    break;
     6756
     6757  case 328:
    67416758
    67426759/* Line 1806 of yacc.c  */
    67436760#line 1371 "parser.yy"
    6744     { (yyval.decl) = DeclarationNode::newModifier( DeclarationNode::Unsigned ); }
    6745     break;
    6746 
    6747   case 326:
     6761    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
     6762    break;
     6763
     6764  case 329:
    67486765
    67496766/* Line 1806 of yacc.c  */
    67506767#line 1373 "parser.yy"
    6751     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    6752     break;
    6753 
    6754   case 327:
     6768    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
     6769    break;
     6770
     6771  case 330:
    67556772
    67566773/* Line 1806 of yacc.c  */
    67576774#line 1375 "parser.yy"
    6758     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    6759     break;
    6760 
    6761   case 328:
    6762 
    6763 /* Line 1806 of yacc.c  */
    6764 #line 1377 "parser.yy"
    6765     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Complex ); }
    6766     break;
    6767 
    6768   case 329:
    6769 
    6770 /* Line 1806 of yacc.c  */
    6771 #line 1379 "parser.yy"
    6772     { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Imaginary ); }
    6773     break;
    6774 
    6775   case 330:
    6776 
    6777 /* Line 1806 of yacc.c  */
    6778 #line 1381 "parser.yy"
    67796775    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    67806776    break;
     
    67836779
    67846780/* Line 1806 of yacc.c  */
     6781#line 1382 "parser.yy"
     6782    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6783    break;
     6784
     6785  case 333:
     6786
     6787/* Line 1806 of yacc.c  */
     6788#line 1384 "parser.yy"
     6789    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6790    break;
     6791
     6792  case 334:
     6793
     6794/* Line 1806 of yacc.c  */
     6795#line 1386 "parser.yy"
     6796    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     6797    break;
     6798
     6799  case 335:
     6800
     6801/* Line 1806 of yacc.c  */
    67856802#line 1388 "parser.yy"
     6803    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
     6804    break;
     6805
     6806  case 337:
     6807
     6808/* Line 1806 of yacc.c  */
     6809#line 1394 "parser.yy"
     6810    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     6811    break;
     6812
     6813  case 339:
     6814
     6815/* Line 1806 of yacc.c  */
     6816#line 1401 "parser.yy"
    67866817    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    67876818    break;
    67886819
    6789   case 333:
    6790 
    6791 /* Line 1806 of yacc.c  */
    6792 #line 1390 "parser.yy"
     6820  case 340:
     6821
     6822/* Line 1806 of yacc.c  */
     6823#line 1403 "parser.yy"
    67936824    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    67946825    break;
    67956826
    6796   case 334:
    6797 
    6798 /* Line 1806 of yacc.c  */
    6799 #line 1392 "parser.yy"
     6827  case 341:
     6828
     6829/* Line 1806 of yacc.c  */
     6830#line 1405 "parser.yy"
     6831    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
     6832    break;
     6833
     6834  case 342:
     6835
     6836/* Line 1806 of yacc.c  */
     6837#line 1410 "parser.yy"
     6838    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
     6839    break;
     6840
     6841  case 343:
     6842
     6843/* Line 1806 of yacc.c  */
     6844#line 1412 "parser.yy"
     6845    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
     6846    break;
     6847
     6848  case 344:
     6849
     6850/* Line 1806 of yacc.c  */
     6851#line 1414 "parser.yy"
     6852    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
     6853    break;
     6854
     6855  case 345:
     6856
     6857/* Line 1806 of yacc.c  */
     6858#line 1416 "parser.yy"
     6859    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
     6860    break;
     6861
     6862  case 347:
     6863
     6864/* Line 1806 of yacc.c  */
     6865#line 1422 "parser.yy"
     6866    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6867    break;
     6868
     6869  case 348:
     6870
     6871/* Line 1806 of yacc.c  */
     6872#line 1424 "parser.yy"
     6873    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     6874    break;
     6875
     6876  case 349:
     6877
     6878/* Line 1806 of yacc.c  */
     6879#line 1426 "parser.yy"
    68006880    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68016881    break;
    68026882
    6803   case 335:
    6804 
    6805 /* Line 1806 of yacc.c  */
    6806 #line 1394 "parser.yy"
    6807     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    6808     break;
    6809 
    6810   case 337:
    6811 
    6812 /* Line 1806 of yacc.c  */
    6813 #line 1400 "parser.yy"
    6814     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    6815     break;
    6816 
    6817   case 339:
    6818 
    6819 /* Line 1806 of yacc.c  */
    6820 #line 1407 "parser.yy"
     6883  case 351:
     6884
     6885/* Line 1806 of yacc.c  */
     6886#line 1432 "parser.yy"
    68216887    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68226888    break;
    68236889
    6824   case 340:
    6825 
    6826 /* Line 1806 of yacc.c  */
    6827 #line 1409 "parser.yy"
     6890  case 352:
     6891
     6892/* Line 1806 of yacc.c  */
     6893#line 1434 "parser.yy"
    68286894    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68296895    break;
    68306896
    6831   case 341:
    6832 
    6833 /* Line 1806 of yacc.c  */
    6834 #line 1411 "parser.yy"
    6835     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    6836     break;
    6837 
    6838   case 342:
    6839 
    6840 /* Line 1806 of yacc.c  */
    6841 #line 1416 "parser.yy"
    6842     { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    6843     break;
    6844 
    6845   case 343:
    6846 
    6847 /* Line 1806 of yacc.c  */
    6848 #line 1418 "parser.yy"
    6849     { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    6850     break;
    6851 
    6852   case 344:
    6853 
    6854 /* Line 1806 of yacc.c  */
    6855 #line 1420 "parser.yy"
    6856     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    6857     break;
    6858 
    6859   case 345:
    6860 
    6861 /* Line 1806 of yacc.c  */
    6862 #line 1422 "parser.yy"
    6863     { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    6864     break;
    6865 
    6866   case 347:
    6867 
    6868 /* Line 1806 of yacc.c  */
    6869 #line 1428 "parser.yy"
     6897  case 354:
     6898
     6899/* Line 1806 of yacc.c  */
     6900#line 1440 "parser.yy"
    68706901    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68716902    break;
    68726903
    6873   case 348:
    6874 
    6875 /* Line 1806 of yacc.c  */
    6876 #line 1430 "parser.yy"
     6904  case 355:
     6905
     6906/* Line 1806 of yacc.c  */
     6907#line 1442 "parser.yy"
    68776908    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68786909    break;
    68796910
    6880   case 349:
    6881 
    6882 /* Line 1806 of yacc.c  */
    6883 #line 1432 "parser.yy"
     6911  case 356:
     6912
     6913/* Line 1806 of yacc.c  */
     6914#line 1444 "parser.yy"
    68846915    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68856916    break;
    68866917
    6887   case 351:
    6888 
    6889 /* Line 1806 of yacc.c  */
    6890 #line 1438 "parser.yy"
    6891     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    6892     break;
    6893 
    6894   case 352:
    6895 
    6896 /* Line 1806 of yacc.c  */
    6897 #line 1440 "parser.yy"
     6918  case 357:
     6919
     6920/* Line 1806 of yacc.c  */
     6921#line 1449 "parser.yy"
     6922    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
     6923    break;
     6924
     6925  case 358:
     6926
     6927/* Line 1806 of yacc.c  */
     6928#line 1451 "parser.yy"
     6929    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     6930    break;
     6931
     6932  case 359:
     6933
     6934/* Line 1806 of yacc.c  */
     6935#line 1453 "parser.yy"
    68986936    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68996937    break;
    69006938
    6901   case 354:
    6902 
    6903 /* Line 1806 of yacc.c  */
    6904 #line 1446 "parser.yy"
    6905     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    6906     break;
    6907 
    6908   case 355:
    6909 
    6910 /* Line 1806 of yacc.c  */
    6911 #line 1448 "parser.yy"
    6912     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    6913     break;
    6914 
    6915   case 356:
    6916 
    6917 /* Line 1806 of yacc.c  */
    6918 #line 1450 "parser.yy"
    6919     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    6920     break;
    6921 
    6922   case 357:
    6923 
    6924 /* Line 1806 of yacc.c  */
    6925 #line 1455 "parser.yy"
    6926     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    6927     break;
    6928 
    6929   case 358:
    6930 
    6931 /* Line 1806 of yacc.c  */
    6932 #line 1457 "parser.yy"
    6933     { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    6934     break;
    6935 
    6936   case 359:
    6937 
    6938 /* Line 1806 of yacc.c  */
    6939 #line 1459 "parser.yy"
    6940     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    6941     break;
    6942 
    69436939  case 362:
    69446940
    69456941/* Line 1806 of yacc.c  */
    6946 #line 1469 "parser.yy"
     6942#line 1463 "parser.yy"
    69476943    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), 0, 0, (yyvsp[(3) - (4)].decl), true ); }
    69486944    break;
     
    69516947
    69526948/* Line 1806 of yacc.c  */
    6953 #line 1471 "parser.yy"
     6949#line 1465 "parser.yy"
    69546950    {
    69556951                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    69616957
    69626958/* Line 1806 of yacc.c  */
     6959#line 1470 "parser.yy"
     6960    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     6961    break;
     6962
     6963  case 365:
     6964
     6965/* Line 1806 of yacc.c  */
     6966#line 1472 "parser.yy"
     6967    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
     6968    break;
     6969
     6970  case 366:
     6971
     6972/* Line 1806 of yacc.c  */
     6973#line 1474 "parser.yy"
     6974    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
     6975    break;
     6976
     6977  case 367:
     6978
     6979/* Line 1806 of yacc.c  */
    69636980#line 1476 "parser.yy"
    6964     { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    6965     break;
    6966 
    6967   case 365:
    6968 
    6969 /* Line 1806 of yacc.c  */
    6970 #line 1478 "parser.yy"
    6971     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), 0, (yyvsp[(5) - (6)].decl), true ); }
    6972     break;
    6973 
    6974   case 366:
    6975 
    6976 /* Line 1806 of yacc.c  */
    6977 #line 1480 "parser.yy"
    6978     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), 0, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    6979     break;
    6980 
    6981   case 367:
    6982 
    6983 /* Line 1806 of yacc.c  */
    6984 #line 1482 "parser.yy"
    69856981    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    69866982    break;
     
    69896985
    69906986/* Line 1806 of yacc.c  */
    6991 #line 1487 "parser.yy"
     6987#line 1481 "parser.yy"
    69926988    { (yyval.aggKey) = DeclarationNode::Struct; }
    69936989    break;
     
    69966992
    69976993/* Line 1806 of yacc.c  */
    6998 #line 1489 "parser.yy"
     6994#line 1483 "parser.yy"
    69996995    { (yyval.aggKey) = DeclarationNode::Union; }
    70006996    break;
     
    70036999
    70047000/* Line 1806 of yacc.c  */
    7005 #line 1494 "parser.yy"
     7001#line 1488 "parser.yy"
    70067002    { (yyval.decl) = 0; }
    70077003    break;
     
    70107006
    70117007/* Line 1806 of yacc.c  */
     7008#line 1490 "parser.yy"
     7009    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
     7010    break;
     7011
     7012  case 373:
     7013
     7014/* Line 1806 of yacc.c  */
    70127015#line 1496 "parser.yy"
    7013     { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    7014     break;
    7015 
    7016   case 373:
    7017 
    7018 /* Line 1806 of yacc.c  */
    7019 #line 1502 "parser.yy"
    70207016    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    70217017    break;
     
    70247020
    70257021/* Line 1806 of yacc.c  */
    7026 #line 1505 "parser.yy"
     7022#line 1499 "parser.yy"
    70277023    {   // mark all fields in list
    7028                         for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     7024                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_next() )
    70297025                                iter->set_extension( true );
    70307026                        (yyval.decl) = (yyvsp[(2) - (3)].decl);
     
    70357031
    70367032/* Line 1806 of yacc.c  */
    7037 #line 1515 "parser.yy"
     7033#line 1509 "parser.yy"
    70387034    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    70397035    break;
     
    70427038
    70437039/* Line 1806 of yacc.c  */
    7044 #line 1517 "parser.yy"
     7040#line 1511 "parser.yy"
    70457041    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    70467042    break;
     
    70497045
    70507046/* Line 1806 of yacc.c  */
    7051 #line 1519 "parser.yy"
     7047#line 1513 "parser.yy"
    70527048    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    70537049    break;
     
    70567052
    70577053/* Line 1806 of yacc.c  */
    7058 #line 1524 "parser.yy"
     7054#line 1518 "parser.yy"
    70597055    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    70607056    break;
     
    70637059
    70647060/* Line 1806 of yacc.c  */
    7065 #line 1526 "parser.yy"
     7061#line 1520 "parser.yy"
    70667062    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    70677063    break;
     
    70707066
    70717067/* Line 1806 of yacc.c  */
    7072 #line 1531 "parser.yy"
     7068#line 1525 "parser.yy"
    70737069    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    70747070    break;
     
    70777073
    70787074/* Line 1806 of yacc.c  */
     7075#line 1527 "parser.yy"
     7076    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
     7077    break;
     7078
     7079  case 384:
     7080
     7081/* Line 1806 of yacc.c  */
     7082#line 1530 "parser.yy"
     7083    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     7084    break;
     7085
     7086  case 385:
     7087
     7088/* Line 1806 of yacc.c  */
    70797089#line 1533 "parser.yy"
    7080     { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    7081     break;
    7082 
    7083   case 384:
    7084 
    7085 /* Line 1806 of yacc.c  */
    7086 #line 1536 "parser.yy"
    70877090    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    70887091    break;
    70897092
    7090   case 385:
     7093  case 387:
    70917094
    70927095/* Line 1806 of yacc.c  */
    70937096#line 1539 "parser.yy"
    7094     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    7095     break;
    7096 
    7097   case 387:
    7098 
    7099 /* Line 1806 of yacc.c  */
    7100 #line 1545 "parser.yy"
    71017097    { (yyval.en) = 0; }
    71027098    break;
     
    71057101
    71067102/* Line 1806 of yacc.c  */
    7107 #line 1547 "parser.yy"
     7103#line 1541 "parser.yy"
    71087104    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    71097105    break;
     
    71127108
    71137109/* Line 1806 of yacc.c  */
    7114 #line 1552 "parser.yy"
     7110#line 1546 "parser.yy"
    71157111    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    71167112    break;
     
    71197115
    71207116/* Line 1806 of yacc.c  */
    7121 #line 1561 "parser.yy"
     7117#line 1555 "parser.yy"
    71227118    { (yyval.decl) = DeclarationNode::newEnum( 0, (yyvsp[(3) - (5)].decl) ); }
    71237119    break;
     
    71267122
    71277123/* Line 1806 of yacc.c  */
    7128 #line 1563 "parser.yy"
     7124#line 1557 "parser.yy"
    71297125    {
    71307126                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
     
    71367132
    71377133/* Line 1806 of yacc.c  */
    7138 #line 1568 "parser.yy"
     7134#line 1562 "parser.yy"
    71397135    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    71407136    break;
     
    71437139
    71447140/* Line 1806 of yacc.c  */
    7145 #line 1570 "parser.yy"
     7141#line 1564 "parser.yy"
    71467142    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    71477143    break;
     
    71507146
    71517147/* Line 1806 of yacc.c  */
    7152 #line 1575 "parser.yy"
     7148#line 1569 "parser.yy"
    71537149    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    71547150    break;
     
    71577153
    71587154/* Line 1806 of yacc.c  */
    7159 #line 1577 "parser.yy"
     7155#line 1571 "parser.yy"
    71607156    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    71617157    break;
     
    71647160
    71657161/* Line 1806 of yacc.c  */
    7166 #line 1582 "parser.yy"
     7162#line 1576 "parser.yy"
    71677163    { (yyval.en) = 0; }
    71687164    break;
     
    71717167
    71727168/* Line 1806 of yacc.c  */
    7173 #line 1584 "parser.yy"
     7169#line 1578 "parser.yy"
    71747170    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    71757171    break;
     
    71787174
    71797175/* Line 1806 of yacc.c  */
    7180 #line 1591 "parser.yy"
     7176#line 1585 "parser.yy"
    71817177    { (yyval.decl) = 0; }
    71827178    break;
     
    71857181
    71867182/* Line 1806 of yacc.c  */
    7187 #line 1599 "parser.yy"
     7183#line 1593 "parser.yy"
    71887184    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    71897185    break;
     
    71927188
    71937189/* Line 1806 of yacc.c  */
    7194 #line 1601 "parser.yy"
     7190#line 1595 "parser.yy"
    71957191    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    71967192    break;
     
    71997195
    72007196/* Line 1806 of yacc.c  */
    7201 #line 1603 "parser.yy"
     7197#line 1597 "parser.yy"
    72027198    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72037199    break;
     
    72067202
    72077203/* Line 1806 of yacc.c  */
    7208 #line 1611 "parser.yy"
     7204#line 1605 "parser.yy"
    72097205    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72107206    break;
     
    72137209
    72147210/* Line 1806 of yacc.c  */
    7215 #line 1613 "parser.yy"
     7211#line 1607 "parser.yy"
    72167212    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72177213    break;
     
    72207216
    72217217/* Line 1806 of yacc.c  */
     7218#line 1609 "parser.yy"
     7219    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
     7220    break;
     7221
     7222  case 411:
     7223
     7224/* Line 1806 of yacc.c  */
    72227225#line 1615 "parser.yy"
    7223     { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    7224     break;
    7225 
    7226   case 411:
    7227 
    7228 /* Line 1806 of yacc.c  */
    7229 #line 1621 "parser.yy"
    72307226    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72317227    break;
     
    72347230
    72357231/* Line 1806 of yacc.c  */
    7236 #line 1626 "parser.yy"
     7232#line 1620 "parser.yy"
    72377233    { (yyval.decl) = 0; }
    72387234    break;
     
    72417237
    72427238/* Line 1806 of yacc.c  */
    7243 #line 1633 "parser.yy"
     7239#line 1627 "parser.yy"
    72447240    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72457241    break;
     
    72487244
    72497245/* Line 1806 of yacc.c  */
    7250 #line 1640 "parser.yy"
     7246#line 1634 "parser.yy"
    72517247    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72527248    break;
     
    72557251
    72567252/* Line 1806 of yacc.c  */
    7257 #line 1642 "parser.yy"
     7253#line 1636 "parser.yy"
    72587254    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72597255    break;
     
    72627258
    72637259/* Line 1806 of yacc.c  */
    7264 #line 1651 "parser.yy"
     7260#line 1645 "parser.yy"
    72657261    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    72667262    break;
     
    72697265
    72707266/* Line 1806 of yacc.c  */
    7271 #line 1654 "parser.yy"
     7267#line 1648 "parser.yy"
    72727268    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    72737269    break;
     
    72767272
    72777273/* Line 1806 of yacc.c  */
    7278 #line 1656 "parser.yy"
     7274#line 1650 "parser.yy"
    72797275    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    72807276    break;
     
    72837279
    72847280/* Line 1806 of yacc.c  */
     7281#line 1660 "parser.yy"
     7282    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     7283    break;
     7284
     7285  case 430:
     7286
     7287/* Line 1806 of yacc.c  */
    72857288#line 1666 "parser.yy"
    7286     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7287     break;
    7288 
    7289   case 430:
    7290 
    7291 /* Line 1806 of yacc.c  */
    7292 #line 1672 "parser.yy"
    72937289    {
    72947290                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73007296
    73017297/* Line 1806 of yacc.c  */
    7302 #line 1677 "parser.yy"
     7298#line 1671 "parser.yy"
    73037299    {
    73047300                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    73107306
    73117307/* Line 1806 of yacc.c  */
    7312 #line 1686 "parser.yy"
     7308#line 1680 "parser.yy"
    73137309    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73147310    break;
     
    73177313
    73187314/* Line 1806 of yacc.c  */
    7319 #line 1695 "parser.yy"
     7315#line 1689 "parser.yy"
    73207316    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    73217317    break;
     
    73247320
    73257321/* Line 1806 of yacc.c  */
    7326 #line 1697 "parser.yy"
     7322#line 1691 "parser.yy"
    73277323    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    73287324    break;
     
    73317327
    73327328/* Line 1806 of yacc.c  */
    7333 #line 1722 "parser.yy"
     7329#line 1716 "parser.yy"
    73347330    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73357331    break;
     
    73387334
    73397335/* Line 1806 of yacc.c  */
    7340 #line 1730 "parser.yy"
     7336#line 1724 "parser.yy"
    73417337    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73427338    break;
     
    73457341
    73467342/* Line 1806 of yacc.c  */
    7347 #line 1735 "parser.yy"
     7343#line 1729 "parser.yy"
    73487344    { (yyval.in) = 0; }
    73497345    break;
     
    73527348
    73537349/* Line 1806 of yacc.c  */
     7350#line 1731 "parser.yy"
     7351    { (yyval.in) = (yyvsp[(2) - (2)].in); }
     7352    break;
     7353
     7354  case 454:
     7355
     7356/* Line 1806 of yacc.c  */
     7357#line 1733 "parser.yy"
     7358    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
     7359    break;
     7360
     7361  case 455:
     7362
     7363/* Line 1806 of yacc.c  */
    73547364#line 1737 "parser.yy"
    7355     { (yyval.in) = (yyvsp[(2) - (2)].in); }
    7356     break;
    7357 
    7358   case 454:
    7359 
    7360 /* Line 1806 of yacc.c  */
    7361 #line 1739 "parser.yy"
    7362     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    7363     break;
    7364 
    7365   case 455:
     7365    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
     7366    break;
     7367
     7368  case 456:
     7369
     7370/* Line 1806 of yacc.c  */
     7371#line 1738 "parser.yy"
     7372    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
     7373    break;
     7374
     7375  case 457:
    73667376
    73677377/* Line 1806 of yacc.c  */
    73687378#line 1743 "parser.yy"
    7369     { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    7370     break;
    7371 
    7372   case 456:
    7373 
    7374 /* Line 1806 of yacc.c  */
    7375 #line 1744 "parser.yy"
    7376     { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    7377     break;
    7378 
    7379   case 457:
    7380 
    7381 /* Line 1806 of yacc.c  */
    7382 #line 1749 "parser.yy"
    73837379    { (yyval.in) = 0; }
    73847380    break;
     
    73877383
    73887384/* Line 1806 of yacc.c  */
    7389 #line 1751 "parser.yy"
     7385#line 1745 "parser.yy"
    73907386    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    73917387    break;
     
    73947390
    73957391/* Line 1806 of yacc.c  */
    7396 #line 1752 "parser.yy"
    7397     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_link( (yyvsp[(3) - (3)].in) ) ); }
     7392#line 1746 "parser.yy"
     7393    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
    73987394    break;
    73997395
     
    74017397
    74027398/* Line 1806 of yacc.c  */
    7403 #line 1754 "parser.yy"
    7404     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_link( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
     7399#line 1748 "parser.yy"
     7400    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    74057401    break;
    74067402
     
    74087404
    74097405/* Line 1806 of yacc.c  */
     7406#line 1764 "parser.yy"
     7407    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
     7408    break;
     7409
     7410  case 465:
     7411
     7412/* Line 1806 of yacc.c  */
    74107413#line 1770 "parser.yy"
    7411     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
    7412     break;
    7413 
    7414   case 465:
     7414    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
     7415    break;
     7416
     7417  case 466:
    74157418
    74167419/* Line 1806 of yacc.c  */
    74177420#line 1776 "parser.yy"
    7418     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_link( (yyvsp[(2) - (2)].en) ) ); }
    7419     break;
    7420 
    7421   case 466:
    7422 
    7423 /* Line 1806 of yacc.c  */
    7424 #line 1782 "parser.yy"
    74257421    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
    74267422    break;
     
    74297425
    74307426/* Line 1806 of yacc.c  */
     7427#line 1779 "parser.yy"
     7428    { (yyval.en) = (yyvsp[(3) - (5)].en); }
     7429    break;
     7430
     7431  case 468:
     7432
     7433/* Line 1806 of yacc.c  */
     7434#line 1781 "parser.yy"
     7435    { (yyval.en) = (yyvsp[(3) - (5)].en); }
     7436    break;
     7437
     7438  case 469:
     7439
     7440/* Line 1806 of yacc.c  */
     7441#line 1783 "parser.yy"
     7442    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
     7443    break;
     7444
     7445  case 470:
     7446
     7447/* Line 1806 of yacc.c  */
    74317448#line 1785 "parser.yy"
    7432     { (yyval.en) = (yyvsp[(3) - (5)].en); }
    7433     break;
    7434 
    7435   case 468:
    7436 
    7437 /* Line 1806 of yacc.c  */
    7438 #line 1787 "parser.yy"
    7439     { (yyval.en) = (yyvsp[(3) - (5)].en); }
    7440     break;
    7441 
    7442   case 469:
    7443 
    7444 /* Line 1806 of yacc.c  */
    7445 #line 1789 "parser.yy"
    7446     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
    7447     break;
    7448 
    7449   case 470:
    7450 
    7451 /* Line 1806 of yacc.c  */
    7452 #line 1791 "parser.yy"
    74537449    { (yyval.en) = (yyvsp[(4) - (6)].en); }
    74547450    break;
     
    74577453
    74587454/* Line 1806 of yacc.c  */
    7459 #line 1815 "parser.yy"
     7455#line 1809 "parser.yy"
    74607456    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    74617457    break;
     
    74647460
    74657461/* Line 1806 of yacc.c  */
    7466 #line 1817 "parser.yy"
     7462#line 1811 "parser.yy"
    74677463    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    74687464    break;
     
    74717467
    74727468/* Line 1806 of yacc.c  */
     7469#line 1813 "parser.yy"
     7470    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     7471    break;
     7472
     7473  case 476:
     7474
     7475/* Line 1806 of yacc.c  */
    74737476#line 1819 "parser.yy"
    7474     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    7475     break;
    7476 
    7477   case 476:
    7478 
    7479 /* Line 1806 of yacc.c  */
    7480 #line 1825 "parser.yy"
    74817477    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    74827478    break;
     
    74857481
    74867482/* Line 1806 of yacc.c  */
    7487 #line 1827 "parser.yy"
     7483#line 1821 "parser.yy"
    74887484    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    74897485    break;
     
    74927488
    74937489/* Line 1806 of yacc.c  */
     7490#line 1826 "parser.yy"
     7491    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
     7492    break;
     7493
     7494  case 480:
     7495
     7496/* Line 1806 of yacc.c  */
    74947497#line 1832 "parser.yy"
    7495     { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    7496     break;
    7497 
    7498   case 480:
    7499 
    7500 /* Line 1806 of yacc.c  */
    7501 #line 1838 "parser.yy"
    75027498    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    75037499    break;
     
    75067502
    75077503/* Line 1806 of yacc.c  */
    7508 #line 1843 "parser.yy"
     7504#line 1837 "parser.yy"
    75097505    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    75107506    break;
     
    75137509
    75147510/* Line 1806 of yacc.c  */
     7511#line 1839 "parser.yy"
     7512    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
     7513    break;
     7514
     7515  case 484:
     7516
     7517/* Line 1806 of yacc.c  */
    75157518#line 1845 "parser.yy"
    7516     { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    7517     break;
    7518 
    7519   case 484:
    7520 
    7521 /* Line 1806 of yacc.c  */
    7522 #line 1851 "parser.yy"
    75237519    { (yyval.tclass) = DeclarationNode::Type; }
    75247520    break;
     
    75277523
    75287524/* Line 1806 of yacc.c  */
    7529 #line 1853 "parser.yy"
     7525#line 1847 "parser.yy"
    75307526    { (yyval.tclass) = DeclarationNode::Ftype; }
    75317527    break;
     
    75347530
    75357531/* Line 1806 of yacc.c  */
    7536 #line 1855 "parser.yy"
     7532#line 1849 "parser.yy"
    75377533    { (yyval.tclass) = DeclarationNode::Dtype; }
    75387534    break;
     
    75417537
    75427538/* Line 1806 of yacc.c  */
    7543 #line 1860 "parser.yy"
     7539#line 1854 "parser.yy"
    75447540    { (yyval.decl) = 0; }
    75457541    break;
     
    75487544
    75497545/* Line 1806 of yacc.c  */
    7550 #line 1862 "parser.yy"
     7546#line 1856 "parser.yy"
    75517547    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    75527548    break;
     
    75557551
    75567552/* Line 1806 of yacc.c  */
    7557 #line 1867 "parser.yy"
     7553#line 1861 "parser.yy"
    75587554    {
    75597555                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
     
    75657561
    75667562/* Line 1806 of yacc.c  */
    7567 #line 1872 "parser.yy"
     7563#line 1866 "parser.yy"
    75687564    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    75697565    break;
     
    75727568
    75737569/* Line 1806 of yacc.c  */
    7574 #line 1874 "parser.yy"
     7570#line 1868 "parser.yy"
    75757571    { (yyval.decl) = 0; }
    75767572    break;
     
    75797575
    75807576/* Line 1806 of yacc.c  */
    7581 #line 1879 "parser.yy"
     7577#line 1873 "parser.yy"
    75827578    { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
    75837579    break;
     
    75867582
    75877583/* Line 1806 of yacc.c  */
    7588 #line 1882 "parser.yy"
    7589     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
     7584#line 1876 "parser.yy"
     7585    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
    75907586    break;
    75917587
     
    75937589
    75947590/* Line 1806 of yacc.c  */
    7595 #line 1884 "parser.yy"
    7596     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_link( (yyvsp[(3) - (3)].en) )); }
     7591#line 1878 "parser.yy"
     7592    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
    75977593    break;
    75987594
     
    76007596
    76017597/* Line 1806 of yacc.c  */
    7602 #line 1889 "parser.yy"
     7598#line 1883 "parser.yy"
    76037599    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    76047600    break;
     
    76077603
    76087604/* Line 1806 of yacc.c  */
    7609 #line 1891 "parser.yy"
     7605#line 1885 "parser.yy"
    76107606    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    76117607    break;
     
    76147610
    76157611/* Line 1806 of yacc.c  */
    7616 #line 1893 "parser.yy"
     7612#line 1887 "parser.yy"
    76177613    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    76187614    break;
     
    76217617
    76227618/* Line 1806 of yacc.c  */
    7623 #line 1898 "parser.yy"
     7619#line 1892 "parser.yy"
    76247620    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    76257621    break;
     
    76287624
    76297625/* Line 1806 of yacc.c  */
    7630 #line 1900 "parser.yy"
     7626#line 1894 "parser.yy"
    76317627    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    76327628    break;
     
    76357631
    76367632/* Line 1806 of yacc.c  */
    7637 #line 1905 "parser.yy"
     7633#line 1899 "parser.yy"
    76387634    {
    76397635                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
     
    76457641
    76467642/* Line 1806 of yacc.c  */
    7647 #line 1910 "parser.yy"
     7643#line 1904 "parser.yy"
    76487644    {
    76497645                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
     
    76557651
    76567652/* Line 1806 of yacc.c  */
    7657 #line 1918 "parser.yy"
     7653#line 1912 "parser.yy"
    76587654    {
    76597655                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
     
    76657661
    76667662/* Line 1806 of yacc.c  */
    7667 #line 1923 "parser.yy"
     7663#line 1917 "parser.yy"
    76687664    {
    76697665                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
     
    76757671
    76767672/* Line 1806 of yacc.c  */
    7677 #line 1928 "parser.yy"
     7673#line 1922 "parser.yy"
    76787674    {
    76797675                        typedefTable.leaveTrait();
     
    76867682
    76877683/* Line 1806 of yacc.c  */
    7688 #line 1938 "parser.yy"
     7684#line 1932 "parser.yy"
    76897685    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    76907686    break;
     
    76937689
    76947690/* Line 1806 of yacc.c  */
    7695 #line 1948 "parser.yy"
     7691#line 1942 "parser.yy"
    76967692    {
    76977693                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77037699
    77047700/* Line 1806 of yacc.c  */
    7705 #line 1953 "parser.yy"
     7701#line 1947 "parser.yy"
    77067702    {
    77077703                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77137709
    77147710/* Line 1806 of yacc.c  */
    7715 #line 1958 "parser.yy"
     7711#line 1952 "parser.yy"
    77167712    {
    77177713                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
     
    77237719
    77247720/* Line 1806 of yacc.c  */
    7725 #line 1966 "parser.yy"
     7721#line 1960 "parser.yy"
    77267722    {
    77277723                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77337729
    77347730/* Line 1806 of yacc.c  */
    7735 #line 1971 "parser.yy"
     7731#line 1965 "parser.yy"
    77367732    {
    77377733                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
     
    77437739
    77447740/* Line 1806 of yacc.c  */
    7745 #line 1981 "parser.yy"
     7741#line 1975 "parser.yy"
    77467742    {}
    77477743    break;
     
    77507746
    77517747/* Line 1806 of yacc.c  */
    7752 #line 1983 "parser.yy"
     7748#line 1977 "parser.yy"
    77537749    {
    77547750                        if ( theTree ) {
     
    77637759
    77647760/* Line 1806 of yacc.c  */
    7765 #line 1995 "parser.yy"
     7761#line 1989 "parser.yy"
    77667762    { (yyval.decl) = ( (yyvsp[(1) - (3)].decl) != NULL ) ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    77677763    break;
     
    77707766
    77717767/* Line 1806 of yacc.c  */
    7772 #line 2000 "parser.yy"
     7768#line 1994 "parser.yy"
    77737769    { (yyval.decl) = 0; }
    77747770    break;
     
    77777773
    77787774/* Line 1806 of yacc.c  */
    7779 #line 2008 "parser.yy"
     7775#line 2002 "parser.yy"
    77807776    {}
    77817777    break;
     
    77847780
    77857781/* Line 1806 of yacc.c  */
    7786 #line 2010 "parser.yy"
     7782#line 2004 "parser.yy"
    77877783    {
    77887784                        linkageStack.push( linkage );
     
    77947790
    77957791/* Line 1806 of yacc.c  */
    7796 #line 2015 "parser.yy"
     7792#line 2009 "parser.yy"
    77977793    {
    77987794                        linkage = linkageStack.top();
     
    78057801
    78067802/* Line 1806 of yacc.c  */
    7807 #line 2021 "parser.yy"
     7803#line 2015 "parser.yy"
    78087804    {   // mark all fields in list
    7809                         for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     7805                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != NULL; iter = (DeclarationNode *)iter->get_next() )
    78107806                                iter->set_extension( true );
    78117807                        (yyval.decl) = (yyvsp[(2) - (2)].decl);
     
    78167812
    78177813/* Line 1806 of yacc.c  */
    7818 #line 2036 "parser.yy"
     7814#line 2030 "parser.yy"
    78197815    {
    78207816                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78277823
    78287824/* Line 1806 of yacc.c  */
    7829 #line 2042 "parser.yy"
     7825#line 2036 "parser.yy"
    78307826    {
    78317827                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78387834
    78397835/* Line 1806 of yacc.c  */
    7840 #line 2051 "parser.yy"
     7836#line 2045 "parser.yy"
    78417837    {
    78427838                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78497845
    78507846/* Line 1806 of yacc.c  */
    7851 #line 2057 "parser.yy"
     7847#line 2051 "parser.yy"
    78527848    {
    78537849                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78587854
    78597855  case 532:
     7856
     7857/* Line 1806 of yacc.c  */
     7858#line 2057 "parser.yy"
     7859    {
     7860                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     7861                        typedefTable.leaveScope();
     7862                        (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) );
     7863                }
     7864    break;
     7865
     7866  case 533:
    78607867
    78617868/* Line 1806 of yacc.c  */
     
    78687875    break;
    78697876
    7870   case 533:
     7877  case 534:
    78717878
    78727879/* Line 1806 of yacc.c  */
    78737880#line 2069 "parser.yy"
    7874     {
    7875                         typedefTable.addToEnclosingScope( TypedefTable::ID );
    7876                         typedefTable.leaveScope();
    7877                         (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) );
    7878                 }
    7879     break;
    7880 
    7881   case 534:
    7882 
    7883 /* Line 1806 of yacc.c  */
    7884 #line 2075 "parser.yy"
    78857881    {
    78867882                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    78937889
    78947890/* Line 1806 of yacc.c  */
    7895 #line 2083 "parser.yy"
     7891#line 2077 "parser.yy"
    78967892    {
    78977893                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79047900
    79057901/* Line 1806 of yacc.c  */
    7906 #line 2089 "parser.yy"
     7902#line 2083 "parser.yy"
    79077903    {
    79087904                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79157911
    79167912/* Line 1806 of yacc.c  */
    7917 #line 2097 "parser.yy"
     7913#line 2091 "parser.yy"
    79187914    {
    79197915                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79267922
    79277923/* Line 1806 of yacc.c  */
    7928 #line 2103 "parser.yy"
     7924#line 2097 "parser.yy"
    79297925    {
    79307926                        typedefTable.addToEnclosingScope( TypedefTable::ID );
     
    79377933
    79387934/* Line 1806 of yacc.c  */
    7939 #line 2118 "parser.yy"
     7935#line 2112 "parser.yy"
    79407936    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    79417937    break;
     
    79447940
    79457941/* Line 1806 of yacc.c  */
    7946 #line 2128 "parser.yy"
     7942#line 2122 "parser.yy"
    79477943    { (yyval.decl) = 0; }
    79487944    break;
     
    79517947
    79527948/* Line 1806 of yacc.c  */
     7949#line 2129 "parser.yy"
     7950    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     7951    break;
     7952
     7953  case 549:
     7954
     7955/* Line 1806 of yacc.c  */
    79537956#line 2135 "parser.yy"
    7954     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    7955     break;
    7956 
    7957   case 549:
    7958 
    7959 /* Line 1806 of yacc.c  */
    7960 #line 2141 "parser.yy"
    79617957    { (yyval.decl) = 0; }
    79627958    break;
     
    79657961
    79667962/* Line 1806 of yacc.c  */
    7967 #line 2156 "parser.yy"
     7963#line 2150 "parser.yy"
    79687964    {}
    79697965    break;
     
    79727968
    79737969/* Line 1806 of yacc.c  */
    7974 #line 2157 "parser.yy"
     7970#line 2151 "parser.yy"
    79757971    {}
    79767972    break;
     
    79797975
    79807976/* Line 1806 of yacc.c  */
    7981 #line 2158 "parser.yy"
     7977#line 2152 "parser.yy"
    79827978    {}
    79837979    break;
     
    79867982
    79877983/* Line 1806 of yacc.c  */
    7988 #line 2159 "parser.yy"
     7984#line 2153 "parser.yy"
    79897985    {}
    79907986    break;
     
    79937989
    79947990/* Line 1806 of yacc.c  */
    7995 #line 2194 "parser.yy"
     7991#line 2188 "parser.yy"
    79967992    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    79977993    break;
     
    80007996
    80017997/* Line 1806 of yacc.c  */
    8002 #line 2197 "parser.yy"
     7998#line 2191 "parser.yy"
    80037999    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80048000    break;
     
    80078003
    80088004/* Line 1806 of yacc.c  */
    8009 #line 2199 "parser.yy"
     8005#line 2193 "parser.yy"
    80108006    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80118007    break;
     
    80148010
    80158011/* Line 1806 of yacc.c  */
    8016 #line 2204 "parser.yy"
     8012#line 2198 "parser.yy"
    80178013    {
    80188014                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    80248020
    80258021/* Line 1806 of yacc.c  */
    8026 #line 2209 "parser.yy"
     8022#line 2203 "parser.yy"
    80278023    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80288024    break;
     
    80318027
    80328028/* Line 1806 of yacc.c  */
    8033 #line 2214 "parser.yy"
     8029#line 2208 "parser.yy"
    80348030    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    80358031    break;
     
    80388034
    80398035/* Line 1806 of yacc.c  */
    8040 #line 2216 "parser.yy"
     8036#line 2210 "parser.yy"
    80418037    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    80428038    break;
     
    80458041
    80468042/* Line 1806 of yacc.c  */
    8047 #line 2218 "parser.yy"
     8043#line 2212 "parser.yy"
    80488044    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80498045    break;
     
    80528048
    80538049/* Line 1806 of yacc.c  */
     8050#line 2217 "parser.yy"
     8051    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8052    break;
     8053
     8054  case 569:
     8055
     8056/* Line 1806 of yacc.c  */
     8057#line 2219 "parser.yy"
     8058    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8059    break;
     8060
     8061  case 570:
     8062
     8063/* Line 1806 of yacc.c  */
     8064#line 2221 "parser.yy"
     8065    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8066    break;
     8067
     8068  case 571:
     8069
     8070/* Line 1806 of yacc.c  */
    80548071#line 2223 "parser.yy"
     8072    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8073    break;
     8074
     8075  case 572:
     8076
     8077/* Line 1806 of yacc.c  */
     8078#line 2228 "parser.yy"
     8079    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8080    break;
     8081
     8082  case 573:
     8083
     8084/* Line 1806 of yacc.c  */
     8085#line 2230 "parser.yy"
     8086    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8087    break;
     8088
     8089  case 574:
     8090
     8091/* Line 1806 of yacc.c  */
     8092#line 2239 "parser.yy"
     8093    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8094    break;
     8095
     8096  case 576:
     8097
     8098/* Line 1806 of yacc.c  */
     8099#line 2242 "parser.yy"
     8100    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8101    break;
     8102
     8103  case 577:
     8104
     8105/* Line 1806 of yacc.c  */
     8106#line 2247 "parser.yy"
     8107    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8108    break;
     8109
     8110  case 578:
     8111
     8112/* Line 1806 of yacc.c  */
     8113#line 2249 "parser.yy"
     8114    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8115    break;
     8116
     8117  case 579:
     8118
     8119/* Line 1806 of yacc.c  */
     8120#line 2251 "parser.yy"
     8121    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8122    break;
     8123
     8124  case 580:
     8125
     8126/* Line 1806 of yacc.c  */
     8127#line 2256 "parser.yy"
     8128    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8129    break;
     8130
     8131  case 581:
     8132
     8133/* Line 1806 of yacc.c  */
     8134#line 2258 "parser.yy"
     8135    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8136    break;
     8137
     8138  case 582:
     8139
     8140/* Line 1806 of yacc.c  */
     8141#line 2260 "parser.yy"
     8142    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8143    break;
     8144
     8145  case 583:
     8146
     8147/* Line 1806 of yacc.c  */
     8148#line 2265 "parser.yy"
     8149    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8150    break;
     8151
     8152  case 584:
     8153
     8154/* Line 1806 of yacc.c  */
     8155#line 2267 "parser.yy"
     8156    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8157    break;
     8158
     8159  case 585:
     8160
     8161/* Line 1806 of yacc.c  */
     8162#line 2269 "parser.yy"
     8163    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8164    break;
     8165
     8166  case 589:
     8167
     8168/* Line 1806 of yacc.c  */
     8169#line 2284 "parser.yy"
     8170    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
     8171    break;
     8172
     8173  case 590:
     8174
     8175/* Line 1806 of yacc.c  */
     8176#line 2286 "parser.yy"
     8177    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
     8178    break;
     8179
     8180  case 591:
     8181
     8182/* Line 1806 of yacc.c  */
     8183#line 2288 "parser.yy"
     8184    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8185    break;
     8186
     8187  case 592:
     8188
     8189/* Line 1806 of yacc.c  */
     8190#line 2293 "parser.yy"
     8191    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8192    break;
     8193
     8194  case 593:
     8195
     8196/* Line 1806 of yacc.c  */
     8197#line 2295 "parser.yy"
     8198    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8199    break;
     8200
     8201  case 594:
     8202
     8203/* Line 1806 of yacc.c  */
     8204#line 2297 "parser.yy"
     8205    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8206    break;
     8207
     8208  case 595:
     8209
     8210/* Line 1806 of yacc.c  */
     8211#line 2302 "parser.yy"
     8212    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8213    break;
     8214
     8215  case 596:
     8216
     8217/* Line 1806 of yacc.c  */
     8218#line 2304 "parser.yy"
     8219    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8220    break;
     8221
     8222  case 597:
     8223
     8224/* Line 1806 of yacc.c  */
     8225#line 2306 "parser.yy"
     8226    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8227    break;
     8228
     8229  case 598:
     8230
     8231/* Line 1806 of yacc.c  */
     8232#line 2321 "parser.yy"
     8233    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8234    break;
     8235
     8236  case 600:
     8237
     8238/* Line 1806 of yacc.c  */
     8239#line 2324 "parser.yy"
     8240    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8241    break;
     8242
     8243  case 601:
     8244
     8245/* Line 1806 of yacc.c  */
     8246#line 2326 "parser.yy"
     8247    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8248    break;
     8249
     8250  case 603:
     8251
     8252/* Line 1806 of yacc.c  */
     8253#line 2332 "parser.yy"
     8254    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8255    break;
     8256
     8257  case 604:
     8258
     8259/* Line 1806 of yacc.c  */
     8260#line 2337 "parser.yy"
     8261    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8262    break;
     8263
     8264  case 605:
     8265
     8266/* Line 1806 of yacc.c  */
     8267#line 2339 "parser.yy"
     8268    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8269    break;
     8270
     8271  case 606:
     8272
     8273/* Line 1806 of yacc.c  */
     8274#line 2341 "parser.yy"
     8275    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8276    break;
     8277
     8278  case 607:
     8279
     8280/* Line 1806 of yacc.c  */
     8281#line 2346 "parser.yy"
    80558282    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    80568283    break;
    80578284
    8058   case 569:
    8059 
    8060 /* Line 1806 of yacc.c  */
    8061 #line 2225 "parser.yy"
     8285  case 608:
     8286
     8287/* Line 1806 of yacc.c  */
     8288#line 2348 "parser.yy"
    80628289    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    80638290    break;
    80648291
    8065   case 570:
    8066 
    8067 /* Line 1806 of yacc.c  */
    8068 #line 2227 "parser.yy"
     8292  case 609:
     8293
     8294/* Line 1806 of yacc.c  */
     8295#line 2350 "parser.yy"
    80698296    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    80708297    break;
    80718298
    8072   case 571:
    8073 
    8074 /* Line 1806 of yacc.c  */
    8075 #line 2229 "parser.yy"
     8299  case 610:
     8300
     8301/* Line 1806 of yacc.c  */
     8302#line 2352 "parser.yy"
    80768303    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80778304    break;
    80788305
    8079   case 572:
    8080 
    8081 /* Line 1806 of yacc.c  */
    8082 #line 2234 "parser.yy"
     8306  case 611:
     8307
     8308/* Line 1806 of yacc.c  */
     8309#line 2357 "parser.yy"
     8310    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8311    break;
     8312
     8313  case 612:
     8314
     8315/* Line 1806 of yacc.c  */
     8316#line 2359 "parser.yy"
    80838317    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    80848318    break;
    80858319
    8086   case 573:
    8087 
    8088 /* Line 1806 of yacc.c  */
    8089 #line 2236 "parser.yy"
     8320  case 613:
     8321
     8322/* Line 1806 of yacc.c  */
     8323#line 2361 "parser.yy"
    80908324    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80918325    break;
    80928326
    8093   case 574:
    8094 
    8095 /* Line 1806 of yacc.c  */
    8096 #line 2245 "parser.yy"
     8327  case 614:
     8328
     8329/* Line 1806 of yacc.c  */
     8330#line 2371 "parser.yy"
    80978331    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80988332    break;
    80998333
    8100   case 576:
    8101 
    8102 /* Line 1806 of yacc.c  */
    8103 #line 2248 "parser.yy"
     8334  case 616:
     8335
     8336/* Line 1806 of yacc.c  */
     8337#line 2374 "parser.yy"
    81048338    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81058339    break;
    81068340
    8107   case 577:
    8108 
    8109 /* Line 1806 of yacc.c  */
    8110 #line 2253 "parser.yy"
     8341  case 617:
     8342
     8343/* Line 1806 of yacc.c  */
     8344#line 2376 "parser.yy"
     8345    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8346    break;
     8347
     8348  case 618:
     8349
     8350/* Line 1806 of yacc.c  */
     8351#line 2381 "parser.yy"
     8352    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8353    break;
     8354
     8355  case 619:
     8356
     8357/* Line 1806 of yacc.c  */
     8358#line 2383 "parser.yy"
     8359    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8360    break;
     8361
     8362  case 620:
     8363
     8364/* Line 1806 of yacc.c  */
     8365#line 2385 "parser.yy"
     8366    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8367    break;
     8368
     8369  case 621:
     8370
     8371/* Line 1806 of yacc.c  */
     8372#line 2390 "parser.yy"
     8373    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8374    break;
     8375
     8376  case 622:
     8377
     8378/* Line 1806 of yacc.c  */
     8379#line 2392 "parser.yy"
     8380    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8381    break;
     8382
     8383  case 623:
     8384
     8385/* Line 1806 of yacc.c  */
     8386#line 2394 "parser.yy"
     8387    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8388    break;
     8389
     8390  case 624:
     8391
     8392/* Line 1806 of yacc.c  */
     8393#line 2396 "parser.yy"
     8394    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8395    break;
     8396
     8397  case 625:
     8398
     8399/* Line 1806 of yacc.c  */
     8400#line 2401 "parser.yy"
    81118401    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    81128402    break;
    81138403
    8114   case 578:
    8115 
    8116 /* Line 1806 of yacc.c  */
    8117 #line 2255 "parser.yy"
     8404  case 626:
     8405
     8406/* Line 1806 of yacc.c  */
     8407#line 2403 "parser.yy"
    81188408    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81198409    break;
    81208410
    8121   case 579:
    8122 
    8123 /* Line 1806 of yacc.c  */
    8124 #line 2257 "parser.yy"
     8411  case 627:
     8412
     8413/* Line 1806 of yacc.c  */
     8414#line 2405 "parser.yy"
    81258415    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81268416    break;
    81278417
    8128   case 580:
    8129 
    8130 /* Line 1806 of yacc.c  */
    8131 #line 2262 "parser.yy"
    8132     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8133     break;
    8134 
    8135   case 581:
    8136 
    8137 /* Line 1806 of yacc.c  */
    8138 #line 2264 "parser.yy"
    8139     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8140     break;
    8141 
    8142   case 582:
    8143 
    8144 /* Line 1806 of yacc.c  */
    8145 #line 2266 "parser.yy"
    8146     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8147     break;
    8148 
    8149   case 583:
    8150 
    8151 /* Line 1806 of yacc.c  */
    8152 #line 2271 "parser.yy"
    8153     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8154     break;
    8155 
    8156   case 584:
    8157 
    8158 /* Line 1806 of yacc.c  */
    8159 #line 2273 "parser.yy"
    8160     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8161     break;
    8162 
    8163   case 585:
    8164 
    8165 /* Line 1806 of yacc.c  */
    8166 #line 2275 "parser.yy"
    8167     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8168     break;
    8169 
    8170   case 589:
    8171 
    8172 /* Line 1806 of yacc.c  */
    8173 #line 2290 "parser.yy"
    8174     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    8175     break;
    8176 
    8177   case 590:
    8178 
    8179 /* Line 1806 of yacc.c  */
    8180 #line 2292 "parser.yy"
    8181     { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    8182     break;
    8183 
    8184   case 591:
    8185 
    8186 /* Line 1806 of yacc.c  */
    8187 #line 2294 "parser.yy"
    8188     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8189     break;
    8190 
    8191   case 592:
    8192 
    8193 /* Line 1806 of yacc.c  */
    8194 #line 2299 "parser.yy"
    8195     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8196     break;
    8197 
    8198   case 593:
    8199 
    8200 /* Line 1806 of yacc.c  */
    8201 #line 2301 "parser.yy"
    8202     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8203     break;
    8204 
    8205   case 594:
    8206 
    8207 /* Line 1806 of yacc.c  */
    8208 #line 2303 "parser.yy"
    8209     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8210     break;
    8211 
    8212   case 595:
    8213 
    8214 /* Line 1806 of yacc.c  */
    8215 #line 2308 "parser.yy"
    8216     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8217     break;
    8218 
    8219   case 596:
    8220 
    8221 /* Line 1806 of yacc.c  */
    8222 #line 2310 "parser.yy"
    8223     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8224     break;
    8225 
    8226   case 597:
    8227 
    8228 /* Line 1806 of yacc.c  */
    8229 #line 2312 "parser.yy"
    8230     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8231     break;
    8232 
    8233   case 598:
    8234 
    8235 /* Line 1806 of yacc.c  */
    8236 #line 2327 "parser.yy"
     8418  case 628:
     8419
     8420/* Line 1806 of yacc.c  */
     8421#line 2436 "parser.yy"
    82378422    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82388423    break;
    82398424
    8240   case 600:
    8241 
    8242 /* Line 1806 of yacc.c  */
    8243 #line 2330 "parser.yy"
     8425  case 630:
     8426
     8427/* Line 1806 of yacc.c  */
     8428#line 2439 "parser.yy"
    82448429    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82458430    break;
    82468431
    8247   case 601:
    8248 
    8249 /* Line 1806 of yacc.c  */
    8250 #line 2332 "parser.yy"
     8432  case 631:
     8433
     8434/* Line 1806 of yacc.c  */
     8435#line 2441 "parser.yy"
    82518436    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82528437    break;
    82538438
    8254   case 603:
    8255 
    8256 /* Line 1806 of yacc.c  */
    8257 #line 2338 "parser.yy"
    8258     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8259     break;
    8260 
    8261   case 604:
    8262 
    8263 /* Line 1806 of yacc.c  */
    8264 #line 2343 "parser.yy"
    8265     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8266     break;
    8267 
    8268   case 605:
    8269 
    8270 /* Line 1806 of yacc.c  */
    8271 #line 2345 "parser.yy"
    8272     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8273     break;
    8274 
    8275   case 606:
    8276 
    8277 /* Line 1806 of yacc.c  */
    8278 #line 2347 "parser.yy"
    8279     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8280     break;
    8281 
    8282   case 607:
    8283 
    8284 /* Line 1806 of yacc.c  */
    8285 #line 2352 "parser.yy"
    8286     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8287     break;
    8288 
    8289   case 608:
    8290 
    8291 /* Line 1806 of yacc.c  */
    8292 #line 2354 "parser.yy"
    8293     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8294     break;
    8295 
    8296   case 609:
    8297 
    8298 /* Line 1806 of yacc.c  */
    8299 #line 2356 "parser.yy"
    8300     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8301     break;
    8302 
    8303   case 610:
    8304 
    8305 /* Line 1806 of yacc.c  */
    8306 #line 2358 "parser.yy"
    8307     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8308     break;
    8309 
    8310   case 611:
    8311 
    8312 /* Line 1806 of yacc.c  */
    8313 #line 2363 "parser.yy"
    8314     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8315     break;
    8316 
    8317   case 612:
    8318 
    8319 /* Line 1806 of yacc.c  */
    8320 #line 2365 "parser.yy"
    8321     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8322     break;
    8323 
    8324   case 613:
    8325 
    8326 /* Line 1806 of yacc.c  */
    8327 #line 2367 "parser.yy"
    8328     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8329     break;
    8330 
    8331   case 614:
    8332 
    8333 /* Line 1806 of yacc.c  */
    8334 #line 2377 "parser.yy"
    8335     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8336     break;
    8337 
    8338   case 616:
    8339 
    8340 /* Line 1806 of yacc.c  */
    8341 #line 2380 "parser.yy"
    8342     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8343     break;
    8344 
    8345   case 617:
    8346 
    8347 /* Line 1806 of yacc.c  */
    8348 #line 2382 "parser.yy"
    8349     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8350     break;
    8351 
    8352   case 618:
    8353 
    8354 /* Line 1806 of yacc.c  */
    8355 #line 2387 "parser.yy"
    8356     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8357     break;
    8358 
    8359   case 619:
    8360 
    8361 /* Line 1806 of yacc.c  */
    8362 #line 2389 "parser.yy"
    8363     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8364     break;
    8365 
    8366   case 620:
    8367 
    8368 /* Line 1806 of yacc.c  */
    8369 #line 2391 "parser.yy"
    8370     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8371     break;
    8372 
    8373   case 621:
    8374 
    8375 /* Line 1806 of yacc.c  */
    8376 #line 2396 "parser.yy"
    8377     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8378     break;
    8379 
    8380   case 622:
    8381 
    8382 /* Line 1806 of yacc.c  */
    8383 #line 2398 "parser.yy"
    8384     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8385     break;
    8386 
    8387   case 623:
    8388 
    8389 /* Line 1806 of yacc.c  */
    8390 #line 2400 "parser.yy"
    8391     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8392     break;
    8393 
    8394   case 624:
    8395 
    8396 /* Line 1806 of yacc.c  */
    8397 #line 2402 "parser.yy"
    8398     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8399     break;
    8400 
    8401   case 625:
    8402 
    8403 /* Line 1806 of yacc.c  */
    8404 #line 2407 "parser.yy"
    8405     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8406     break;
    8407 
    8408   case 626:
    8409 
    8410 /* Line 1806 of yacc.c  */
    8411 #line 2409 "parser.yy"
    8412     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8413     break;
    8414 
    8415   case 627:
    8416 
    8417 /* Line 1806 of yacc.c  */
    8418 #line 2411 "parser.yy"
    8419     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8420     break;
    8421 
    8422   case 628:
    8423 
    8424 /* Line 1806 of yacc.c  */
    8425 #line 2442 "parser.yy"
    8426     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8427     break;
    8428 
    8429   case 630:
    8430 
    8431 /* Line 1806 of yacc.c  */
    8432 #line 2445 "parser.yy"
    8433     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8434     break;
    8435 
    8436   case 631:
    8437 
    8438 /* Line 1806 of yacc.c  */
    8439 #line 2447 "parser.yy"
    8440     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8441     break;
    8442 
    84438439  case 632:
    84448440
    84458441/* Line 1806 of yacc.c  */
    8446 #line 2452 "parser.yy"
     8442#line 2446 "parser.yy"
    84478443    {
    84488444                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    84548450
    84558451/* Line 1806 of yacc.c  */
    8456 #line 2457 "parser.yy"
     8452#line 2451 "parser.yy"
    84578453    {
    84588454                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
     
    84648460
    84658461/* Line 1806 of yacc.c  */
    8466 #line 2465 "parser.yy"
     8462#line 2459 "parser.yy"
    84678463    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    84688464    break;
     
    84718467
    84728468/* Line 1806 of yacc.c  */
    8473 #line 2467 "parser.yy"
     8469#line 2461 "parser.yy"
    84748470    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84758471    break;
     
    84788474
    84798475/* Line 1806 of yacc.c  */
    8480 #line 2469 "parser.yy"
     8476#line 2463 "parser.yy"
    84818477    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84828478    break;
     
    84858481
    84868482/* Line 1806 of yacc.c  */
    8487 #line 2474 "parser.yy"
     8483#line 2468 "parser.yy"
    84888484    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    84898485    break;
     
    84928488
    84938489/* Line 1806 of yacc.c  */
    8494 #line 2476 "parser.yy"
     8490#line 2470 "parser.yy"
    84958491    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84968492    break;
     
    84998495
    85008496/* Line 1806 of yacc.c  */
    8501 #line 2481 "parser.yy"
     8497#line 2475 "parser.yy"
    85028498    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    85038499    break;
     
    85068502
    85078503/* Line 1806 of yacc.c  */
    8508 #line 2483 "parser.yy"
     8504#line 2477 "parser.yy"
    85098505    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85108506    break;
     
    85138509
    85148510/* Line 1806 of yacc.c  */
    8515 #line 2498 "parser.yy"
     8511#line 2492 "parser.yy"
    85168512    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85178513    break;
     
    85208516
    85218517/* Line 1806 of yacc.c  */
    8522 #line 2500 "parser.yy"
     8518#line 2494 "parser.yy"
    85238519    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85248520    break;
     
    85278523
    85288524/* Line 1806 of yacc.c  */
     8525#line 2499 "parser.yy"
     8526    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     8527    break;
     8528
     8529  case 645:
     8530
     8531/* Line 1806 of yacc.c  */
     8532#line 2501 "parser.yy"
     8533    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     8534    break;
     8535
     8536  case 646:
     8537
     8538/* Line 1806 of yacc.c  */
     8539#line 2503 "parser.yy"
     8540    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8541    break;
     8542
     8543  case 647:
     8544
     8545/* Line 1806 of yacc.c  */
    85298546#line 2505 "parser.yy"
     8547    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8548    break;
     8549
     8550  case 648:
     8551
     8552/* Line 1806 of yacc.c  */
     8553#line 2507 "parser.yy"
     8554    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8555    break;
     8556
     8557  case 650:
     8558
     8559/* Line 1806 of yacc.c  */
     8560#line 2513 "parser.yy"
     8561    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8562    break;
     8563
     8564  case 651:
     8565
     8566/* Line 1806 of yacc.c  */
     8567#line 2515 "parser.yy"
     8568    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8569    break;
     8570
     8571  case 652:
     8572
     8573/* Line 1806 of yacc.c  */
     8574#line 2517 "parser.yy"
     8575    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8576    break;
     8577
     8578  case 653:
     8579
     8580/* Line 1806 of yacc.c  */
     8581#line 2522 "parser.yy"
     8582    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
     8583    break;
     8584
     8585  case 654:
     8586
     8587/* Line 1806 of yacc.c  */
     8588#line 2524 "parser.yy"
     8589    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8590    break;
     8591
     8592  case 655:
     8593
     8594/* Line 1806 of yacc.c  */
     8595#line 2526 "parser.yy"
     8596    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8597    break;
     8598
     8599  case 656:
     8600
     8601/* Line 1806 of yacc.c  */
     8602#line 2532 "parser.yy"
     8603    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     8604    break;
     8605
     8606  case 657:
     8607
     8608/* Line 1806 of yacc.c  */
     8609#line 2534 "parser.yy"
     8610    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
     8611    break;
     8612
     8613  case 659:
     8614
     8615/* Line 1806 of yacc.c  */
     8616#line 2540 "parser.yy"
     8617    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
     8618    break;
     8619
     8620  case 660:
     8621
     8622/* Line 1806 of yacc.c  */
     8623#line 2542 "parser.yy"
     8624    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
     8625    break;
     8626
     8627  case 661:
     8628
     8629/* Line 1806 of yacc.c  */
     8630#line 2544 "parser.yy"
     8631    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
     8632    break;
     8633
     8634  case 662:
     8635
     8636/* Line 1806 of yacc.c  */
     8637#line 2546 "parser.yy"
     8638    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
     8639    break;
     8640
     8641  case 664:
     8642
     8643/* Line 1806 of yacc.c  */
     8644#line 2561 "parser.yy"
     8645    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8646    break;
     8647
     8648  case 665:
     8649
     8650/* Line 1806 of yacc.c  */
     8651#line 2563 "parser.yy"
     8652    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8653    break;
     8654
     8655  case 666:
     8656
     8657/* Line 1806 of yacc.c  */
     8658#line 2568 "parser.yy"
    85308659    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    85318660    break;
    85328661
    8533   case 645:
    8534 
    8535 /* Line 1806 of yacc.c  */
    8536 #line 2507 "parser.yy"
     8662  case 667:
     8663
     8664/* Line 1806 of yacc.c  */
     8665#line 2570 "parser.yy"
    85378666    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    85388667    break;
    85398668
    8540   case 646:
    8541 
    8542 /* Line 1806 of yacc.c  */
    8543 #line 2509 "parser.yy"
     8669  case 668:
     8670
     8671/* Line 1806 of yacc.c  */
     8672#line 2572 "parser.yy"
    85448673    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    85458674    break;
    85468675
    8547   case 647:
    8548 
    8549 /* Line 1806 of yacc.c  */
    8550 #line 2511 "parser.yy"
     8676  case 669:
     8677
     8678/* Line 1806 of yacc.c  */
     8679#line 2574 "parser.yy"
    85518680    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    85528681    break;
    85538682
    8554   case 648:
    8555 
    8556 /* Line 1806 of yacc.c  */
    8557 #line 2513 "parser.yy"
     8683  case 670:
     8684
     8685/* Line 1806 of yacc.c  */
     8686#line 2576 "parser.yy"
    85588687    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85598688    break;
    85608689
    8561   case 650:
    8562 
    8563 /* Line 1806 of yacc.c  */
    8564 #line 2519 "parser.yy"
     8690  case 672:
     8691
     8692/* Line 1806 of yacc.c  */
     8693#line 2582 "parser.yy"
    85658694    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85668695    break;
    85678696
    8568   case 651:
    8569 
    8570 /* Line 1806 of yacc.c  */
    8571 #line 2521 "parser.yy"
     8697  case 673:
     8698
     8699/* Line 1806 of yacc.c  */
     8700#line 2584 "parser.yy"
    85728701    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85738702    break;
    85748703
    8575   case 652:
    8576 
    8577 /* Line 1806 of yacc.c  */
    8578 #line 2523 "parser.yy"
     8704  case 674:
     8705
     8706/* Line 1806 of yacc.c  */
     8707#line 2586 "parser.yy"
    85798708    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85808709    break;
    85818710
    8582   case 653:
    8583 
    8584 /* Line 1806 of yacc.c  */
    8585 #line 2528 "parser.yy"
     8711  case 675:
     8712
     8713/* Line 1806 of yacc.c  */
     8714#line 2591 "parser.yy"
    85868715    { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    85878716    break;
    85888717
    8589   case 654:
    8590 
    8591 /* Line 1806 of yacc.c  */
    8592 #line 2530 "parser.yy"
     8718  case 676:
     8719
     8720/* Line 1806 of yacc.c  */
     8721#line 2593 "parser.yy"
    85938722    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85948723    break;
    85958724
    8596   case 655:
    8597 
    8598 /* Line 1806 of yacc.c  */
    8599 #line 2532 "parser.yy"
     8725  case 677:
     8726
     8727/* Line 1806 of yacc.c  */
     8728#line 2595 "parser.yy"
    86008729    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86018730    break;
    86028731
    8603   case 656:
    8604 
    8605 /* Line 1806 of yacc.c  */
    8606 #line 2538 "parser.yy"
     8732  case 679:
     8733
     8734/* Line 1806 of yacc.c  */
     8735#line 2602 "parser.yy"
     8736    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8737    break;
     8738
     8739  case 681:
     8740
     8741/* Line 1806 of yacc.c  */
     8742#line 2613 "parser.yy"
    86078743    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    86088744    break;
    86098745
    8610   case 657:
    8611 
    8612 /* Line 1806 of yacc.c  */
    8613 #line 2540 "parser.yy"
    8614     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    8615     break;
    8616 
    8617   case 659:
    8618 
    8619 /* Line 1806 of yacc.c  */
    8620 #line 2546 "parser.yy"
    8621     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    8622     break;
    8623 
    8624   case 660:
    8625 
    8626 /* Line 1806 of yacc.c  */
    8627 #line 2548 "parser.yy"
    8628     { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    8629     break;
    8630 
    8631   case 661:
    8632 
    8633 /* Line 1806 of yacc.c  */
    8634 #line 2550 "parser.yy"
    8635     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    8636     break;
    8637 
    8638   case 662:
    8639 
    8640 /* Line 1806 of yacc.c  */
    8641 #line 2552 "parser.yy"
    8642     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    8643     break;
    8644 
    8645   case 664:
    8646 
    8647 /* Line 1806 of yacc.c  */
    8648 #line 2567 "parser.yy"
     8746  case 682:
     8747
     8748/* Line 1806 of yacc.c  */
     8749#line 2616 "parser.yy"
     8750    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     8751    break;
     8752
     8753  case 683:
     8754
     8755/* Line 1806 of yacc.c  */
     8756#line 2618 "parser.yy"
     8757    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
     8758    break;
     8759
     8760  case 684:
     8761
     8762/* Line 1806 of yacc.c  */
     8763#line 2621 "parser.yy"
     8764    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
     8765    break;
     8766
     8767  case 685:
     8768
     8769/* Line 1806 of yacc.c  */
     8770#line 2623 "parser.yy"
     8771    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
     8772    break;
     8773
     8774  case 686:
     8775
     8776/* Line 1806 of yacc.c  */
     8777#line 2625 "parser.yy"
     8778    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
     8779    break;
     8780
     8781  case 688:
     8782
     8783/* Line 1806 of yacc.c  */
     8784#line 2639 "parser.yy"
    86498785    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86508786    break;
    86518787
    8652   case 665:
    8653 
    8654 /* Line 1806 of yacc.c  */
    8655 #line 2569 "parser.yy"
     8788  case 689:
     8789
     8790/* Line 1806 of yacc.c  */
     8791#line 2641 "parser.yy"
    86568792    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    86578793    break;
    86588794
    8659   case 666:
    8660 
    8661 /* Line 1806 of yacc.c  */
    8662 #line 2574 "parser.yy"
     8795  case 690:
     8796
     8797/* Line 1806 of yacc.c  */
     8798#line 2646 "parser.yy"
    86638799    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    86648800    break;
    86658801
    8666   case 667:
    8667 
    8668 /* Line 1806 of yacc.c  */
    8669 #line 2576 "parser.yy"
     8802  case 691:
     8803
     8804/* Line 1806 of yacc.c  */
     8805#line 2648 "parser.yy"
    86708806    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    86718807    break;
    86728808
    8673   case 668:
    8674 
    8675 /* Line 1806 of yacc.c  */
    8676 #line 2578 "parser.yy"
     8809  case 692:
     8810
     8811/* Line 1806 of yacc.c  */
     8812#line 2650 "parser.yy"
    86778813    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    86788814    break;
    86798815
    8680   case 669:
    8681 
    8682 /* Line 1806 of yacc.c  */
    8683 #line 2580 "parser.yy"
     8816  case 693:
     8817
     8818/* Line 1806 of yacc.c  */
     8819#line 2652 "parser.yy"
    86848820    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    86858821    break;
    86868822
    8687   case 670:
    8688 
    8689 /* Line 1806 of yacc.c  */
    8690 #line 2582 "parser.yy"
     8823  case 694:
     8824
     8825/* Line 1806 of yacc.c  */
     8826#line 2654 "parser.yy"
    86918827    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86928828    break;
    86938829
    8694   case 672:
    8695 
    8696 /* Line 1806 of yacc.c  */
    8697 #line 2588 "parser.yy"
     8830  case 696:
     8831
     8832/* Line 1806 of yacc.c  */
     8833#line 2660 "parser.yy"
    86988834    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86998835    break;
    87008836
    8701   case 673:
    8702 
    8703 /* Line 1806 of yacc.c  */
    8704 #line 2590 "parser.yy"
     8837  case 697:
     8838
     8839/* Line 1806 of yacc.c  */
     8840#line 2662 "parser.yy"
    87058841    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87068842    break;
    87078843
    8708   case 674:
    8709 
    8710 /* Line 1806 of yacc.c  */
    8711 #line 2592 "parser.yy"
     8844  case 698:
     8845
     8846/* Line 1806 of yacc.c  */
     8847#line 2664 "parser.yy"
    87128848    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87138849    break;
    87148850
    8715   case 675:
    8716 
    8717 /* Line 1806 of yacc.c  */
    8718 #line 2597 "parser.yy"
    8719     { (yyval.decl) = DeclarationNode::newFunction( 0, 0, (yyvsp[(3) - (5)].decl), 0 ); }
    8720     break;
    8721 
    8722   case 676:
    8723 
    8724 /* Line 1806 of yacc.c  */
    8725 #line 2599 "parser.yy"
     8851  case 699:
     8852
     8853/* Line 1806 of yacc.c  */
     8854#line 2669 "parser.yy"
    87268855    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87278856    break;
    87288857
    8729   case 677:
    8730 
    8731 /* Line 1806 of yacc.c  */
    8732 #line 2601 "parser.yy"
     8858  case 700:
     8859
     8860/* Line 1806 of yacc.c  */
     8861#line 2671 "parser.yy"
    87338862    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87348863    break;
    87358864
    8736   case 679:
    8737 
    8738 /* Line 1806 of yacc.c  */
    8739 #line 2608 "parser.yy"
    8740     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8741     break;
    8742 
    8743   case 681:
    8744 
    8745 /* Line 1806 of yacc.c  */
    8746 #line 2619 "parser.yy"
    8747     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    8748     break;
    8749 
    8750   case 682:
    8751 
    8752 /* Line 1806 of yacc.c  */
    8753 #line 2622 "parser.yy"
    8754     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    8755     break;
    8756 
    8757   case 683:
    8758 
    8759 /* Line 1806 of yacc.c  */
    8760 #line 2624 "parser.yy"
    8761     { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    8762     break;
    8763 
    8764   case 684:
    8765 
    8766 /* Line 1806 of yacc.c  */
    8767 #line 2627 "parser.yy"
    8768     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    8769     break;
    8770 
    8771   case 685:
    8772 
    8773 /* Line 1806 of yacc.c  */
    8774 #line 2629 "parser.yy"
    8775     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    8776     break;
    8777 
    8778   case 686:
    8779 
    8780 /* Line 1806 of yacc.c  */
    8781 #line 2631 "parser.yy"
    8782     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    8783     break;
    8784 
    8785   case 688:
    8786 
    8787 /* Line 1806 of yacc.c  */
    8788 #line 2645 "parser.yy"
    8789     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8790     break;
    8791 
    8792   case 689:
    8793 
    8794 /* Line 1806 of yacc.c  */
    8795 #line 2647 "parser.yy"
    8796     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8797     break;
    8798 
    8799   case 690:
    8800 
    8801 /* Line 1806 of yacc.c  */
    8802 #line 2652 "parser.yy"
    8803     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    8804     break;
    8805 
    8806   case 691:
    8807 
    8808 /* Line 1806 of yacc.c  */
    8809 #line 2654 "parser.yy"
    8810     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    8811     break;
    8812 
    8813   case 692:
    8814 
    8815 /* Line 1806 of yacc.c  */
    8816 #line 2656 "parser.yy"
    8817     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8818     break;
    8819 
    8820   case 693:
    8821 
    8822 /* Line 1806 of yacc.c  */
    8823 #line 2658 "parser.yy"
    8824     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8825     break;
    8826 
    8827   case 694:
    8828 
    8829 /* Line 1806 of yacc.c  */
    8830 #line 2660 "parser.yy"
    8831     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8832     break;
    8833 
    8834   case 696:
    8835 
    8836 /* Line 1806 of yacc.c  */
    8837 #line 2666 "parser.yy"
    8838     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8839     break;
    8840 
    8841   case 697:
    8842 
    8843 /* Line 1806 of yacc.c  */
    8844 #line 2668 "parser.yy"
    8845     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8846     break;
    8847 
    8848   case 698:
    8849 
    8850 /* Line 1806 of yacc.c  */
    8851 #line 2670 "parser.yy"
    8852     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8853     break;
    8854 
    8855   case 699:
    8856 
    8857 /* Line 1806 of yacc.c  */
    8858 #line 2675 "parser.yy"
    8859     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8860     break;
    8861 
    8862   case 700:
    8863 
    8864 /* Line 1806 of yacc.c  */
    8865 #line 2677 "parser.yy"
    8866     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8867     break;
    8868 
    88698865  case 703:
    88708866
    88718867/* Line 1806 of yacc.c  */
    8872 #line 2687 "parser.yy"
     8868#line 2681 "parser.yy"
    88738869    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    88748870    break;
     
    88778873
    88788874/* Line 1806 of yacc.c  */
     8875#line 2691 "parser.yy"
     8876    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     8877    break;
     8878
     8879  case 707:
     8880
     8881/* Line 1806 of yacc.c  */
     8882#line 2693 "parser.yy"
     8883    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     8884    break;
     8885
     8886  case 708:
     8887
     8888/* Line 1806 of yacc.c  */
     8889#line 2695 "parser.yy"
     8890    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     8891    break;
     8892
     8893  case 709:
     8894
     8895/* Line 1806 of yacc.c  */
    88798896#line 2697 "parser.yy"
     8897    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     8898    break;
     8899
     8900  case 710:
     8901
     8902/* Line 1806 of yacc.c  */
     8903#line 2699 "parser.yy"
    88808904    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    88818905    break;
    88828906
    8883   case 707:
    8884 
    8885 /* Line 1806 of yacc.c  */
    8886 #line 2699 "parser.yy"
     8907  case 711:
     8908
     8909/* Line 1806 of yacc.c  */
     8910#line 2701 "parser.yy"
    88878911    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    88888912    break;
    88898913
    8890   case 708:
    8891 
    8892 /* Line 1806 of yacc.c  */
    8893 #line 2701 "parser.yy"
    8894     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    8895     break;
    8896 
    8897   case 709:
    8898 
    8899 /* Line 1806 of yacc.c  */
    8900 #line 2703 "parser.yy"
    8901     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    8902     break;
    8903 
    8904   case 710:
    8905 
    8906 /* Line 1806 of yacc.c  */
    8907 #line 2705 "parser.yy"
    8908     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    8909     break;
    8910 
    8911   case 711:
    8912 
    8913 /* Line 1806 of yacc.c  */
    8914 #line 2707 "parser.yy"
    8915     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    8916     break;
    8917 
    89188914  case 712:
    89198915
    89208916/* Line 1806 of yacc.c  */
     8917#line 2708 "parser.yy"
     8918    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     8919    break;
     8920
     8921  case 713:
     8922
     8923/* Line 1806 of yacc.c  */
     8924#line 2710 "parser.yy"
     8925    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     8926    break;
     8927
     8928  case 714:
     8929
     8930/* Line 1806 of yacc.c  */
     8931#line 2712 "parser.yy"
     8932    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     8933    break;
     8934
     8935  case 715:
     8936
     8937/* Line 1806 of yacc.c  */
    89218938#line 2714 "parser.yy"
    8922     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    8923     break;
    8924 
    8925   case 713:
     8939    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     8940    break;
     8941
     8942  case 716:
    89268943
    89278944/* Line 1806 of yacc.c  */
     
    89308947    break;
    89318948
    8932   case 714:
     8949  case 717:
    89338950
    89348951/* Line 1806 of yacc.c  */
    89358952#line 2718 "parser.yy"
     8953    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     8954    break;
     8955
     8956  case 718:
     8957
     8958/* Line 1806 of yacc.c  */
     8959#line 2720 "parser.yy"
     8960    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     8961    break;
     8962
     8963  case 719:
     8964
     8965/* Line 1806 of yacc.c  */
     8966#line 2722 "parser.yy"
    89368967    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89378968    break;
    89388969
    8939   case 715:
    8940 
    8941 /* Line 1806 of yacc.c  */
    8942 #line 2720 "parser.yy"
     8970  case 720:
     8971
     8972/* Line 1806 of yacc.c  */
     8973#line 2724 "parser.yy"
    89438974    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    89448975    break;
    89458976
    8946   case 716:
    8947 
    8948 /* Line 1806 of yacc.c  */
    8949 #line 2722 "parser.yy"
    8950     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    8951     break;
    8952 
    8953   case 717:
    8954 
    8955 /* Line 1806 of yacc.c  */
    8956 #line 2724 "parser.yy"
    8957     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    8958     break;
    8959 
    8960   case 718:
     8977  case 721:
    89618978
    89628979/* Line 1806 of yacc.c  */
     
    89658982    break;
    89668983
    8967   case 719:
    8968 
    8969 /* Line 1806 of yacc.c  */
    8970 #line 2728 "parser.yy"
     8984  case 722:
     8985
     8986/* Line 1806 of yacc.c  */
     8987#line 2731 "parser.yy"
     8988    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     8989    break;
     8990
     8991  case 723:
     8992
     8993/* Line 1806 of yacc.c  */
     8994#line 2733 "parser.yy"
     8995    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
     8996    break;
     8997
     8998  case 724:
     8999
     9000/* Line 1806 of yacc.c  */
     9001#line 2738 "parser.yy"
     9002    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
     9003    break;
     9004
     9005  case 725:
     9006
     9007/* Line 1806 of yacc.c  */
     9008#line 2740 "parser.yy"
     9009    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
     9010    break;
     9011
     9012  case 727:
     9013
     9014/* Line 1806 of yacc.c  */
     9015#line 2767 "parser.yy"
     9016    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     9017    break;
     9018
     9019  case 731:
     9020
     9021/* Line 1806 of yacc.c  */
     9022#line 2778 "parser.yy"
     9023    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9024    break;
     9025
     9026  case 732:
     9027
     9028/* Line 1806 of yacc.c  */
     9029#line 2780 "parser.yy"
     9030    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9031    break;
     9032
     9033  case 733:
     9034
     9035/* Line 1806 of yacc.c  */
     9036#line 2782 "parser.yy"
     9037    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9038    break;
     9039
     9040  case 734:
     9041
     9042/* Line 1806 of yacc.c  */
     9043#line 2784 "parser.yy"
     9044    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9045    break;
     9046
     9047  case 735:
     9048
     9049/* Line 1806 of yacc.c  */
     9050#line 2786 "parser.yy"
     9051    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9052    break;
     9053
     9054  case 736:
     9055
     9056/* Line 1806 of yacc.c  */
     9057#line 2788 "parser.yy"
     9058    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9059    break;
     9060
     9061  case 737:
     9062
     9063/* Line 1806 of yacc.c  */
     9064#line 2795 "parser.yy"
     9065    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9066    break;
     9067
     9068  case 738:
     9069
     9070/* Line 1806 of yacc.c  */
     9071#line 2797 "parser.yy"
    89719072    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89729073    break;
    89739074
    8974   case 720:
    8975 
    8976 /* Line 1806 of yacc.c  */
    8977 #line 2730 "parser.yy"
    8978     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    8979     break;
    8980 
    8981   case 721:
    8982 
    8983 /* Line 1806 of yacc.c  */
    8984 #line 2732 "parser.yy"
     9075  case 739:
     9076
     9077/* Line 1806 of yacc.c  */
     9078#line 2799 "parser.yy"
    89859079    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    89869080    break;
    89879081
    8988   case 722:
    8989 
    8990 /* Line 1806 of yacc.c  */
    8991 #line 2737 "parser.yy"
    8992     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    8993     break;
    8994 
    8995   case 723:
    8996 
    8997 /* Line 1806 of yacc.c  */
    8998 #line 2739 "parser.yy"
    8999     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    9000     break;
    9001 
    9002   case 724:
    9003 
    9004 /* Line 1806 of yacc.c  */
    9005 #line 2744 "parser.yy"
    9006     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
    9007     break;
    9008 
    9009   case 725:
    9010 
    9011 /* Line 1806 of yacc.c  */
    9012 #line 2746 "parser.yy"
    9013     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
    9014     break;
    9015 
    9016   case 727:
    9017 
    9018 /* Line 1806 of yacc.c  */
    9019 #line 2773 "parser.yy"
    9020     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    9021     break;
    9022 
    9023   case 731:
    9024 
    9025 /* Line 1806 of yacc.c  */
    9026 #line 2784 "parser.yy"
    9027     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9028     break;
    9029 
    9030   case 732:
    9031 
    9032 /* Line 1806 of yacc.c  */
    9033 #line 2786 "parser.yy"
    9034     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9035     break;
    9036 
    9037   case 733:
    9038 
    9039 /* Line 1806 of yacc.c  */
    9040 #line 2788 "parser.yy"
    9041     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9042     break;
    9043 
    9044   case 734:
    9045 
    9046 /* Line 1806 of yacc.c  */
    9047 #line 2790 "parser.yy"
    9048     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9049     break;
    9050 
    9051   case 735:
    9052 
    9053 /* Line 1806 of yacc.c  */
    9054 #line 2792 "parser.yy"
    9055     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9056     break;
    9057 
    9058   case 736:
    9059 
    9060 /* Line 1806 of yacc.c  */
    9061 #line 2794 "parser.yy"
    9062     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9063     break;
    9064 
    9065   case 737:
     9082  case 740:
    90669083
    90679084/* Line 1806 of yacc.c  */
     
    90709087    break;
    90719088
    9072   case 738:
     9089  case 741:
    90739090
    90749091/* Line 1806 of yacc.c  */
     
    90779094    break;
    90789095
    9079   case 739:
     9096  case 742:
    90809097
    90819098/* Line 1806 of yacc.c  */
     
    90849101    break;
    90859102
    9086   case 740:
    9087 
    9088 /* Line 1806 of yacc.c  */
    9089 #line 2807 "parser.yy"
    9090     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9091     break;
    9092 
    9093   case 741:
    9094 
    9095 /* Line 1806 of yacc.c  */
    9096 #line 2809 "parser.yy"
    9097     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9098     break;
    9099 
    9100   case 742:
    9101 
    9102 /* Line 1806 of yacc.c  */
    9103 #line 2811 "parser.yy"
    9104     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    9105     break;
    9106 
    91079103  case 743:
    91089104
    91099105/* Line 1806 of yacc.c  */
    9110 #line 2816 "parser.yy"
     9106#line 2810 "parser.yy"
    91119107    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    91129108    break;
     
    91159111
    91169112/* Line 1806 of yacc.c  */
    9117 #line 2821 "parser.yy"
     9113#line 2815 "parser.yy"
    91189114    { (yyval.decl) = DeclarationNode::newFunction( 0, DeclarationNode::newTuple( 0 ), (yyvsp[(4) - (5)].decl), 0 ); }
    91199115    break;
     
    91229118
    91239119/* Line 1806 of yacc.c  */
    9124 #line 2823 "parser.yy"
     9120#line 2817 "parser.yy"
    91259121    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    91269122    break;
     
    91299125
    91309126/* Line 1806 of yacc.c  */
    9131 #line 2825 "parser.yy"
     9127#line 2819 "parser.yy"
    91329128    { (yyval.decl) = DeclarationNode::newFunction( 0, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), 0 ); }
    91339129    break;
     
    91369132
    91379133/* Line 1806 of yacc.c  */
    9138 #line 2849 "parser.yy"
     9134#line 2843 "parser.yy"
    91399135    { (yyval.en) = 0; }
    91409136    break;
     
    91439139
    91449140/* Line 1806 of yacc.c  */
    9145 #line 2851 "parser.yy"
     9141#line 2845 "parser.yy"
    91469142    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    91479143    break;
     
    91509146
    91519147/* Line 1806 of yacc.c  */
    9152 #line 9153 "Parser/parser.cc"
     9148#line 9149 "Parser/parser.cc"
    91539149      default: break;
    91549150    }
     
    93819377
    93829378/* Line 2067 of yacc.c  */
    9383 #line 2854 "parser.yy"
     9379#line 2848 "parser.yy"
    93849380
    93859381// ----end of grammar----
  • src/Parser/parser.yy

    r46b4259 r1d4580a  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 11 18:02:57 2016
    13 // Update Count     : 1861
     12// Last Modified On : Sat Aug 13 18:59:02 2016
     13// Update Count     : 1877
    1414//
    1515
     
    162162%type<sn> case_value_list                               case_label                                      case_label_list
    163163%type<sn> switch_clause_list_opt                switch_clause_list                      choose_clause_list_opt          choose_clause_list
    164 %type<pn> handler_list                                  handler_clause                          finally_clause
     164%type<sn> handler_list                                  handler_clause                          finally_clause
    165165
    166166// declarations
     
    389389                        Token fn;
    390390                        fn.str = new std::string( "?{}" ); // location undefined
    391                         $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_link( $3 ) ) );
     391                        $$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) );
    392392                }
    393393        ;
     
    396396        argument_expression
    397397        | argument_expression_list ',' argument_expression
    398                 { $$ = (ExpressionNode *)( $1->set_link( $3 )); }
     398                { $$ = (ExpressionNode *)( $1->set_last( $3 )); }
    399399        ;
    400400
     
    407407field_list:                                                                                             // CFA, tuple field selector
    408408        field
    409         | field_list ',' field                                          { $$ = (ExpressionNode *)$1->set_link( $3 ); }
     409        | field_list ',' field                                          { $$ = (ExpressionNode *)$1->set_last( $3 ); }
    410410        ;
    411411
     
    627627                { $$ = new ExpressionNode( build_tuple( $3 ) ); }
    628628        | '[' push ',' tuple_expression_list pop ']'
    629                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_link( $4 ) ) ); }
     629                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( $4 ) ) ); }
    630630        | '[' push assignment_expression ',' tuple_expression_list pop ']'
    631                 { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_link( $5 ) ) ); }
     631                { $$ = new ExpressionNode( build_tuple( (ExpressionNode *)$3->set_last( $5 ) ) ); }
    632632        ;
    633633
     
    635635        assignment_expression_opt
    636636        | tuple_expression_list ',' assignment_expression_opt
    637                 { $$ = (ExpressionNode *)$1->set_link( $3 ); }
     637                { $$ = (ExpressionNode *)$1->set_last( $3 ); }
    638638        ;
    639639
     
    665665                        Token fn;
    666666                        fn.str = new std::string( "^?{}" ); // location undefined
    667                         $$ = new StatementNode2( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_link( $4 ) ) ) ) );
     667                        $$ = new StatementNode2( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) ) ) );
    668668                }
    669669        ;
     
    692692        block_item
    693693        | block_item_list push block_item
    694                 { if ( $1 != 0 ) { $1->set_link( $3 ); $$ = $1; } }
     694                { if ( $1 != 0 ) { $1->set_last( $3 ); $$ = $1; } }
    695695        ;
    696696
    697697block_item:
    698698        declaration                                                                                     // CFA, new & old style declarations
    699                 { $$ = new StatementNode( $1 ); }
     699                { $$ = new StatementNode2( $1 ); }
    700700        | EXTENSION declaration                                                         // GCC
    701701                {       // mark all fields in list
    702                         for ( DeclarationNode *iter = $2; iter != NULL; iter = (DeclarationNode *)iter->get_link() )
     702                        for ( DeclarationNode *iter = $2; iter != NULL; iter = (DeclarationNode *)iter->get_next() )
    703703                                iter->set_extension( true );
    704                         $$ = new StatementNode( $2 );
     704                        $$ = new StatementNode2( $2 );
    705705                }
    706706        | function_definition
    707                 { $$ = new StatementNode( $1 ); }
     707                { $$ = new StatementNode2( $1 ); }
    708708        | statement pop
    709709        ;
     
    712712        statement
    713713        | statement_list statement
    714                 { if ( $1 != 0 ) { $1->set_link( $2 ); $$ = $1; } }
     714                { if ( $1 != 0 ) { $1->set_last( $2 ); $$ = $1; } }
    715715        ;
    716716
     
    736736                        // therefore, are removed from the grammar even though C allows it. The change also applies to choose
    737737                        // statement.
    738                         $$ = $7 != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( $7 ))->set_link( sw )) ) : sw;
     738                        $$ = $7 != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode2( $7 ))->set_last( sw )) ) : sw;
    739739                }
    740740        | CHOOSE '(' comma_expression ')' case_clause           // CFA
     
    743743                {
    744744                        StatementNode *sw = new StatementNode2( build_switch( $3, $8 ) );
    745                         $$ = $7 != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode( $7 ))->set_link( sw )) ) : sw;
     745                        $$ = $7 != 0 ? new CompoundStmtNode( (StatementNode *)((new StatementNode2( $7 ))->set_last( sw )) ) : sw;
    746746                }
    747747        ;
     
    758758
    759759case_value_list:                                                                                // CFA
    760         //case_value                                                                    { $$ = new StatementNode( StatementNode::Case, $1, 0 ); }
    761760        case_value                                                                      { $$ = new StatementNode2( build_case( $1 ) ); }
    762761                // convert case list, e.g., "case 1, 3, 5:" into "case 1: case 3: case 5"
    763         | case_value_list ',' case_value                        { $$ = (StatementNode *)($1->set_link( new StatementNode2( build_case( $3 ) ) ) ); }
     762        | case_value_list ',' case_value                        { $$ = (StatementNode *)($1->set_last( new StatementNode2( build_case( $3 ) ) ) ); }
    764763        ;
    765764
     
    772771case_label_list:                                                                                // CFA
    773772        case_label
    774         | case_label_list case_label                            { $$ = (StatementNode *)( $1->set_link( $2 )); }
     773        | case_label_list case_label                            { $$ = (StatementNode *)( $1->set_last( $2 )); }
    775774        ;
    776775
     
    789788                { $$ = $1->append_last_case( new CompoundStmtNode( $2 ) ); }
    790789        | switch_clause_list case_label_list statement_list
    791                 { $$ = (StatementNode *)( $1->set_link( $2->append_last_case( new CompoundStmtNode( $3 ) ) ) ); }
     790                { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new CompoundStmtNode( $3 ) ) ) ); }
    792791        ;
    793792
     
    804803                { $$ = $1->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*$2, *$3 ) ) ) ); }
    805804        | choose_clause_list case_label_list fall_through
    806                 { $$ = (StatementNode *)( $1->set_link( $2->append_last_case( $3 ))); }
     805                { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( $3 ))); }
    807806        | choose_clause_list case_label_list statement_list fall_through_opt
    808                 { $$ = (StatementNode *)( $1->set_link( $2->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*$3, *$4 ) ) ) ) ) ); }
     807                { $$ = (StatementNode *)( $1->set_last( $2->append_last_case( new CompoundStmtNode( (StatementNode *)mkList( (*$3, *$4 ) ) ) ) ) ); }
    809808        ;
    810809
     
    871870exception_statement:
    872871        TRY compound_statement handler_list
    873                 { $$ = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3 )))); }
     872                { $$ = new StatementNode2( build_try( $2, $3, 0 ) ); }
    874873        | TRY compound_statement finally_clause
    875                 { $$ = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3 )))); }
     874                { $$ = new StatementNode2( build_try( $2, 0, $3 ) ); }
    876875        | TRY compound_statement handler_list finally_clause
    877                 {
    878                         $3->set_link( $4 );
    879                         $$ = new StatementNode( StatementNode::Try, 0,(StatementNode *)(mkList((*$2,*$3 ))));
    880                 }