Changes in / [a1e67dd:fe7b281]


Ignore:
Location:
src
Files:
5 added
2 deleted
60 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    ra1e67dd rfe7b281  
    309309                                                        UntypedExpr * newExpr = new UntypedExpr( new NameExpr( "*?" ) );
    310310                                                        newExpr->get_args().push_back( *arg );
    311                                                         Type * type = InitTweak::getPointerBase( (*arg)->get_result() );
     311                                                        assert( (*arg)->get_results().size() == 1 );
     312                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_results().front() );
    312313                                                        assert( type );
    313                                                         newExpr->set_result( type->clone() );
     314                                                        newExpr->get_results().push_back( type->clone() );
    314315                                                        *arg = newExpr;
    315316                                                } // if
    … …  
    526527                extension( castExpr );
    527528                output << "(";
    528                 if ( castExpr->get_result()->isVoid() ) {
     529                if ( castExpr->get_results().empty() ) {
    529530                        output << "(void)" ;
    530                 } else if ( ! castExpr->get_result()->get_isLvalue() ) {
     531                } else if ( ! castExpr->get_results().front()->get_isLvalue() ) {
    531532                        // at least one result type of cast, but not an lvalue
    532533                        output << "(";
    533                         output << genType( castExpr->get_result(), "" );
     534                        output << genType( castExpr->get_results().front(), "" );
    534535                        output << ")";
    535536                } else {
    … …  
    639640        }
    640641
    641         void CodeGenerator::visit( TupleExpr * tupleExpr ) { assert( false ); }
     642        void CodeGenerator::visit( TupleExpr * tupleExpr ) {}
    642643
    643644        void CodeGenerator::visit( TypeExpr * typeExpr ) {}
    … …  
    653654                asmExpr->get_operand()->accept( *this );
    654655                output << " )";
    655         }
    656 
    657         void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
    658                 assert( compLitExpr->get_type() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
    659                 output << "(" << genType( compLitExpr->get_type(), "" ) << ")";
    660                 compLitExpr->get_initializer()->accept( *this );
    661         }
    662 
    663         void CodeGenerator::visit( StmtExpr * stmtExpr ) {
    664                 std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
    665                 output << "({" << std::endl;
    666                 cur_indent += CodeGenerator::tabsize;
    667                 unsigned int numStmts = stmts.size();
    668                 unsigned int i = 0;
    669                 for ( Statement * stmt : stmts ) {
    670                         output << indent << printLabels( stmt->get_labels() );
    671                         if ( i+1 == numStmts ) {
    672                                 // last statement in a statement expression needs to be handled specially -
    673                                 // cannot cast to void, otherwise the expression statement has no value
    674                                 if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
    675                                         exprStmt->get_expr()->accept( *this );
    676                                         output << ";" << endl;
    677                                         ++i;
    678                                         break;
    679                                 }
    680                         }
    681                         stmt->accept( *this );
    682                         output << endl;
    683                         if ( wantSpacing( stmt ) ) {
    684                                 output << endl;
    685                         } // if
    686                         ++i;
    687                 }
    688                 cur_indent -= CodeGenerator::tabsize;
    689                 output << indent << "})";
    690656        }
    691657

  • src/CodeGen/CodeGenerator.h

    ra1e67dd rfe7b281  
    7070                virtual void visit( ConditionalExpr *conditionalExpr );
    7171                virtual void visit( CommaExpr *commaExpr );
    72                 virtual void visit( CompoundLiteralExpr *compLitExpr );
    7372                virtual void visit( TupleExpr *tupleExpr );
    7473                virtual void visit( TypeExpr *typeExpr );
    7574                virtual void visit( AsmExpr * );
    76                 virtual void visit( StmtExpr * );
    7775
    7876                //*** Statements

  • src/CodeGen/GenType.cc

    ra1e67dd rfe7b281  
    227227                        typeString = "_Atomic " + typeString;
    228228                } // if
     229                if ( type->get_isAttribute() ) {
     230                        typeString = "__attribute(( )) " + typeString;
     231                } // if
    229232        }
    230233} // namespace CodeGen

  • src/Common/utility.h

    ra1e67dd rfe7b281  
    148148}
    149149
    150 // replace element of list with all elements of another list
    151150template< typename T >
    152151void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
    … …  
    159158
    160159        return;
    161 }
    162 
    163 // replace range of a list with a single element
    164 template< typename T >
    165 void replace( std::list< T > &org, typename std::list< T >::iterator begin, typename std::list< T >::iterator end, const T & with ) {
    166         org.insert( begin, with );
    167         org.erase( begin, end );
    168160}
    169161

  • src/ControlStruct/Mutate.cc

    ra1e67dd rfe7b281  
    2323#include "MLEMutator.h"
    2424#include "ForExprMutator.h"
     25#include "LabelTypeChecker.h"
    2526//#include "ExceptMutator.h"
    2627
    … …  
    4041
    4142                //ExceptMutator exc;
     43                // LabelTypeChecker lbl;
    4244
    4345                mutateAll( translationUnit, formut );
    4446                acceptAll( translationUnit, lfix );
    4547                //mutateAll( translationUnit, exc );
     48                //acceptAll( translationUnit, lbl );
    4649        }
    4750} // namespace CodeGen

  • src/ControlStruct/module.mk

    ra1e67dd rfe7b281  
    66## file "LICENCE" distributed with Cforall.
    77##
    8 ## module.mk --
     8## module.mk -- 
    99##
    1010## Author           : Richard C. Bilson
    … …  
    1919        ControlStruct/MLEMutator.cc \
    2020        ControlStruct/Mutate.cc \
    21         ControlStruct/ForExprMutator.cc
     21        ControlStruct/ForExprMutator.cc \
     22        ControlStruct/LabelTypeChecker.cc
    2223

  • src/GenPoly/Box.cc

    ra1e67dd rfe7b281  
    110110                        void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars );
    111111                        /// Stores assignment operators from assertion list in local map of assignment operations
    112                         void findTypeOps( const Type::ForallList &forall );
     112                        void findTypeOps( const std::list< TypeDecl *> &forall );
    113113                        void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
    114114                        FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
    … …  
    612612                }
    613613
    614                 void Pass1::findTypeOps( const Type::ForallList &forall ) {
     614                void Pass1::findTypeOps( const std::list< TypeDecl *> &forall ) {
    615615                        // what if a nested function uses an assignment operator?
    616616                        // assignOps.clear();
    617                         for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
     617                        for ( std::list< TypeDecl *>::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
    618618                                for ( std::list< DeclarationWithType *>::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
    619619                                        std::string typeName;
    … …  
    680680                                std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
    681681                                std::list< FunctionType *> functions;
    682                                 for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
     682                                for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
    683683                                        for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
    684684                                                findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter );
    … …  
    782782
    783783                        // add size/align for generic types to parameter list
    784                         if ( ! appExpr->get_function()->has_result() ) return;
    785                         FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
     784                        if ( appExpr->get_function()->get_results().empty() ) return;
     785                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_results().front() );
    786786                        assert( funcType );
    787787
    … …  
    799799                        for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
    800800                                VariableExpr *fnArgBase = getBaseVar( *fnArg );
    801                                 if ( ! fnArgBase ) continue; // xxx - previously had check for non-empty fnArgBase results
    802                                 passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_result(), arg, exprTyVars, seenTypes );
     801                                if ( ! fnArgBase || fnArgBase->get_results().empty() ) continue;
     802                                passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_results().front(), arg, exprTyVars, seenTypes );
    803803                        }
    804804                }
    … …  
    890890                        Type * adapteeType = new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
    891891                        appExpr->get_args().push_front( new CastExpr( appExpr->get_function(), adapteeType ) );
    892                         appExpr->set_function( new NameExpr( adapterName ) ); // xxx - result is never set on NameExpr
     892                        appExpr->set_function( new NameExpr( adapterName ) );
    893893
    894894                        return ret;
    … …  
    896896
    897897                void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
    898                         assert( arg->has_result() );
     898                        assert( ! arg->get_results().empty() );
    899899                        if ( isPolyType( param, exprTyVars ) ) {
    900                                 if ( isPolyType( arg->get_result() ) ) {
     900                                if ( isPolyType( arg->get_results().front() ) ) {
    901901                                        // if the argument's type is polymorphic, we don't need to box again!
    902902                                        return;
    903                                 } else if ( arg->get_result()->get_isLvalue() ) {
     903                                } else if ( arg->get_results().front()->get_isLvalue() ) {
    904904                                        // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
    905905                                        // xxx - need to test that this code is still reachable
    … …  
    946946                void Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
    947947                        std::list< Expression *>::iterator cur = arg;
    948                         for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
     948                        for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
    949949                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
    950950                                        InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
    … …  
    987987                                        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
    988988                                        deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
    989                                         deref->set_result( arg->get_type()->clone() );
     989                                        deref->get_results().push_back( arg->get_type()->clone() );
    990990                                        return deref;
    991991                                } // if
    … …  
    10131013                        Statement *bodyStmt;
    10141014
    1015                         Type::ForallList::iterator tyArg = realType->get_forall().begin();
    1016                         Type::ForallList::iterator tyParam = adapterType->get_forall().begin();
    1017                         Type::ForallList::iterator realTyParam = adaptee->get_forall().begin();
     1015                        std::list< TypeDecl *>::iterator tyArg = realType->get_forall().begin();
     1016                        std::list< TypeDecl *>::iterator tyParam = adapterType->get_forall().begin();
     1017                        std::list< TypeDecl *>::iterator realTyParam = adaptee->get_forall().begin();
    10181018                        for ( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) {
    10191019                                assert( tyArg != realType->get_forall().end() );
    … …  
    10641064                        std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
    10651065                        std::list< FunctionType *> functions;
    1066                         for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
     1066                        for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
    10671067                                for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
    10681068                                        findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter );
    … …  
    11241124                        } // if
    11251125                        addAssign->get_args().push_back( new NameExpr( sizeofName( mangleType( polyType ) ) ) );
    1126                         addAssign->set_result( appExpr->get_result()->clone() );
     1126                        addAssign->get_results().front() = appExpr->get_results().front()->clone();
    11271127                        if ( appExpr->get_env() ) {
    11281128                                addAssign->set_env( appExpr->get_env() );
    … …  
    11381138                                if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
    11391139                                        if ( varExpr->get_var()->get_name() == "?[?]" ) {
    1140                                                 assert( appExpr->has_result() );
     1140                                                assert( ! appExpr->get_results().empty() );
    11411141                                                assert( appExpr->get_args().size() == 2 );
    1142                                                 Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
    1143                                                 Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
     1142                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
     1143                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
    11441144                                                assert( ! baseType1 || ! baseType2 ); // the arguments cannot both be polymorphic pointers
    11451145                                                UntypedExpr *ret = 0;
    … …  
    11611161                                                } // if
    11621162                                                if ( baseType1 || baseType2 ) {
    1163                                                         ret->set_result( appExpr->get_result()->clone() );
     1163                                                        ret->get_results().push_front( appExpr->get_results().front()->clone() );
    11641164                                                        if ( appExpr->get_env() ) {
    11651165                                                                ret->set_env( appExpr->get_env() );
    … …  
    11711171                                                } // if
    11721172                                        } else if ( varExpr->get_var()->get_name() == "*?" ) {
    1173                                                 assert( appExpr->has_result() );
     1173                                                assert( ! appExpr->get_results().empty() );
    11741174                                                assert( ! appExpr->get_args().empty() );
    1175                                                 if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
     1175                                                if ( isPolyType( appExpr->get_results().front(), scopeTyVars, env ) ) {
    11761176                                                        Expression *ret = appExpr->get_args().front();
    1177                                                         delete ret->get_result();
    1178                                                         ret->set_result( appExpr->get_result()->clone() );
     1177                                                        delete ret->get_results().front();
     1178                                                        ret->get_results().front() = appExpr->get_results().front()->clone();
    11791179                                                        if ( appExpr->get_env() ) {
    11801180                                                                ret->set_env( appExpr->get_env() );
    … …  
    11861186                                                } // if
    11871187                                        } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
    1188                                                 assert( appExpr->has_result() );
     1188                                                assert( ! appExpr->get_results().empty() );
    11891189                                                assert( appExpr->get_args().size() == 1 );
    1190                                                 if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
    1191                                                         Type *tempType = appExpr->get_result()->clone();
     1190                                                if ( Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env ) ) {
     1191                                                        Type *tempType = appExpr->get_results().front()->clone();
    11921192                                                        if ( env ) {
    11931193                                                                env->apply( tempType );
    … …  
    12061206                                                } // if
    12071207                                        } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
    1208                                                 assert( appExpr->has_result() );
     1208                                                assert( ! appExpr->get_results().empty() );
    12091209                                                assert( appExpr->get_args().size() == 1 );
    1210                                                 if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
     1210                                                if ( Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env ) ) {
    12111211                                                        return makeIncrDecrExpr( appExpr, baseType, varExpr->get_var()->get_name() == "++?" );
    12121212                                                } // if
    12131213                                        } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
    1214                                                 assert( appExpr->has_result() );
     1214                                                assert( ! appExpr->get_results().empty() );
    12151215                                                assert( appExpr->get_args().size() == 2 );
    1216                                                 Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
    1217                                                 Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
     1216                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
     1217                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
    12181218                                                if ( baseType1 && baseType2 ) {
    12191219                                                        UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
    12201220                                                        divide->get_args().push_back( appExpr );
    12211221                                                        divide->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
    1222                                                         divide->set_result( appExpr->get_result()->clone() );
     1222                                                        divide->get_results().push_front( appExpr->get_results().front()->clone() );
    12231223                                                        if ( appExpr->get_env() ) {
    12241224                                                                divide->set_env( appExpr->get_env() );
    … …  
    12381238                                                } // if
    12391239                                        } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
    1240                                                 assert( appExpr->has_result() );
     1240                                                assert( ! appExpr->get_results().empty() );
    12411241                                                assert( appExpr->get_args().size() == 2 );
    1242                                                 Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env );
     1242                                                Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env );
    12431243                                                if ( baseType ) {
    12441244                                                        UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
    … …  
    12661266                        useRetval = oldUseRetval;
    12671267
    1268                         assert( appExpr->get_function()->has_result() );
    1269                         PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
    1270                         FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
     1268                        assert( ! appExpr->get_function()->get_results().empty() );
     1269                        PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
     1270                        assert( pointer );
     1271                        FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
     1272                        assert( function );
    12711273
    12721274                        if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
    … …  
    13061308
    13071309                Expression *Pass1::mutate( UntypedExpr *expr ) {
    1308                         if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
     1310                        if ( ! expr->get_results().empty() && isPolyType( expr->get_results().front(), scopeTyVars, env ) ) {
    13091311                                if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
    13101312                                        if ( name->get_name() == "*?" ) {
    … …  
    13201322
    13211323                Expression *Pass1::mutate( AddressExpr *addrExpr ) {
    1322                         assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
     1324                        assert( ! addrExpr->get_arg()->get_results().empty() );
    13231325
    13241326                        bool needs = false;
    13251327                        if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
    1326                                 if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
     1328                                if ( ! expr->get_results().empty() && isPolyType( expr->get_results().front(), scopeTyVars, env ) ) {
    13271329                                        if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
    13281330                                                if ( name->get_name() == "*?" ) {
    13291331                                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
    1330                                                                 assert( appExpr->get_function()->has_result() );
    1331                                                                 PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
    1332                                                                 FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
     1332                                                                assert( ! appExpr->get_function()->get_results().empty() );
     1333                                                                PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
     1334                                                                assert( pointer );
     1335                                                                FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
     1336                                                                assert( function );
    13331337                                                                needs = needsAdapter( function, scopeTyVars );
    13341338                                                        } // if
    … …  
    13391343                        // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
    13401344                        // out of the if condition.
    1341                         bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
     1345                        bool polytype = isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env );
    13421346                        addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
    13431347                        if ( polytype || needs ) {
    13441348                                Expression *ret = addrExpr->get_arg();
    1345                                 delete ret->get_result();
    1346                                 ret->set_result( addrExpr->get_result()->clone() );
     1349                                delete ret->get_results().front();
     1350                                ret->get_results().front() = addrExpr->get_results().front()->clone();
    13471351                                addrExpr->set_arg( 0 );
    13481352                                delete addrExpr;
    … …  
    13821386                Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
    13831387                        if ( retval && returnStmt->get_expr() ) {
    1384                                 assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
     1388                                assert( ! returnStmt->get_expr()->get_results().empty() );
    13851389                                // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous.
    13861390                                // if ( returnStmt->get_expr()->get_results().front()->get_isLvalue() ) {
    … …  
    14161420                                        // find each of its needed secondary assignment operators
    14171421                                        std::list< Expression* > &tyParams = refType->get_parameters();
    1418                                         Type::ForallList &forallParams = functionDecl->get_type()->get_forall();
     1422                                        std::list< TypeDecl* > &forallParams = functionDecl->get_type()->get_forall();
    14191423                                        std::list< Expression* >::const_iterator tyIt = tyParams.begin();
    1420                                         Type::ForallList::const_iterator forallIt = forallParams.begin();
     1424                                        std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin();
    14211425                                        for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) {
    14221426                                                // Add appropriate mapping to assignment expression environment
    … …  
    14621466                                // replace return statement with appropriate assignment to out parameter
    14631467                                Expression *retParm = new NameExpr( retval->get_name() );
    1464                                 retParm->set_result( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
     1468                                retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
    14651469                                assignExpr->get_args().push_back( retParm );
    14661470                                assignExpr->get_args().push_back( returnStmt->get_expr() );
    … …  
    15921596                        ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0,
    15931597                                           new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
    1594                         for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
     1598                        for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
    15951599                                ObjectDecl *sizeParm, *alignParm;
    15961600                                // add all size and alignment parameters to parameter list

  • src/GenPoly/CopyParams.cc

    ra1e67dd rfe7b281  
    5454                                std::map< std::string, DeclarationWithType* > assignOps;
    5555                                // assume the assignment operator is the first assert param after any "type" parameter
    56                                 for ( Type::ForallList::const_iterator tyVar = funcDecl->get_functionType()->get_forall().begin(); tyVar != funcDecl->get_functionType()->get_forall().end(); ++tyVar ) {
     56                                for ( std::list< TypeDecl* >::const_iterator tyVar = funcDecl->get_functionType()->get_forall().begin(); tyVar != funcDecl->get_functionType()->get_forall().end(); ++tyVar ) {
    5757                                        if ( (*tyVar)->get_kind() == TypeDecl::Any ) {
    5858                                                assert( !(*tyVar)->get_assertions().empty() );

  • src/GenPoly/FindFunction.cc

    ra1e67dd rfe7b281  
    2929                virtual Type *mutate( PointerType *pointerType );
    3030          private:
    31                 void handleForall( const Type::ForallList &forall );
     31                void handleForall( const std::list< TypeDecl* > &forall );
    3232
    3333                std::list< FunctionType* > &functions;
    … …  
    5151        }
    5252
    53         void FindFunction::handleForall( const Type::ForallList &forall ) {
    54                 for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
     53        void FindFunction::handleForall( const std::list< TypeDecl* > &forall ) {
     54                for ( std::list< TypeDecl* >::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
    5555                        TyVarMap::iterator var = tyVars.find( (*i)->get_name() );
    5656                        if ( var != tyVars.end() ) {

  • src/GenPoly/GenPoly.cc

    ra1e67dd rfe7b281  
    110110        ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &forallTypes ) {
    111111                if ( function->get_returnVals().empty() ) return 0;
    112 
     112               
    113113                return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
    114114        }
    … …  
    127127//              } // if
    128128                if ( isDynRet( adaptee, tyVars ) ) return true;
    129 
     129               
    130130                for ( std::list< DeclarationWithType* >::const_iterator innerArg = adaptee->get_parameters().begin(); innerArg != adaptee->get_parameters().end(); ++innerArg ) {
    131131//                      if ( isPolyType( (*innerArg)->get_type(), tyVars ) ) {
    … …  
    228228
    229229        void makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
    230                 for ( Type::ForallList::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
     230                for ( std::list< TypeDecl* >::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
    231231                        assert( *tyVar );
    232232                        tyVarMap[ (*tyVar)->get_name() ] = (*tyVar)->get_kind();

  • src/GenPoly/Lvalue.cc

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Lvalue.cc --
     7// Lvalue.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    4141                  public:
    4242                        Pass1();
    43 
     43 
    4444                        virtual Expression *mutate( ApplicationExpr *appExpr );
    4545                        virtual Statement *mutate( ReturnStmt *appExpr );
    … …  
    9999                        appExpr->get_function()->acceptMutator( *this );
    100100                        mutateAll( appExpr->get_args(), *this );
     101 
     102                        assert( ! appExpr->get_function()->get_results().empty() );
    101103
    102                         PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
    103                         FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
     104                        PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
     105                        assert( pointer );
     106                        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
     107                        assert( function );
    104108
    105109                        Type *funType = isLvalueRet( function );
    106110                        if ( funType && ! isIntrinsicApp( appExpr ) ) {
    107111                                Expression *expr = appExpr;
    108                                 Type *appType = appExpr->get_result();
     112                                Type *appType = appExpr->get_results().front();
    109113                                if ( isPolyType( funType ) && ! isPolyType( appType ) ) {
    110114                                        // make sure cast for polymorphic type is inside dereference
    … …  
    112116                                }
    113117                                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
    114                                 deref->set_result( appType->clone() );
    115                                 appExpr->set_result( new PointerType( Type::Qualifiers(), appType ) );
     118                                deref->get_results().push_back( appType->clone() );
     119                                appExpr->get_results().front() = new PointerType( Type::Qualifiers(), appType );
    116120                                deref->get_args().push_back( expr );
    117121                                return deref;
    … …  
    123127                Statement * Pass1::mutate(ReturnStmt *retStmt) {
    124128                        if ( retval && retStmt->get_expr() ) {
    125                                 if ( retStmt->get_expr()->get_result()->get_isLvalue() ) {
     129                                assert( ! retStmt->get_expr()->get_results().empty() );
     130                                if ( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
    126131                                        // ***** Code Removal ***** because casts may be stripped already
    127132
    … …  
    150155                                retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
    151156                        } // if
    152 
     157 
    153158                        Visitor::visit( funType );
    154159                }

  • src/GenPoly/Specialize.cc

    ra1e67dd rfe7b281  
    147147
    148148        Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
    149                 assert( actual->has_result() );
    150                 if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
     149                assert( ! actual->get_results().empty() ); // using front, should have this assert
     150                if ( needsSpecialization( formalType, actual->get_results().front(), env ) ) {
    151151                        FunctionType *funType;
    152152                        if ( ( funType = getFunctionType( formalType ) ) ) {
    … …  
    171171        void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
    172172                // create thunks for the explicit parameters
    173                 assert( appExpr->get_function()->has_result() );
    174                 FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
     173                assert( ! appExpr->get_function()->get_results().empty() );
     174                FunctionType *function = getFunctionType( appExpr->get_function()->get_results().front() );
    175175                assert( function );
    176176                std::list< DeclarationWithType* >::iterator formal;
    … …  
    200200        Expression * Specialize::mutate( AddressExpr *addrExpr ) {
    201201                addrExpr->get_arg()->acceptMutator( *this );
    202                 assert( addrExpr->has_result() );
    203                 addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
     202                assert( ! addrExpr->get_results().empty() );
     203                addrExpr->set_arg( doSpecialization( addrExpr->get_results().front(), addrExpr->get_arg() ) );
    204204                return addrExpr;
    205205        }
    … …  
    207207        Expression * Specialize::mutate( CastExpr *castExpr ) {
    208208                castExpr->get_arg()->acceptMutator( *this );
    209                 if ( castExpr->get_result()->isVoid() ) {
     209                if ( castExpr->get_results().empty() ) {
    210210                        // can't specialize if we don't have a return value
    211211                        return castExpr;
    212212                }
    213                 Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
     213                Expression *specialized = doSpecialization( castExpr->get_results().front(), castExpr->get_arg() );
    214214                if ( specialized != castExpr->get_arg() ) {
    215215                        // assume here that the specialization incorporates the cast

  • src/InitTweak/FixInit.cc

    ra1e67dd rfe7b281  
    3535#include "GenPoly/DeclMutator.h"
    3636#include "SynTree/AddStmtVisitor.h"
    37 #include "CodeGen/GenType.h"  // for warning/error messages
    38 
    39 bool ctordtorp = false; // print all debug
    40 bool ctorp = false; // print ctor debug
    41 bool cpctorp = false; // print copy ctor debug
    42 bool dtorp = false; // print dtor debug
     37#include "CodeGen/GenType.h"  // for warnings
     38
     39bool ctordtorp = false;
     40bool ctorp = false;
     41bool cpctorp = false;
     42bool dtorp = false;
    4343#define PRINT( text ) if ( ctordtorp ) { text }
    4444#define CP_CTOR_PRINT( text ) if ( ctordtorp || cpctorp ) { text }
    … …  
    4747namespace InitTweak {
    4848        namespace {
     49                const std::list<Label> noLabels;
     50                const std::list<Expression*> noDesignators;
     51
    4952                class InsertImplicitCalls : public GenPoly::PolyMutator {
    5053                public:
    … …  
    6669
    6770                        /// create and resolve ctor/dtor expression: fname(var, [cpArg])
    68                         Expression * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL );
    69                         Expression * makeCtorDtor( const std::string & fname, Expression * thisArg, Expression * cpArg = NULL );
     71                        ApplicationExpr * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL );
    7072                        /// true if type does not need to be copy constructed to ensure correctness
    71                         bool skipCopyConstruct( Type * type );
    72                         void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
    73                         void destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
     73                        bool skipCopyConstruct( Type * );
    7474                private:
    7575                        TypeSubstitution * env;
    … …  
    357357                }
    358358
    359                 Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
     359                ApplicationExpr * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
    360360                        assert( var );
    361                         return makeCtorDtor( fname, new AddressExpr( new VariableExpr( var ) ), cpArg );
    362                 }
    363 
    364                 Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, Expression * thisArg, Expression * cpArg ) {
    365                         assert( thisArg );
    366361                        UntypedExpr * untyped = new UntypedExpr( new NameExpr( fname ) );
    367                         untyped->get_args().push_back( thisArg );
     362                        untyped->get_args().push_back( new AddressExpr( new VariableExpr( var ) ) );
    368363                        if (cpArg) untyped->get_args().push_back( cpArg->clone() );
    369364
    … …  
    372367                        // (VariableExpr and already resolved expression)
    373368                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
    374                         Expression * resolved = ResolvExpr::findVoidExpression( untyped, *this );
    375                         assert( resolved );
     369                        ApplicationExpr * resolved = dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untyped, *this ) );
    376370                        if ( resolved->get_env() ) {
    377371                                env->add( *resolved->get_env() );
    378372                        } // if
    379373
     374                        assert( resolved );
    380375                        delete untyped;
    381376                        return resolved;
    382377                }
    383378
    384                 void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
     379                void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
    385380                        static UniqueName tempNamer("_tmp_cp");
    386                         CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
    387                         assert( arg->has_result() );
    388                         Type * result = arg->get_result();
    389                         if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
    390 
    391                         // type may involve type variables, so apply type substitution to get temporary variable's actual type
    392                         result = result->clone();
    393                         impCpCtorExpr->get_env()->apply( result );
    394                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
    395                         tmp->get_type()->set_isConst( false );
    396 
    397                         // create and resolve copy constructor
    398                         CP_CTOR_PRINT( std::cerr << "makeCtorDtor for an argument" << std::endl; )
    399                         Expression * cpCtor = makeCtorDtor( "?{}", tmp, arg );
    400 
    401                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( cpCtor ) ) {
    402                                 // if the chosen constructor is intrinsic, the copy is unnecessary, so
    403                                 // don't create the temporary and don't call the copy constructor
    404                                 VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
    405                                 assert( function );
    406                                 if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return;
    407                         }
    408 
    409                         // replace argument to function call with temporary
    410                         arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) );
    411                         impCpCtorExpr->get_tempDecls().push_back( tmp );
    412                         impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
    413                 }
    414 
    415                 void ResolveCopyCtors::destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr ) {
    416                         impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", new AddressExpr( ret ) ) );
    417                 }
    418 
    419                 void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
     381                        static UniqueName retNamer("_tmp_cp_ret");
     382
    420383                        CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
    421384                        Visitor::visit( impCpCtorExpr );
    … …  
    426389                        // take each argument and attempt to copy construct it.
    427390                        for ( Expression * & arg : appExpr->get_args() ) {
    428                                 copyConstructArg( arg, impCpCtorExpr );
     391                                CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
     392                                // xxx - need to handle tuple arguments
     393                                assert( ! arg->get_results().empty() );
     394                                Type * result = arg->get_results().front();
     395                                if ( skipCopyConstruct( result ) ) continue; // skip certain non-copyable types
     396                                // type may involve type variables, so apply type substitution to get temporary variable's actual type
     397                                result = result->clone();
     398                                impCpCtorExpr->get_env()->apply( result );
     399                                ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
     400                                tmp->get_type()->set_isConst( false );
     401
     402                                // create and resolve copy constructor
     403                                CP_CTOR_PRINT( std::cerr << "makeCtorDtor for an argument" << std::endl; )
     404                                ApplicationExpr * cpCtor = makeCtorDtor( "?{}", tmp, arg );
     405
     406                                // if the chosen constructor is intrinsic, the copy is unnecessary, so
     407                                // don't create the temporary and don't call the copy constructor
     408                                VariableExpr * function = dynamic_cast< VariableExpr * >( cpCtor->get_function() );
     409                                assert( function );
     410                                if ( function->get_var()->get_linkage() != LinkageSpec::Intrinsic ) {
     411                                        // replace argument to function call with temporary
     412                                        arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) );
     413                                        impCpCtorExpr->get_tempDecls().push_back( tmp );
     414                                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
     415                                } // if
    429416                        } // for
    430417
    … …  
    436423                        // level. Trying to pass that environment along.
    437424                        callExpr->set_env( impCpCtorExpr->get_env()->clone() );
    438                         Type * result = appExpr->get_result();
    439                         if ( ! result->isVoid() ) {
    440                                 static UniqueName retNamer("_tmp_cp_ret");
     425                        for ( Type * result : appExpr->get_results() ) {
    441426                                result = result->clone();
    442427                                impCpCtorExpr->get_env()->apply( result );
    … …  
    445430                                impCpCtorExpr->get_returnDecls().push_back( ret );
    446431                                CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
    447                                 destructRet( new VariableExpr( ret ) , impCpCtorExpr );
     432                                impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
    448433                        } // for
    449434                        CP_CTOR_PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
    … …  
    494479                                // know the result type of the assignment is the type of the LHS (minus the pointer), so
    495480                                // add that onto the assignment expression so that later steps have the necessary information
    496                                 assign->set_result( returnDecl->get_type()->clone() );
     481                                assign->add_result( returnDecl->get_type()->clone() );
    497482
    498483                                Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
    499                                 if ( callExpr->get_result()->get_isLvalue() ) {
     484                                if ( callExpr->get_results().front()->get_isLvalue() ) {
    500485                                        // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
    501486                                        // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
    … …  
    515500                                        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
    516501                                        deref->get_args().push_back( retExpr );
    517                                         deref->set_result( resultType );
     502                                        deref->add_result( resultType );
    518503                                        retExpr = deref;
    519504                                } // if
    … …  
    954939                Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
    955940                        static UniqueName tempNamer( "_tmp_ctor_expr" );
    956                         // xxx - is the size check necessary?
    957                         assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
    958                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
     941                        assert( ctorExpr->get_results().size() == 1 );
     942                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_results().front()->clone(), nullptr );
    959943                        addDeclaration( tmp );
    960944
    … …  
    968952                        assign->get_args().push_back( new VariableExpr( tmp ) );
    969953                        assign->get_args().push_back( firstArg );
    970                         assign->set_result( ctorExpr->get_result()->clone() );
     954                        cloneAll( ctorExpr->get_results(), assign->get_results() );
    971955                        firstArg = assign;
    972956

  • src/InitTweak/GenInit.cc

    ra1e67dd rfe7b281  
    2929#include "GenPoly/DeclMutator.h"
    3030#include "GenPoly/ScopedSet.h"
    31 #include "ResolvExpr/typeops.h"
    3231
    3332namespace InitTweak {
    … …  
    5150
    5251          protected:
    53                 FunctionType * ftype;
     52                std::list<DeclarationWithType*> returnVals;
    5453                UniqueName tempNamer;
    5554                std::string funcName;
    … …  
    8786
    8887                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
    89                 bool isManaged( Type * type ) const; // determine if type is managed
    9088                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
    9189                GenPoly::ScopedSet< std::string > managedTypes;
    … …  
    136134
    137135        Statement *ReturnFixer::mutate( ReturnStmt *returnStmt ) {
    138                 std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
     136                // update for multiple return values
    139137                assert( returnVals.size() == 0 || returnVals.size() == 1 );
    140138                // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address
    … …  
    158156
    159157        DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
    160                 // xxx - need to handle named return values - this pass may need to happen
    161                 // after resolution? the ordering is tricky because return statements must be
    162                 // constructed - the simplest way to do that (while also handling multiple
    163                 // returns) is to structure the returnVals into a tuple, as done here.
    164                 // however, if the tuple return value is structured before resolution,
    165                 // it's difficult to resolve named return values, since the name is lost
    166                 // in conversion to a tuple. this might be easiest to deal with
    167                 // after reference types are added, as it may then be possible to
    168                 // uniformly move named return values to the parameter list directly
    169                 ValueGuard< FunctionType * > oldFtype( ftype );
     158                ValueGuard< std::list<DeclarationWithType*> > oldReturnVals( returnVals );
    170159                ValueGuard< std::string > oldFuncName( funcName );
    171160
    172                 ftype = functionDecl->get_functionType();
    173                 std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
    174                 if ( retVals.size() > 1 ) {
    175                         TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
    176                         ObjectDecl * newRet = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
    177                         retVals.clear();
    178                         retVals.push_back( newRet );
    179                 }
     161                FunctionType * type = functionDecl->get_functionType();
     162                returnVals = type->get_returnVals();
    180163                funcName = functionDecl->get_name();
    181164                DeclarationWithType * decl = Mutator::mutate( functionDecl );
    … …  
    237220        }
    238221
    239         bool CtorDtor::isManaged( Type * type ) const {
    240                 if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
    241                         // tuple is also managed if any of its components are managed
    242                         if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
    243                                 return true;
    244                         }
    245                 }
    246                 return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
    247         }
    248 
    249222        bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
    250223                Type * type = objDecl->get_type();
    … …  
    252225                        type = at->get_base();
    253226                }
    254                 return isManaged( type );
     227                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
    255228        }
    256229
    … …  
    263236                        managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
    264237                }
    265         }
    266 
    267         ConstructorInit * genCtorInit( ObjectDecl * objDecl ) {
    268                 // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
    269                 // for each constructable object
    270                 std::list< Statement * > ctor;
    271                 std::list< Statement * > dtor;
    272 
    273                 InitExpander srcParam( objDecl->get_init() );
    274                 InitExpander nullParam( (Initializer *)NULL );
    275                 SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
    276                 SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
    277 
    278                 // Currently genImplicitCall produces a single Statement - a CompoundStmt
    279                 // which  wraps everything that needs to happen. As such, it's technically
    280                 // possible to use a Statement ** in the above calls, but this is inherently
    281                 // unsafe, so instead we take the slightly less efficient route, but will be
    282                 // immediately informed if somehow the above assumption is broken. In this case,
    283                 // we could always wrap the list of statements at this point with a CompoundStmt,
    284                 // but it seems reasonable at the moment for this to be done by genImplicitCall
    285                 // itself. It is possible that genImplicitCall produces no statements (e.g. if
    286                 // an array type does not have a dimension). In this case, it's fine to ignore
    287                 // the object for the purposes of construction.
    288                 assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
    289                 if ( ctor.size() == 1 ) {
    290                         // need to remember init expression, in case no ctors exist
    291                         // if ctor does exist, want to use ctor expression instead of init
    292                         // push this decision to the resolver
    293                         assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
    294                         return new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() );
    295                 }
    296                 return nullptr;
    297238        }
    298239
    … …  
    307248                        if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl );
    308249
    309                         objDecl->set_init( genCtorInit( objDecl ) );
     250                        // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
     251                        // for each constructable object
     252                        std::list< Statement * > ctor;
     253                        std::list< Statement * > dtor;
     254
     255                        InitExpander srcParam( objDecl->get_init() );
     256                        InitExpander nullParam( (Initializer *)NULL );
     257                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
     258                        SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
     259
     260                        // Currently genImplicitCall produces a single Statement - a CompoundStmt
     261                        // which  wraps everything that needs to happen. As such, it's technically
     262                        // possible to use a Statement ** in the above calls, but this is inherently
     263                        // unsafe, so instead we take the slightly less efficient route, but will be
     264                        // immediately informed if somehow the above assumption is broken. In this case,
     265                        // we could always wrap the list of statements at this point with a CompoundStmt,
     266                        // but it seems reasonable at the moment for this to be done by genImplicitCall
     267                        // itself. It is possible that genImplicitCall produces no statements (e.g. if
     268                        // an array type does not have a dimension). In this case, it's fine to ignore
     269                        // the object for the purposes of construction.
     270                        assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
     271                        if ( ctor.size() == 1 ) {
     272                                // need to remember init expression, in case no ctors exist
     273                                // if ctor does exist, want to use ctor expression instead of init
     274                                // push this decision to the resolver
     275                                assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
     276                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
     277                        }
    310278                }
    311279                return Parent::mutate( objDecl );
    … …  
    320288                managedTypes.beginScope();
    321289                // go through assertions and recursively add seen ctor/dtors
    322                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
     290                for ( TypeDecl * tyDecl : functionDecl->get_functionType()->get_forall() ) {
    323291                        for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
    324292                                assertion = assertion->acceptMutator( *this );

  • src/InitTweak/GenInit.h

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // GenInit.h --
     7// RemoveInit.h --
    88//
    99// Author           : Rodolfo G. Esteves
    … …  
    2727        /// Adds return value temporaries and wraps Initializers in ConstructorInit nodes
    2828        void genInit( std::list< Declaration * > & translationUnit );
    29 
    30         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
    31         ConstructorInit * genCtorInit( ObjectDecl * objDecl );
    3229} // namespace
    3330

  • src/InitTweak/InitTweak.cc

    ra1e67dd rfe7b281  
    340340                return allofCtorDtor( stmt, []( Expression * callExpr ){
    341341                        if ( ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
    342                                 FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_result() );
     342                                assert( ! appExpr->get_function()->get_results().empty() );
     343                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_results().front() );
    343344                                assert( funcType );
    344345                                return funcType->get_parameters().size() == 1;
    … …  
    387388                                return memberExpr->get_member()->get_name();
    388389                        } else if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * > ( func ) ) {
    389                                 return funcName( memberExpr->get_member() );
     390                                return memberExpr->get_member();
    390391                        } else {
    391392                                assertf( false, "Unexpected expression type being called as a function in call expression" );
    … …  
    450451                // virtual void visit( LogicalExpr *logicalExpr );
    451452                // virtual void visit( ConditionalExpr *conditionalExpr );
     453                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
     454                virtual void visit( SolvedTupleExpr *tupleExpr ) { isConstExpr = false; }
    452455                virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
    453456                virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
    454457                virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
    455458                virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
    456                 virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
    457                 virtual void visit( TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
    458459
    459460                bool isConstExpr;

  • src/Makefile.in

    ra1e67dd rfe7b281  
    105105        ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT) \
    106106        ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT) \
     107        ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT) \
    107108        GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \
    108109        GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \
    … …  
    190191        SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
    191192        Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT) \
    192         Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT)
     193        Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT)
    193194am_driver_cfa_cpp_OBJECTS = $(am__objects_1)
    194195driver_cfa_cpp_OBJECTS = $(am_driver_cfa_cpp_OBJECTS)
    … …  
    363364        ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
    364365        ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
    365         ControlStruct/ForExprMutator.cc GenPoly/Box.cc \
     366        ControlStruct/ForExprMutator.cc \
     367        ControlStruct/LabelTypeChecker.cc GenPoly/Box.cc \
    366368        GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
    367369        GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
    … …  
    403405        SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \
    404406        SynTree/Attribute.cc Tuples/TupleAssignment.cc \
    405         Tuples/TupleExpansion.cc
     407        Tuples/NameMatcher.cc
    406408MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
    407409        ${cfa_cpplib_PROGRAMS}}
    … …  
    538540        ControlStruct/$(DEPDIR)/$(am__dirstamp)
    539541ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT):  \
     542        ControlStruct/$(am__dirstamp) \
     543        ControlStruct/$(DEPDIR)/$(am__dirstamp)
     544ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT):  \
    540545        ControlStruct/$(am__dirstamp) \
    541546        ControlStruct/$(DEPDIR)/$(am__dirstamp)
    … …  
    771776Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT):  \
    772777        Tuples/$(am__dirstamp) Tuples/$(DEPDIR)/$(am__dirstamp)
    773 Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT): \
    774         Tuples/$(am__dirstamp) Tuples/$(DEPDIR)/$(am__dirstamp)
     778Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT): Tuples/$(am__dirstamp) \
     779        Tuples/$(DEPDIR)/$(am__dirstamp)
    775780driver/$(am__dirstamp):
    776781        @$(MKDIR_P) driver
    … …  
    794799        -rm -f ControlStruct/driver_cfa_cpp-LabelFixer.$(OBJEXT)
    795800        -rm -f ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT)
     801        -rm -f ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT)
    796802        -rm -f ControlStruct/driver_cfa_cpp-MLEMutator.$(OBJEXT)
    797803        -rm -f ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT)
    … …  
    880886        -rm -f SynTree/driver_cfa_cpp-VoidType.$(OBJEXT)
    881887        -rm -f SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT)
     888        -rm -f Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT)
    882889        -rm -f Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT)
    883         -rm -f Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT)
    884890
    885891distclean-compile:
    … …  
    900906@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelFixer.Po@am__quote@
    901907@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelGenerator.Po@am__quote@
     908@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po@am__quote@
    902909@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-MLEMutator.Po@am__quote@
    903910@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-Mutate.Po@am__quote@
    … …  
    986993@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
    987994@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
     995@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po@am__quote@
    988996@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Po@am__quote@
    989 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po@am__quote@
    990997
    991998.cc.o:
    … …  
    12291236@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-ForExprMutator.obj `if test -f 'ControlStruct/ForExprMutator.cc'; then $(CYGPATH_W) 'ControlStruct/ForExprMutator.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/ForExprMutator.cc'; fi`
    12301237
     1238ControlStruct/driver_cfa_cpp-LabelTypeChecker.o: ControlStruct/LabelTypeChecker.cc
     1239@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-LabelTypeChecker.o -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo -c -o ControlStruct/driver_cfa_cpp-LabelTypeChecker.o `test -f 'ControlStruct/LabelTypeChecker.cc' || echo '$(srcdir)/'`ControlStruct/LabelTypeChecker.cc
     1240@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po
     1241@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/LabelTypeChecker.cc' object='ControlStruct/driver_cfa_cpp-LabelTypeChecker.o' libtool=no @AMDEPBACKSLASH@
     1242@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1243@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-LabelTypeChecker.o `test -f 'ControlStruct/LabelTypeChecker.cc' || echo '$(srcdir)/'`ControlStruct/LabelTypeChecker.cc
     1244
     1245ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj: ControlStruct/LabelTypeChecker.cc
     1246@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj -MD -MP -MF ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo -c -o ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj `if test -f 'ControlStruct/LabelTypeChecker.cc'; then $(CYGPATH_W) 'ControlStruct/LabelTypeChecker.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/LabelTypeChecker.cc'; fi`
     1247@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po
     1248@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/LabelTypeChecker.cc' object='ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj' libtool=no @AMDEPBACKSLASH@
     1249@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1250@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj `if test -f 'ControlStruct/LabelTypeChecker.cc'; then $(CYGPATH_W) 'ControlStruct/LabelTypeChecker.cc'; else $(CYGPATH_W) '$(srcdir)/ControlStruct/LabelTypeChecker.cc'; fi`
     1251
    12311252GenPoly/driver_cfa_cpp-Box.o: GenPoly/Box.cc
    12321253@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-Box.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Tpo -c -o GenPoly/driver_cfa_cpp-Box.o `test -f 'GenPoly/Box.cc' || echo '$(srcdir)/'`GenPoly/Box.cc
    … …  
    24192440@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Tuples/driver_cfa_cpp-TupleAssignment.obj `if test -f 'Tuples/TupleAssignment.cc'; then $(CYGPATH_W) 'Tuples/TupleAssignment.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/TupleAssignment.cc'; fi`
    24202441
    2421 Tuples/driver_cfa_cpp-TupleExpansion.o: Tuples/TupleExpansion.cc
    2422 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-TupleExpansion.o -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo -c -o Tuples/driver_cfa_cpp-TupleExpansion.o `test -f 'Tuples/TupleExpansion.cc' || echo '$(srcdir)/'`Tuples/TupleExpansion.cc
    2423 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po
    2424 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/TupleExpansion.cc' object='Tuples/driver_cfa_cpp-TupleExpansion.o' libtool=no @AMDEPBACKSLASH@
    2425 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    2426 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Tuples/driver_cfa_cpp-TupleExpansion.o `test -f 'Tuples/TupleExpansion.cc' || echo '$(srcdir)/'`Tuples/TupleExpansion.cc
    2427 
    2428 Tuples/driver_cfa_cpp-TupleExpansion.obj: Tuples/TupleExpansion.cc
    2429 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-TupleExpansion.obj -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo -c -o Tuples/driver_cfa_cpp-TupleExpansion.obj `if test -f 'Tuples/TupleExpansion.cc'; then $(CYGPATH_W) 'Tuples/TupleExpansion.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/TupleExpansion.cc'; fi`
    2430 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po
    2431 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/TupleExpansion.cc' object='Tuples/driver_cfa_cpp-TupleExpansion.obj' libtool=no @AMDEPBACKSLASH@
    2432 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    2433 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Tuples/driver_cfa_cpp-TupleExpansion.obj `if test -f 'Tuples/TupleExpansion.cc'; then $(CYGPATH_W) 'Tuples/TupleExpansion.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/TupleExpansion.cc'; fi`
     2442Tuples/driver_cfa_cpp-NameMatcher.o: Tuples/NameMatcher.cc
     2443@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-NameMatcher.o -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo -c -o Tuples/driver_cfa_cpp-NameMatcher.o `test -f 'Tuples/NameMatcher.cc' || echo '$(srcdir)/'`Tuples/NameMatcher.cc
     2444@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po
     2445@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/NameMatcher.cc' object='Tuples/driver_cfa_cpp-NameMatcher.o' libtool=no @AMDEPBACKSLASH@
     2446@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2447@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Tuples/driver_cfa_cpp-NameMatcher.o `test -f 'Tuples/NameMatcher.cc' || echo '$(srcdir)/'`Tuples/NameMatcher.cc
     2448
     2449Tuples/driver_cfa_cpp-NameMatcher.obj: Tuples/NameMatcher.cc
     2450@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-NameMatcher.obj -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo -c -o Tuples/driver_cfa_cpp-NameMatcher.obj `if test -f 'Tuples/NameMatcher.cc'; then $(CYGPATH_W) 'Tuples/NameMatcher.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/NameMatcher.cc'; fi`
     2451@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po
     2452@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/NameMatcher.cc' object='Tuples/driver_cfa_cpp-NameMatcher.obj' libtool=no @AMDEPBACKSLASH@
     2453@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2454@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o Tuples/driver_cfa_cpp-NameMatcher.obj `if test -f 'Tuples/NameMatcher.cc'; then $(CYGPATH_W) 'Tuples/NameMatcher.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/NameMatcher.cc'; fi`
    24342455
    24352456.ll.cc:

  • src/Parser/ExpressionNode.cc

    ra1e67dd rfe7b281  
    198198}
    199199
    200 Expression *build_fieldSel( ExpressionNode *expr_node, Expression *member ) {
    201         UntypedMemberExpr *ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
    202         return ret;
    203 }
    204 
    205 Expression *build_pfieldSel( ExpressionNode *expr_node, Expression *member ) {
     200Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member ) {
     201        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeMoveBuild< Expression >(expr_node) );
     202        delete member;
     203        return ret;
     204}
     205
     206Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member ) {
    206207        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
    207208        deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
    208         UntypedMemberExpr *ret = new UntypedMemberExpr( member, deref );
     209        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
     210        delete member;
    209211        return ret;
    210212}

  • src/Parser/ParseNode.h

    ra1e67dd rfe7b281  
    160160
    161161Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
    162 Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
    163 Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
     162Expression * build_fieldSel( ExpressionNode * expr_node, NameExpr * member );
     163Expression * build_pfieldSel( ExpressionNode * expr_node, NameExpr * member );
    164164Expression * build_addressOf( ExpressionNode * expr_node );
    165165Expression * build_sizeOfexpr( ExpressionNode * expr_node );
    … …  
    383383//##############################################################################
    384384
    385 template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
    386 void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
     385template< typename SynTreeType, typename NodeType >
     386void buildList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
    387387        SemanticError errors;
    388         std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
     388        std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
    389389        const NodeType * cur = firstNode;
    390390

  • src/Parser/TypeData.cc

    ra1e67dd rfe7b281  
    385385} // TypeData::print
    386386
    387 template< typename ForallList >
    388 void buildForall( const DeclarationNode * firstNode, ForallList &outputList ) {
     387void buildForall( const DeclarationNode * firstNode, list< TypeDecl* > &outputList ) {
    389388        buildList( firstNode, outputList );
    390         for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
    391                 TypeDecl * td = static_cast<TypeDecl*>(*i);
    392                 if ( td->get_kind() == TypeDecl::Any ) {
     389        for ( list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
     390                if ( (*i)->get_kind() == TypeDecl::Any ) {
    393391                        // add assertion parameters to `type' tyvars in reverse order
    394392                        // add dtor:  void ^?{}(T *)
    395393                        FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
    396                         dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    397                         td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
     394                        dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
     395                        (*i)->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
    398396
    399397                        // add copy ctor:  void ?{}(T *, T)
    400398                        FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
    401                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    402                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    403                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
     399                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
     400                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
     401                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
    404402
    405403                        // add default ctor:  void ?{}(T *)
    406404                        FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
    407                         ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    408                         td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
     405                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
     406                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
    409407
    410408                        // add assignment operator:  T * ?=?(T *, T)
    411409                        FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
    412                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
    413                         assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    414                         assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
    415                         td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
     410                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
     411                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
     412                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
     413                        (*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
    416414                } // if
    417415        } // for
    … …  
    517515                // character types. The implementation shall define char to have the same range, representation, and behavior as
    518516                // either signed char or unsigned char.
    519                 static BasicType::Kind chartype[] = { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::Char };
     517                static BasicType::Kind chartype[] = { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::Char }; 
    520518
    521519                if ( td->length != DeclarationNode::NoLength ) {

  • src/Parser/parser.cc

    ra1e67dd rfe7b281  
    10231023static const yytype_uint16 yyrline[] =
    10241024{
    1025        0,   301,   301,   305,   312,   313,   314,   318,   319,   320,
    1026      324,   325,   329,   330,   334,   335,   339,   343,   344,   355,
    1027      357,   359,   361,   366,   367,   373,   377,   379,   381,   383,
    1028      385,   387,   389,   391,   393,   402,   403,   409,   410,   414,
    1029      415,   419,   422,   424,   426,   428,   433,   436,   441,   444,
    1030      446,   448,   453,   466,   468,   470,   472,   474,   476,   478,
    1031      480,   482,   484,   486,   493,   494,   500,   501,   502,   503,
    1032      507,   508,   510,   515,   516,   518,   520,   525,   526,   528,
    1033      533,   534,   536,   541,   542,   544,   546,   548,   553,   554,
    1034      556,   561,   562,   567,   568,   573,   574,   579,   580,   585,
    1035      586,   591,   592,   595,   597,   602,   607,   608,   610,   616,
    1036      617,   621,   622,   623,   624,   625,   626,   627,   628,   629,
    1037      630,   631,   632,   638,   640,   642,   644,   649,   650,   655,
    1038      656,   662,   663,   669,   670,   671,   672,   673,   674,   675,
    1039      676,   677,   687,   694,   696,   706,   707,   712,   714,   720,
    1040      722,   726,   727,   732,   737,   740,   742,   744,   754,   756,
    1041      767,   768,   770,   774,   776,   780,   781,   786,   787,   791,
    1042      796,   797,   801,   803,   809,   810,   814,   816,   818,   820,
    1043      826,   827,   831,   833,   838,   840,   842,   847,   849,   854,
    1044      856,   860,   863,   867,   870,   874,   876,   878,   880,   885,
    1045      887,   889,   894,   896,   898,   900,   902,   907,   909,   911,
    1046      913,   918,   930,   931,   936,   938,   943,   947,   949,   951,
    1047      953,   955,   961,   962,   968,   969,   973,   974,   979,   981,
    1048      987,   988,   990,   995,  1000,  1010,  1012,  1016,  1017,  1022,
    1049     1024,  1028,  1029,  1033,  1035,  1039,  1040,  1044,  1045,  1049,
    1050     1050,  1065,  1066,  1067,  1068,  1069,  1073,  1078,  1085,  1095,
    1051     1100,  1105,  1113,  1118,  1123,  1128,  1133,  1141,  1163,  1168,
    1052     1175,  1177,  1184,  1189,  1194,  1205,  1210,  1215,  1220,  1225,
    1053     1234,  1239,  1247,  1248,  1249,  1250,  1256,  1261,  1269,  1270,
    1054     1271,  1272,  1276,  1277,  1278,  1279,  1284,  1285,  1294,  1295,
    1055     1300,  1301,  1306,  1308,  1310,  1312,  1314,  1317,  1316,  1328,
    1056     1329,  1331,  1341,  1342,  1347,  1349,  1351,  1353,  1355,  1358,
    1057     1360,  1363,  1368,  1370,  1372,  1374,  1376,  1378,  1380,  1382,
    1058     1384,  1386,  1388,  1390,  1392,  1398,  1399,  1401,  1403,  1405,
    1059     1410,  1411,  1417,  1418,  1420,  1422,  1427,  1429,  1431,  1433,
    1060     1438,  1439,  1441,  1443,  1448,  1449,  1451,  1456,  1457,  1459,
    1061     1461,  1466,  1468,  1470,  1475,  1476,  1480,  1482,  1488,  1487,
    1062     1491,  1493,  1498,  1500,  1506,  1507,  1512,  1513,  1515,  1516,
    1063     1525,  1526,  1528,  1530,  1535,  1537,  1543,  1544,  1546,  1549,
    1064     1552,  1557,  1558,  1563,  1568,  1572,  1574,  1580,  1579,  1586,
    1065     1588,  1594,  1595,  1603,  1604,  1608,  1609,  1610,  1612,  1614,
    1066     1621,  1622,  1624,  1626,  1631,  1632,  1638,  1639,  1643,  1644,
    1067     1649,  1650,  1651,  1653,  1661,  1662,  1664,  1667,  1669,  1673,
    1068     1674,  1675,  1677,  1679,  1683,  1688,  1696,  1697,  1706,  1708,
    1069     1713,  1714,  1715,  1719,  1720,  1721,  1725,  1726,  1727,  1731,
    1070     1732,  1733,  1738,  1739,  1740,  1741,  1747,  1748,  1750,  1755,
    1071     1756,  1761,  1762,  1763,  1764,  1765,  1780,  1781,  1786,  1787,
    1072     1793,  1795,  1798,  1800,  1802,  1825,  1826,  1828,  1830,  1835,
    1073     1836,  1838,  1843,  1848,  1849,  1855,  1854,  1858,  1862,  1864,
    1074     1866,  1872,  1873,  1878,  1883,  1885,  1890,  1892,  1893,  1895,
    1075     1900,  1902,  1904,  1909,  1911,  1916,  1921,  1929,  1935,  1934,
    1076     1948,  1949,  1954,  1955,  1959,  1964,  1969,  1977,  1982,  1993,
    1077     1994,  1999,  2000,  2006,  2007,  2011,  2012,  2013,  2016,  2015,
    1078     2026,  2035,  2041,  2047,  2056,  2062,  2068,  2074,  2080,  2088,
    1079     2094,  2102,  2108,  2117,  2118,  2119,  2123,  2127,  2129,  2134,
    1080     2135,  2139,  2140,  2145,  2151,  2152,  2155,  2157,  2158,  2162,
    1081     2163,  2164,  2165,  2199,  2201,  2202,  2204,  2209,  2214,  2219,
    1082     2221,  2223,  2228,  2230,  2232,  2234,  2239,  2241,  2250,  2252,
    1083     2253,  2258,  2260,  2262,  2267,  2269,  2271,  2276,  2278,  2280,
    1084     2289,  2290,  2291,  2295,  2297,  2299,  2304,  2306,  2308,  2313,
    1085     2315,  2317,  2332,  2334,  2335,  2337,  2342,  2343,  2348,  2350,
    1086     2352,  2357,  2359,  2361,  2363,  2368,  2370,  2372,  2382,  2384,
    1087     2385,  2387,  2392,  2394,  2396,  2401,  2403,  2405,  2407,  2412,
    1088     2414,  2416,  2447,  2449,  2450,  2452,  2457,  2462,  2470,  2472,
    1089     2474,  2479,  2481,  2486,  2488,  2502,  2503,  2505,  2510,  2512,
    1090     2514,  2516,  2518,  2523,  2524,  2526,  2528,  2533,  2535,  2537,
    1091     2543,  2545,  2547,  2551,  2553,  2555,  2557,  2571,  2572,  2574,
    1092     2579,  2581,  2583,  2585,  2587,  2592,  2593,  2595,  2597,  2602,
    1093     2604,  2606,  2612,  2613,  2615,  2624,  2627,  2629,  2632,  2634,
    1094     2636,  2649,  2650,  2652,  2657,  2659,  2661,  2663,  2665,  2670,
    1095     2671,  2673,  2675,  2680,  2682,  2690,  2691,  2692,  2697,  2698,
    1096     2702,  2704,  2706,  2708,  2710,  2712,  2719,  2721,  2723,  2725,
    1097     2727,  2730,  2732,  2734,  2736,  2738,  2743,  2745,  2747,  2752,
    1098     2778,  2779,  2781,  2785,  2786,  2790,  2792,  2794,  2796,  2798,
    1099     2800,  2807,  2809,  2811,  2813,  2815,  2817,  2822,  2827,  2829,
    1100     2831,  2849,  2851,  2856,  2857
     1025       0,   302,   302,   306,   313,   314,   315,   319,   320,   321,
     1026     325,   326,   330,   331,   335,   336,   340,   344,   345,   356,
     1027     358,   360,   362,   367,   368,   374,   378,   380,   381,   382,
     1028     384,   385,   387,   389,   391,   400,   401,   407,   408,   412,
     1029     413,   417,   421,   423,   425,   427,   432,   434,   438,   441,
     1030     443,   445,   450,   463,   465,   467,   469,   471,   473,   475,
     1031     477,   479,   481,   483,   490,   491,   497,   498,   499,   500,
     1032     504,   505,   507,   512,   513,   515,   517,   522,   523,   525,
     1033     530,   531,   533,   538,   539,   541,   543,   545,   550,   551,
     1034     553,   558,   559,   564,   565,   570,   571,   576,   577,   582,
     1035     583,   588,   589,   592,   594,   599,   604,   605,   607,   613,
     1036     614,   618,   619,   620,   621,   622,   623,   624,   625,   626,
     1037     627,   628,   629,   635,   637,   639,   641,   646,   647,   652,
     1038     653,   659,   660,   666,   667,   668,   669,   670,   671,   672,
     1039     673,   674,   684,   691,   693,   703,   704,   709,   711,   717,
     1040     719,   723,   724,   729,   734,   737,   739,   741,   751,   753,
     1041     764,   765,   767,   771,   773,   777,   778,   783,   784,   788,
     1042     793,   794,   798,   800,   806,   807,   811,   813,   815,   817,
     1043     823,   824,   828,   830,   835,   837,   839,   844,   846,   851,
     1044     853,   857,   860,   864,   867,   871,   873,   875,   877,   882,
     1045     884,   886,   891,   893,   895,   897,   899,   904,   906,   908,
     1046     910,   915,   927,   928,   933,   935,   940,   944,   946,   948,
     1047     950,   952,   958,   959,   965,   966,   970,   971,   976,   978,
     1048     984,   985,   987,   992,   997,  1007,  1009,  1013,  1014,  1019,
     1049    1021,  1025,  1026,  1030,  1032,  1036,  1037,  1041,  1042,  1046,
     1050    1047,  1062,  1063,  1064,  1065,  1066,  1070,  1075,  1082,  1092,
     1051    1097,  1102,  1110,  1115,  1120,  1125,  1130,  1138,  1160,  1165,
     1052    1172,  1174,  1181,  1186,  1191,  1202,  1207,  1212,  1217,  1222,
     1053    1231,  1236,  1244,  1245,  1246,  1247,  1253,  1258,  1266,  1267,
     1054    1268,  1269,  1273,  1274,  1275,  1276,  1281,  1282,  1291,  1292,
     1055    1297,  1298,  1303,  1305,  1307,  1309,  1311,  1314,  1313,  1325,
     1056    1326,  1328,  1338,  1339,  1344,  1346,  1348,  1350,  1352,  1355,
     1057    1357,  1360,  1365,  1367,  1369,  1371,  1373,  1375,  1377,  1379,
     1058    1381,  1383,  1385,  1387,  1389,  1395,  1396,  1398,  1400,  1402,
     1059    1407,  1408,  1414,  1415,  1417,  1419,  1424,  1426,  1428,  1430,
     1060    1435,  1436,  1438,  1440,  1445,  1446,  1448,  1453,  1454,  1456,
     1061    1458,  1463,  1465,  1467,  1472,  1473,  1477,  1479,  1485,  1484,
     1062    1488,  1490,  1495,  1497,  1503,  1504,  1509,  1510,  1512,  1513,
     1063    1522,  1523,  1525,  1527,  1532,  1534,  1540,  1541,  1543,  1546,
     1064    1549,  1554,  1555,  1560,  1565,  1569,  1571,  1577,  1576,  1583,
     1065    1585,  1591,  1592,  1600,  1601,  1605,  1606,  1607,  1609,  1611,
     1066    1618,  1619,  1621,  1623,  1628,  1629,  1635,  1636,  1640,  1641,
     1067    1646,  1647,  1648,  1650,  1658,  1659,  1661,  1664,  1666,  1670,
     1068    1671,  1672,  1674,  1676,  1680,  1685,  1693,  1694,  1703,  1705,
     1069    1710,  1711,  1712,  1716,  1717,  1718,  1722,  1723,  1724,  1728,
     1070    1729,  1730,  1735,  1736,  1737,  1738,  1744,  1745,  1747,  1752,
     1071    1753,  1758,  1759,  1760,  1761,  1762,  1777,  1778,  1783,  1784,
     1072    1790,  1792,  1795,  1797,  1799,  1822,  1823,  1825,  1827,  1832,
     1073    1833,  1835,  1840,  1845,  1846,  1852,  1851,  1855,  1859,  1861,
     1074    1863,  1869,  1870,  1875,  1880,  1882,  1887,  1889,  1890,  1892,
     1075    1897,  1899,  1901,  1906,  1908,  1913,  1918,  1926,  1932,  1931,
     1076    1945,  1946,  1951,  1952,  1956,  1961,  1966,  1974,  1979,  1990,
     1077    1991,  1996,  1997,  2003,  2004,  2008,  2009,  2010,  2013,  2012,
     1078    2023,  2032,  2038,  2044,  2053,  2059,  2065,  2071,  2077,  2085,
     1079    2091,  2099,  2105,  2114,  2115,  2116,  2120,  2124,  2126,  2131,
     1080    2132,  2136,  2137,  2142,  2148,  2149,  2152,  2154,  2155,  2159,
     1081    2160,  2161,  2162,  2196,  2198,  2199,  2201,  2206,  2211,  2216,
     1082    2218,  2220,  2225,  2227,  2229,  2231,  2236,  2238,  2247,  2249,
     1083    2250,  2255,  2257,  2259,  2264,  2266,  2268,  2273,  2275,  2277,
     1084    2286,  2287,  2288,  2292,  2294,  2296,  2301,  2303,  2305,  2310,
     1085    2312,  2314,  2329,  2331,  2332,  2334,  2339,  2340,  2345,  2347,
     1086    2349,  2354,  2356,  2358,  2360,  2365,  2367,  2369,  2379,  2381,
     1087    2382,  2384,  2389,  2391,  2393,  2398,  2400,  2402,  2404,  2409,
     1088    2411,  2413,  2444,  2446,  2447,  2449,  2454,  2459,  2467,  2469,
     1089    2471,  2476,  2478,  2483,  2485,  2499,  2500,  2502,  2507,  2509,
     1090    2511,  2513,  2515,  2520,  2521,  2523,  2525,  2530,  2532,  2534,
     1091    2540,  2542,  2544,  2548,  2550,  2552,  2554,  2568,  2569,  2571,
     1092    2576,  2578,  2580,  2582,  2584,  2589,  2590,  2592,  2594,  2599,
     1093    2601,  2603,  2609,  2610,  2612,  2621,  2624,  2626,  2629,  2631,
     1094    2633,  2646,  2647,  2649,  2654,  2656,  2658,  2660,  2662,  2667,
     1095    2668,  2670,  2672,  2677,  2679,  2687,  2688,  2689,  2694,  2695,
     1096    2699,  2701,  2703,  2705,  2707,  2709,  2716,  2718,  2720,  2722,
     1097    2724,  2727,  2729,  2731,  2733,  2735,  2740,  2742,  2744,  2749,
     1098    2775,  2776,  2778,  2782,  2783,  2787,  2789,  2791,  2793,  2795,
     1099    2797,  2804,  2806,  2808,  2810,  2812,  2814,  2819,  2824,  2826,
     1100    2828,  2846,  2848,  2853,  2854
    11011101};
    11021102#endif
    … …  
    49774977
    49784978/* Line 1806 of yacc.c  */
    4979 #line 301 "parser.yy"
     4979#line 302 "parser.yy"
    49804980    { typedefTable.enterScope(); }
    49814981    break;
    … …  
    49844984
    49854985/* Line 1806 of yacc.c  */
    4986 #line 305 "parser.yy"
     4986#line 306 "parser.yy"
    49874987    { typedefTable.leaveScope(); }
    49884988    break;
    … …  
    49914991
    49924992/* Line 1806 of yacc.c  */
    4993 #line 312 "parser.yy"
     4993#line 313 "parser.yy"
    49944994    { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
    49954995    break;
    … …  
    49984998
    49994999/* Line 1806 of yacc.c  */
    5000 #line 313 "parser.yy"
     5000#line 314 "parser.yy"
    50015001    { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
    50025002    break;
    … …  
    50055005
    50065006/* Line 1806 of yacc.c  */
    5007 #line 314 "parser.yy"
     5007#line 315 "parser.yy"
    50085008    { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); }
    50095009    break;
    … …  
    50125012
    50135013/* Line 1806 of yacc.c  */
    5014 #line 339 "parser.yy"
     5014#line 340 "parser.yy"
    50155015    { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].str) ); }
    50165016    break;
    … …  
    50195019
    50205020/* Line 1806 of yacc.c  */
    5021 #line 343 "parser.yy"
     5021#line 344 "parser.yy"
    50225022    { (yyval.str) = (yyvsp[(1) - (1)].tok); }
    50235023    break;
    … …  
    50265026
    50275027/* Line 1806 of yacc.c  */
    5028 #line 345 "parser.yy"
     5028#line 346 "parser.yy"
    50295029    {
    50305030                        appendStr( (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].tok) );                                            // append 2nd juxtaposed string to 1st
    … …  
    50375037
    50385038/* Line 1806 of yacc.c  */
    5039 #line 356 "parser.yy"
     5039#line 357 "parser.yy"
    50405040    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    50415041    break;
    … …  
    50445044
    50455045/* Line 1806 of yacc.c  */
    5046 #line 358 "parser.yy"
     5046#line 359 "parser.yy"
    50475047    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    50485048    break;
    … …  
    50515051
    50525052/* Line 1806 of yacc.c  */
    5053 #line 360 "parser.yy"
     5053#line 361 "parser.yy"
    50545054    { (yyval.en) = (yyvsp[(2) - (3)].en); }
    50555055    break;
    … …  
    50585058
    50595059/* Line 1806 of yacc.c  */
    5060 #line 362 "parser.yy"
     5060#line 363 "parser.yy"
    50615061    { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); }
    50625062    break;
    … …  
    50655065
    50665066/* Line 1806 of yacc.c  */
    5067 #line 372 "parser.yy"
     5067#line 373 "parser.yy"
    50685068    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
    50695069    break;
    … …  
    50725072
    50735073/* Line 1806 of yacc.c  */
    5074 #line 374 "parser.yy"
     5074#line 375 "parser.yy"
    50755075    { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
    50765076    break;
    … …  
    50795079
    50805080/* Line 1806 of yacc.c  */
    5081 #line 378 "parser.yy"
     5081#line 379 "parser.yy"
    50825082    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
    50835083    break;
    50845084
    5085   case 27:
    5086 
    5087 /* Line 1806 of yacc.c  */
    5088 #line 380 "parser.yy"
    5089     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
    5090     break;
    5091 
    5092   case 28:
    5093 
    5094 /* Line 1806 of yacc.c  */
    5095 #line 382 "parser.yy"
    5096     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_constantInteger( *(yyvsp[(3) - (3)].tok) ) ) ); }
    5097     break;
    5098 
    50995085  case 29:
    51005086
    51015087/* Line 1806 of yacc.c  */
    5102 #line 384 "parser.yy"
     5088#line 383 "parser.yy"
    51035089    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
    51045090    break;
    51055091
    5106   case 30:
     5092  case 31:
    51075093
    51085094/* Line 1806 of yacc.c  */
    51095095#line 386 "parser.yy"
    5110     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
    5111     break;
    5112 
    5113   case 31:
     5096    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
     5097    break;
     5098
     5099  case 32:
    51145100
    51155101/* Line 1806 of yacc.c  */
    51165102#line 388 "parser.yy"
    5117     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
    5118     break;
    5119 
    5120   case 32:
     5103    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
     5104    break;
     5105
     5106  case 33:
    51215107
    51225108/* Line 1806 of yacc.c  */
    51235109#line 390 "parser.yy"
    5124     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
    5125     break;
    5126 
    5127   case 33:
     5110    { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
     5111    break;
     5112
     5113  case 34:
    51285114
    51295115/* Line 1806 of yacc.c  */
    51305116#line 392 "parser.yy"
    5131     { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
    5132     break;
    5133 
    5134   case 34:
    5135 
    5136 /* Line 1806 of yacc.c  */
    5137 #line 394 "parser.yy"
    51385117    {
    51395118                        Token fn;
    … …  
    51465125
    51475126/* Line 1806 of yacc.c  */
    5148 #line 404 "parser.yy"
     5127#line 402 "parser.yy"
    51495128    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
    51505129    break;
    … …  
    51535132
    51545133/* Line 1806 of yacc.c  */
    5155 #line 409 "parser.yy"
     5134#line 407 "parser.yy"
    51565135    { (yyval.en) = 0; }
    51575136    break;
    … …  
    51605139
    51615140/* Line 1806 of yacc.c  */
    5162 #line 415 "parser.yy"
     5141#line 413 "parser.yy"
    51635142    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    51645143    break;
    51655144
     5145  case 41:
     5146
     5147/* Line 1806 of yacc.c  */
     5148#line 420 "parser.yy"
     5149    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     5150    break;
     5151
    51665152  case 42:
    51675153
    51685154/* Line 1806 of yacc.c  */
    5169 #line 423 "parser.yy"
    5170     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), maybeMoveBuild<Expression>( (yyvsp[(3) - (3)].en) ) ) ); }
     5155#line 422 "parser.yy"
     5156    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
    51715157    break;
    51725158
    … …  
    51745160
    51755161/* Line 1806 of yacc.c  */
    5176 #line 425 "parser.yy"
    5177     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
     5162#line 424 "parser.yy"
     5163    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
    51785164    break;
    51795165
    … …  
    51815167
    51825168/* Line 1806 of yacc.c  */
    5183 #line 427 "parser.yy"
    5184     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), maybeMoveBuild<Expression>( (yyvsp[(3) - (3)].en) ) ) ); }
     5169#line 426 "parser.yy"
     5170    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
    51855171    break;
    51865172
    … …  
    51885174
    51895175/* Line 1806 of yacc.c  */
    5190 #line 429 "parser.yy"
    5191     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
    5192     break;
    5193 
    5194   case 46:
    5195 
    5196 /* Line 1806 of yacc.c  */
    5197 #line 434 "parser.yy"
    5198     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    5199     break;
    5200 
    5201   case 47:
    5202 
    5203 /* Line 1806 of yacc.c  */
    5204 #line 437 "parser.yy"
    5205     { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
     5176#line 428 "parser.yy"
     5177    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
    52065178    break;
    52075179
    … …  
    52095181
    52105182/* Line 1806 of yacc.c  */
    5211 #line 445 "parser.yy"
     5183#line 442 "parser.yy"
    52125184    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    52135185    break;
    … …  
    52165188
    52175189/* Line 1806 of yacc.c  */
    5218 #line 447 "parser.yy"
     5190#line 444 "parser.yy"
    52195191    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    52205192    break;
    … …  
    52235195
    52245196/* Line 1806 of yacc.c  */
    5225 #line 449 "parser.yy"
     5197#line 446 "parser.yy"
    52265198    { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
    52275199    break;
    … …  
    52305202
    52315203/* Line 1806 of yacc.c  */
    5232 #line 454 "parser.yy"
     5204#line 451 "parser.yy"
    52335205    {
    52345206                        switch ( (yyvsp[(1) - (2)].op) ) {
    … …  
    52485220
    52495221/* Line 1806 of yacc.c  */
    5250 #line 467 "parser.yy"
     5222#line 464 "parser.yy"
    52515223    { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
    52525224    break;
    … …  
    52555227
    52565228/* Line 1806 of yacc.c  */
    5257 #line 469 "parser.yy"
     5229#line 466 "parser.yy"
    52585230    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
    52595231    break;
    … …  
    52625234
    52635235/* Line 1806 of yacc.c  */
    5264 #line 471 "parser.yy"
     5236#line 468 "parser.yy"
    52655237    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
    52665238    break;
    … …  
    52695241
    52705242/* Line 1806 of yacc.c  */
    5271 #line 473 "parser.yy"
     5243#line 470 "parser.yy"
    52725244    { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    52735245    break;
    … …  
    52765248
    52775249/* Line 1806 of yacc.c  */
    5278 #line 475 "parser.yy"
     5250#line 472 "parser.yy"
    52795251    { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52805252    break;
    … …  
    52835255
    52845256/* Line 1806 of yacc.c  */
    5285 #line 477 "parser.yy"
     5257#line 474 "parser.yy"
    52865258    { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    52875259    break;
    … …  
    52905262
    52915263/* Line 1806 of yacc.c  */
    5292 #line 479 "parser.yy"
     5264#line 476 "parser.yy"
    52935265    { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52945266    break;
    … …  
    52975269
    52985270/* Line 1806 of yacc.c  */
    5299 #line 481 "parser.yy"
     5271#line 478 "parser.yy"
    53005272    { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
    53015273    break;
    … …  
    53045276
    53055277/* Line 1806 of yacc.c  */
    5306 #line 483 "parser.yy"
     5278#line 480 "parser.yy"
    53075279    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
    53085280    break;
    … …  
    53115283
    53125284/* Line 1806 of yacc.c  */
    5313 #line 485 "parser.yy"
     5285#line 482 "parser.yy"
    53145286    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
    53155287    break;
    … …  
    53185290
    53195291/* Line 1806 of yacc.c  */
    5320 #line 487 "parser.yy"
     5292#line 484 "parser.yy"
    53215293    { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
    53225294    break;
    … …  
    53255297
    53265298/* Line 1806 of yacc.c  */
    5327 #line 493 "parser.yy"
     5299#line 490 "parser.yy"
    53285300    { (yyval.op) = OperKinds::PointTo; }
    53295301    break;
    … …  
    53325304
    53335305/* Line 1806 of yacc.c  */
    5334 #line 494 "parser.yy"
     5306#line 491 "parser.yy"
    53355307    { (yyval.op) = OperKinds::AddressOf; }
    53365308    break;
    … …  
    53395311
    53405312/* Line 1806 of yacc.c  */
     5313#line 497 "parser.yy"
     5314    { (yyval.op) = OperKinds::UnPlus; }
     5315    break;
     5316
     5317  case 67:
     5318
     5319/* Line 1806 of yacc.c  */
     5320#line 498 "parser.yy"
     5321    { (yyval.op) = OperKinds::UnMinus; }
     5322    break;
     5323
     5324  case 68:
     5325
     5326/* Line 1806 of yacc.c  */
     5327#line 499 "parser.yy"
     5328    { (yyval.op) = OperKinds::Neg; }
     5329    break;
     5330
     5331  case 69:
     5332
     5333/* Line 1806 of yacc.c  */
    53415334#line 500 "parser.yy"
    5342     { (yyval.op) = OperKinds::UnPlus; }
    5343     break;
    5344 
    5345   case 67:
    5346 
    5347 /* Line 1806 of yacc.c  */
    5348 #line 501 "parser.yy"
    5349     { (yyval.op) = OperKinds::UnMinus; }
    5350     break;
    5351 
    5352   case 68:
    5353 
    5354 /* Line 1806 of yacc.c  */
    5355 #line 502 "parser.yy"
    5356     { (yyval.op) = OperKinds::Neg; }
    5357     break;
    5358 
    5359   case 69:
    5360 
    5361 /* Line 1806 of yacc.c  */
    5362 #line 503 "parser.yy"
    53635335    { (yyval.op) = OperKinds::BitNeg; }
    53645336    break;
    … …  
    53675339
    53685340/* Line 1806 of yacc.c  */
    5369 #line 509 "parser.yy"
     5341#line 506 "parser.yy"
    53705342    { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
    53715343    break;
    … …  
    53745346
    53755347/* Line 1806 of yacc.c  */
    5376 #line 511 "parser.yy"
     5348#line 508 "parser.yy"
    53775349    { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
    53785350    break;
    … …  
    53815353
    53825354/* Line 1806 of yacc.c  */
    5383 #line 517 "parser.yy"
     5355#line 514 "parser.yy"
    53845356    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53855357    break;
    … …  
    53885360
    53895361/* Line 1806 of yacc.c  */
    5390 #line 519 "parser.yy"
     5362#line 516 "parser.yy"
    53915363    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53925364    break;
    … …  
    53955367
    53965368/* Line 1806 of yacc.c  */
    5397 #line 521 "parser.yy"
     5369#line 518 "parser.yy"
    53985370    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53995371    break;
    … …  
    54025374
    54035375/* Line 1806 of yacc.c  */
    5404 #line 527 "parser.yy"
     5376#line 524 "parser.yy"
    54055377    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54065378    break;
    … …  
    54095381
    54105382/* Line 1806 of yacc.c  */
    5411 #line 529 "parser.yy"
     5383#line 526 "parser.yy"
    54125384    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54135385    break;
    … …  
    54165388
    54175389/* Line 1806 of yacc.c  */
    5418 #line 535 "parser.yy"
     5390#line 532 "parser.yy"
    54195391    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54205392    break;
    … …  
    54235395
    54245396/* Line 1806 of yacc.c  */
    5425 #line 537 "parser.yy"
     5397#line 534 "parser.yy"
    54265398    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54275399    break;
    … …  
    54305402
    54315403/* Line 1806 of yacc.c  */
    5432 #line 543 "parser.yy"
     5404#line 540 "parser.yy"
    54335405    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54345406    break;
    … …  
    54375409
    54385410/* Line 1806 of yacc.c  */
    5439 #line 545 "parser.yy"
     5411#line 542 "parser.yy"
    54405412    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54415413    break;
    … …  
    54445416
    54455417/* Line 1806 of yacc.c  */
    5446 #line 547 "parser.yy"
     5418#line 544 "parser.yy"
    54475419    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54485420    break;
    … …  
    54515423
    54525424/* Line 1806 of yacc.c  */
    5453 #line 549 "parser.yy"
     5425#line 546 "parser.yy"
    54545426    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54555427    break;
    … …  
    54585430
    54595431/* Line 1806 of yacc.c  */
    5460 #line 555 "parser.yy"
     5432#line 552 "parser.yy"
    54615433    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54625434    break;
    … …  
    54655437
    54665438/* Line 1806 of yacc.c  */
    5467 #line 557 "parser.yy"
     5439#line 554 "parser.yy"
    54685440    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54695441    break;
    … …  
    54725444
    54735445/* Line 1806 of yacc.c  */
    5474 #line 563 "parser.yy"
     5446#line 560 "parser.yy"
    54755447    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54765448    break;
    … …  
    54795451
    54805452/* Line 1806 of yacc.c  */
    5481 #line 569 "parser.yy"
     5453#line 566 "parser.yy"
    54825454    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54835455    break;
    … …  
    54865458
    54875459/* Line 1806 of yacc.c  */
    5488 #line 575 "parser.yy"
     5460#line 572 "parser.yy"
    54895461    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54905462    break;
    … …  
    54935465
    54945466/* Line 1806 of yacc.c  */
    5495 #line 581 "parser.yy"
     5467#line 578 "parser.yy"
    54965468    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
    54975469    break;
    … …  
    55005472
    55015473/* Line 1806 of yacc.c  */
    5502 #line 587 "parser.yy"
     5474#line 584 "parser.yy"
    55035475    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
    55045476    break;
    … …  
    55075479
    55085480/* Line 1806 of yacc.c  */
     5481#line 590 "parser.yy"
     5482    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     5483    break;
     5484
     5485  case 103:
     5486
     5487/* Line 1806 of yacc.c  */
    55095488#line 593 "parser.yy"
     5489    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
     5490    break;
     5491
     5492  case 104:
     5493
     5494/* Line 1806 of yacc.c  */
     5495#line 595 "parser.yy"
    55105496    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    55115497    break;
    55125498
    5513   case 103:
    5514 
    5515 /* Line 1806 of yacc.c  */
    5516 #line 596 "parser.yy"
    5517     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
    5518     break;
    5519 
    5520   case 104:
    5521 
    5522 /* Line 1806 of yacc.c  */
    5523 #line 598 "parser.yy"
    5524     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    5525     break;
    5526 
    55275499  case 107:
    55285500
    55295501/* Line 1806 of yacc.c  */
    5530 #line 609 "parser.yy"
     5502#line 606 "parser.yy"
    55315503    { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    55325504    break;
    … …  
    55355507
    55365508/* Line 1806 of yacc.c  */
    5537 #line 611 "parser.yy"
     5509#line 608 "parser.yy"
    55385510    { (yyval.en) = ( (yyvsp[(2) - (2)].en) == 0 ) ? (yyvsp[(1) - (2)].en) : new ExpressionNode( build_binary_ptr( OperKinds::Assign, (yyvsp[(1) - (2)].en), (yyvsp[(2) - (2)].en) ) ); }
    55395511    break;
    … …  
    55425514
    55435515/* Line 1806 of yacc.c  */
    5544 #line 616 "parser.yy"
     5516#line 613 "parser.yy"
    55455517    { (yyval.en) = nullptr; }
    55465518    break;
    … …  
    55495521
    55505522/* Line 1806 of yacc.c  */
     5523#line 618 "parser.yy"
     5524    { (yyval.op) = OperKinds::Assign; }
     5525    break;
     5526
     5527  case 112:
     5528
     5529/* Line 1806 of yacc.c  */
     5530#line 619 "parser.yy"
     5531    { (yyval.op) = OperKinds::AtAssn; }
     5532    break;
     5533
     5534  case 113:
     5535
     5536/* Line 1806 of yacc.c  */
     5537#line 620 "parser.yy"
     5538    { (yyval.op) = OperKinds::MulAssn; }
     5539    break;
     5540
     5541  case 114:
     5542
     5543/* Line 1806 of yacc.c  */
    55515544#line 621 "parser.yy"
    5552     { (yyval.op) = OperKinds::Assign; }
    5553     break;
    5554 
    5555   case 112:
     5545    { (yyval.op) = OperKinds::DivAssn; }
     5546    break;
     5547
     5548  case 115:
    55565549
    55575550/* Line 1806 of yacc.c  */
    55585551#line 622 "parser.yy"
    5559     { (yyval.op) = OperKinds::AtAssn; }
    5560     break;
    5561 
    5562   case 113:
     5552    { (yyval.op) = OperKinds::ModAssn; }
     5553    break;
     5554
     5555  case 116:
    55635556
    55645557/* Line 1806 of yacc.c  */
    55655558#line 623 "parser.yy"
    5566     { (yyval.op) = OperKinds::MulAssn; }
    5567     break;
    5568 
    5569   case 114:
     5559    { (yyval.op) = OperKinds::PlusAssn; }
     5560    break;
     5561
     5562  case 117:
    55705563
    55715564/* Line 1806 of yacc.c  */
    55725565#line 624 "parser.yy"
    5573     { (yyval.op) = OperKinds::DivAssn; }
    5574     break;
    5575 
    5576   case 115:
     5566    { (yyval.op) = OperKinds::MinusAssn; }
     5567    break;
     5568
     5569  case 118:
    55775570
    55785571/* Line 1806 of yacc.c  */
    55795572#line 625 "parser.yy"
    5580     { (yyval.op) = OperKinds::ModAssn; }
    5581     break;
    5582 
    5583   case 116:
     5573    { (yyval.op) = OperKinds::LSAssn; }
     5574    break;
     5575
     5576  case 119:
    55845577
    55855578/* Line 1806 of yacc.c  */
    55865579#line 626 "parser.yy"
    5587     { (yyval.op) = OperKinds::PlusAssn; }
    5588     break;
    5589 
    5590   case 117:
     5580    { (yyval.op) = OperKinds::RSAssn; }
     5581    break;
     5582
     5583  case 120:
    55915584
    55925585/* Line 1806 of yacc.c  */
    55935586#line 627 "parser.yy"
    5594     { (yyval.op) = OperKinds::MinusAssn; }
    5595     break;
    5596 
    5597   case 118:
     5587    { (yyval.op) = OperKinds::AndAssn; }
     5588    break;
     5589
     5590  case 121:
    55985591
    55995592/* Line 1806 of yacc.c  */
    56005593#line 628 "parser.yy"
    5601     { (yyval.op) = OperKinds::LSAssn; }
    5602     break;
    5603 
    5604   case 119:
     5594    { (yyval.op) = OperKinds::ERAssn; }
     5595    break;
     5596
     5597  case 122:
    56055598
    56065599/* Line 1806 of yacc.c  */
    56075600#line 629 "parser.yy"
    5608     { (yyval.op) = OperKinds::RSAssn; }
    5609     break;
    5610 
    5611   case 120:
    5612 
    5613 /* Line 1806 of yacc.c  */
    5614 #line 630 "parser.yy"
    5615     { (yyval.op) = OperKinds::AndAssn; }
    5616     break;
    5617 
    5618   case 121:
    5619 
    5620 /* Line 1806 of yacc.c  */
    5621 #line 631 "parser.yy"
    5622     { (yyval.op) = OperKinds::ERAssn; }
    5623     break;
    5624 
    5625   case 122:
    5626 
    5627 /* Line 1806 of yacc.c  */
    5628 #line 632 "parser.yy"
    56295601    { (yyval.op) = OperKinds::OrAssn; }
    56305602    break;
    … …  
    56335605
    56345606/* Line 1806 of yacc.c  */
    5635 #line 639 "parser.yy"
     5607#line 636 "parser.yy"
    56365608    { (yyval.en) = new ExpressionNode( build_tuple() ); }
    56375609    break;
    … …  
    56405612
    56415613/* Line 1806 of yacc.c  */
    5642 #line 641 "parser.yy"
     5614#line 638 "parser.yy"
    56435615    { (yyval.en) = new ExpressionNode( build_tuple( (yyvsp[(3) - (5)].en) ) ); }
    56445616    break;
    … …  
    56475619
    56485620/* Line 1806 of yacc.c  */
    5649 #line 643 "parser.yy"
     5621#line 640 "parser.yy"
    56505622    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); }
    56515623    break;
    … …  
    56545626
    56555627/* Line 1806 of yacc.c  */
    5656 #line 645 "parser.yy"
     5628#line 642 "parser.yy"
    56575629    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
    56585630    break;
    … …  
    56615633
    56625634/* Line 1806 of yacc.c  */
    5663 #line 651 "parser.yy"
     5635#line 648 "parser.yy"
    56645636    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    56655637    break;
    … …  
    56685640
    56695641/* Line 1806 of yacc.c  */
    5670 #line 657 "parser.yy"
     5642#line 654 "parser.yy"
    56715643    { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    56725644    break;
    … …  
    56755647
    56765648/* Line 1806 of yacc.c  */
    5677 #line 662 "parser.yy"
     5649#line 659 "parser.yy"
    56785650    { (yyval.en) = 0; }
    56795651    break;
    … …  
    56825654
    56835655/* Line 1806 of yacc.c  */
    5684 #line 671 "parser.yy"
     5656#line 668 "parser.yy"
    56855657    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    56865658    break;
    … …  
    56895661
    56905662/* Line 1806 of yacc.c  */
    5691 #line 678 "parser.yy"
     5663#line 675 "parser.yy"
    56925664    {
    56935665                        Token fn;
    … …  
    57005672
    57015673/* Line 1806 of yacc.c  */
    5702 #line 688 "parser.yy"
     5674#line 685 "parser.yy"
    57035675    {
    57045676                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
    … …  
    57095681
    57105682/* Line 1806 of yacc.c  */
    5711 #line 695 "parser.yy"
     5683#line 692 "parser.yy"
    57125684    { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); }
    57135685    break;
    … …  
    57165688
    57175689/* Line 1806 of yacc.c  */
    5718 #line 702 "parser.yy"
     5690#line 699 "parser.yy"
    57195691    { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); }
    57205692    break;
    … …  
    57235695
    57245696/* Line 1806 of yacc.c  */
    5725 #line 708 "parser.yy"
     5697#line 705 "parser.yy"
    57265698    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    57275699    break;
    … …  
    57305702
    57315703/* Line 1806 of yacc.c  */
    5732 #line 713 "parser.yy"
     5704#line 710 "parser.yy"
    57335705    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57345706    break;
    … …  
    57375709
    57385710/* Line 1806 of yacc.c  */
    5739 #line 715 "parser.yy"
     5711#line 712 "parser.yy"
    57405712    {   // mark all fields in list
    57415713                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
    … …  
    57485720
    57495721/* Line 1806 of yacc.c  */
    5750 #line 721 "parser.yy"
     5722#line 718 "parser.yy"
    57515723    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    57525724    break;
    … …  
    57555727
    57565728/* Line 1806 of yacc.c  */
    5757 #line 728 "parser.yy"
     5729#line 725 "parser.yy"
    57585730    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    57595731    break;
    … …  
    57625734
    57635735/* Line 1806 of yacc.c  */
    5764 #line 733 "parser.yy"
     5736#line 730 "parser.yy"
    57655737    { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); }
    57665738    break;
    … …  
    57695741
    57705742/* Line 1806 of yacc.c  */
    5771 #line 739 "parser.yy"
     5743#line 736 "parser.yy"
    57725744    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
    57735745    break;
    … …  
    57765748
    57775749/* Line 1806 of yacc.c  */
    5778 #line 741 "parser.yy"
     5750#line 738 "parser.yy"
    57795751    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
    57805752    break;
    … …  
    57835755
    57845756/* Line 1806 of yacc.c  */
    5785 #line 743 "parser.yy"
     5757#line 740 "parser.yy"
    57865758    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    57875759    break;
    … …  
    57905762
    57915763/* Line 1806 of yacc.c  */
    5792 #line 745 "parser.yy"
     5764#line 742 "parser.yy"
    57935765    {
    57945766                        StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
    … …  
    58055777
    58065778/* Line 1806 of yacc.c  */
    5807 #line 755 "parser.yy"
     5779#line 752 "parser.yy"
    58085780    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    58095781    break;
    … …  
    58125784
    58135785/* Line 1806 of yacc.c  */
    5814 #line 757 "parser.yy"
     5786#line 754 "parser.yy"
    58155787    {
    58165788                        StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
    … …  
    58225794
    58235795/* Line 1806 of yacc.c  */
    5824 #line 767 "parser.yy"
     5796#line 764 "parser.yy"
    58255797    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    58265798    break;
    … …  
    58295801
    58305802/* Line 1806 of yacc.c  */
    5831 #line 769 "parser.yy"
     5803#line 766 "parser.yy"
    58325804    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    58335805    break;
    … …  
    58365808
    58375809/* Line 1806 of yacc.c  */
    5838 #line 774 "parser.yy"
     5810#line 771 "parser.yy"
    58395811    { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
    58405812    break;
    … …  
    58435815
    58445816/* Line 1806 of yacc.c  */
    5845 #line 776 "parser.yy"
     5817#line 773 "parser.yy"
    58465818    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
    58475819    break;
    … …  
    58505822
    58515823/* Line 1806 of yacc.c  */
    5852 #line 780 "parser.yy"
     5824#line 777 "parser.yy"
    58535825    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    58545826    break;
    … …  
    58575829
    58585830/* Line 1806 of yacc.c  */
    5859 #line 781 "parser.yy"
     5831#line 778 "parser.yy"
    58605832    { (yyval.sn) = new StatementNode( build_default() ); }
    58615833    break;
    … …  
    58645836
    58655837/* Line 1806 of yacc.c  */
    5866 #line 787 "parser.yy"
     5838#line 784 "parser.yy"
    58675839    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); }
    58685840    break;
    … …  
    58715843
    58725844/* Line 1806 of yacc.c  */
    5873 #line 791 "parser.yy"
     5845#line 788 "parser.yy"
    58745846    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
    58755847    break;
    … …  
    58785850
    58795851/* Line 1806 of yacc.c  */
    5880 #line 796 "parser.yy"
     5852#line 793 "parser.yy"
    58815853    { (yyval.sn) = 0; }
    58825854    break;
    … …  
    58855857
    58865858/* Line 1806 of yacc.c  */
    5887 #line 802 "parser.yy"
     5859#line 799 "parser.yy"
    58885860    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
    58895861    break;
    … …  
    58925864
    58935865/* Line 1806 of yacc.c  */
    5894 #line 804 "parser.yy"
     5866#line 801 "parser.yy"
    58955867    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); }
    58965868    break;
    … …  
    58995871
    59005872/* Line 1806 of yacc.c  */
    5901 #line 809 "parser.yy"
     5873#line 806 "parser.yy"
    59025874    { (yyval.sn) = 0; }
    59035875    break;
    … …  
    59065878
    59075879/* Line 1806 of yacc.c  */
    5908 #line 815 "parser.yy"
     5880#line 812 "parser.yy"
    59095881    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    59105882    break;
    … …  
    59135885
    59145886/* Line 1806 of yacc.c  */
    5915 #line 817 "parser.yy"
     5887#line 814 "parser.yy"
    59165888    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    59175889    break;
    … …  
    59205892
    59215893/* Line 1806 of yacc.c  */
    5922 #line 819 "parser.yy"
     5894#line 816 "parser.yy"
    59235895    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    59245896    break;
    … …  
    59275899
    59285900/* Line 1806 of yacc.c  */
    5929 #line 821 "parser.yy"
     5901#line 818 "parser.yy"
    59305902    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (4)].sn)->set_last( (yyvsp[(2) - (4)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(3) - (4)].sn)->set_last( (yyvsp[(4) - (4)].sn) ) ) ) ) ) ); }
    59315903    break;
    … …  
    59345906
    59355907/* Line 1806 of yacc.c  */
    5936 #line 826 "parser.yy"
     5908#line 823 "parser.yy"
    59375909    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
    59385910    break;
    … …  
    59415913
    59425914/* Line 1806 of yacc.c  */
    5943 #line 832 "parser.yy"
     5915#line 829 "parser.yy"
    59445916    { (yyval.sn) = 0; }
    59455917    break;
    … …  
    59485920
    59495921/* Line 1806 of yacc.c  */
    5950 #line 834 "parser.yy"
     5922#line 831 "parser.yy"
    59515923    { (yyval.sn) = 0; }
    59525924    break;
    … …  
    59555927
    59565928/* Line 1806 of yacc.c  */
    5957 #line 839 "parser.yy"
     5929#line 836 "parser.yy"
    59585930    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    59595931    break;
    … …  
    59625934
    59635935/* Line 1806 of yacc.c  */
    5964 #line 841 "parser.yy"
     5936#line 838 "parser.yy"
    59655937    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); }
    59665938    break;
    … …  
    59695941
    59705942/* Line 1806 of yacc.c  */
    5971 #line 843 "parser.yy"
     5943#line 840 "parser.yy"
    59725944    { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
    59735945    break;
    … …  
    59765948
    59775949/* Line 1806 of yacc.c  */
    5978 #line 848 "parser.yy"
     5950#line 845 "parser.yy"
    59795951    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    59805952    break;
    … …  
    59835955
    59845956/* Line 1806 of yacc.c  */
    5985 #line 850 "parser.yy"
     5957#line 847 "parser.yy"
    59865958    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    59875959    break;
    … …  
    59905962
    59915963/* Line 1806 of yacc.c  */
    5992 #line 855 "parser.yy"
     5964#line 852 "parser.yy"
    59935965    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
    59945966    break;
    … …  
    59975969
    59985970/* Line 1806 of yacc.c  */
     5971#line 856 "parser.yy"
     5972    { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
     5973    break;
     5974
     5975  case 191:
     5976
     5977/* Line 1806 of yacc.c  */
    59995978#line 859 "parser.yy"
    6000     { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
    6001     break;
    6002 
    6003   case 191:
    6004 
    6005 /* Line 1806 of yacc.c  */
    6006 #line 862 "parser.yy"
    60075979    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
    60085980    break;
    … …  
    60115983
    60125984/* Line 1806 of yacc.c  */
     5985#line 863 "parser.yy"
     5986    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
     5987    break;
     5988
     5989  case 193:
     5990
     5991/* Line 1806 of yacc.c  */
    60135992#line 866 "parser.yy"
    6014     { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
    6015     break;
    6016 
    6017   case 193:
    6018 
    6019 /* Line 1806 of yacc.c  */
    6020 #line 869 "parser.yy"
    60215993    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
    60225994    break;
    … …  
    60255997
    60265998/* Line 1806 of yacc.c  */
    6027 #line 873 "parser.yy"
     5999#line 870 "parser.yy"
    60286000    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); }
    60296001    break;
    … …  
    60326004
    60336005/* Line 1806 of yacc.c  */
    6034 #line 875 "parser.yy"
     6006#line 872 "parser.yy"
    60356007    { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
    60366008    break;
    … …  
    60396011
    60406012/* Line 1806 of yacc.c  */
    6041 #line 877 "parser.yy"
     6013#line 874 "parser.yy"
    60426014    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    60436015    break;
    … …  
    60466018
    60476019/* Line 1806 of yacc.c  */
    6048 #line 879 "parser.yy"
     6020#line 876 "parser.yy"
    60496021    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    60506022    break;
    … …  
    60536025
    60546026/* Line 1806 of yacc.c  */
    6055 #line 881 "parser.yy"
     6027#line 878 "parser.yy"
    60566028    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); }
    60576029    break;
    … …  
    60606032
    60616033/* Line 1806 of yacc.c  */
    6062 #line 886 "parser.yy"
     6034#line 883 "parser.yy"
    60636035    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); }
    60646036    break;
    … …  
    60676039
    60686040/* Line 1806 of yacc.c  */
    6069 #line 888 "parser.yy"
     6041#line 885 "parser.yy"
    60706042    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); }
    60716043    break;
    … …  
    60746046
    60756047/* Line 1806 of yacc.c  */
    6076 #line 890 "parser.yy"
     6048#line 887 "parser.yy"
    60776049    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); }
    60786050    break;
    … …  
    60816053
    60826054/* Line 1806 of yacc.c  */
    6083 #line 897 "parser.yy"
     6055#line 894 "parser.yy"
    60846056    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
    60856057    break;
    … …  
    60886060
    60896061/* Line 1806 of yacc.c  */
    6090 #line 899 "parser.yy"
     6062#line 896 "parser.yy"
    60916063    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
    60926064    break;
    … …  
    60956067
    60966068/* Line 1806 of yacc.c  */
    6097 #line 901 "parser.yy"
     6069#line 898 "parser.yy"
    60986070    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
    60996071    break;
    … …  
    61026074
    61036075/* Line 1806 of yacc.c  */
    6104 #line 903 "parser.yy"
     6076#line 900 "parser.yy"
    61056077    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
    61066078    break;
    … …  
    61096081
    61106082/* Line 1806 of yacc.c  */
    6111 #line 908 "parser.yy"
     6083#line 905 "parser.yy"
    61126084    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
    61136085    break;
    … …  
    61166088
    61176089/* Line 1806 of yacc.c  */
    6118 #line 910 "parser.yy"
     6090#line 907 "parser.yy"
    61196091    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
    61206092    break;
    … …  
    61236095
    61246096/* Line 1806 of yacc.c  */
    6125 #line 912 "parser.yy"
     6097#line 909 "parser.yy"
    61266098    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
    61276099    break;
    … …  
    61306102
    61316103/* Line 1806 of yacc.c  */
    6132 #line 914 "parser.yy"
     6104#line 911 "parser.yy"
    61336105    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
    61346106    break;
    … …  
    61376109
    61386110/* Line 1806 of yacc.c  */
    6139 #line 919 "parser.yy"
     6111#line 916 "parser.yy"
    61406112    {
    61416113                        (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) );
    … …  
    61466118
    61476119/* Line 1806 of yacc.c  */
    6148 #line 932 "parser.yy"
     6120#line 929 "parser.yy"
    61496121    {
    61506122                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    61566128
    61576129/* Line 1806 of yacc.c  */
    6158 #line 937 "parser.yy"
     6130#line 934 "parser.yy"
    61596131    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    61606132    break;
    … …  
    61636135
    61646136/* Line 1806 of yacc.c  */
    6165 #line 939 "parser.yy"
     6137#line 936 "parser.yy"
    61666138    {
    61676139                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    61736145
    61746146/* Line 1806 of yacc.c  */
    6175 #line 948 "parser.yy"
     6147#line 945 "parser.yy"
    61766148    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); }
    61776149    break;
    … …  
    61806152
    61816153/* Line 1806 of yacc.c  */
    6182 #line 950 "parser.yy"
     6154#line 947 "parser.yy"
    61836155    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); }
    61846156    break;
    … …  
    61876159
    61886160/* Line 1806 of yacc.c  */
    6189 #line 952 "parser.yy"
     6161#line 949 "parser.yy"
    61906162    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); }
    61916163    break;
    … …  
    61946166
    61956167/* Line 1806 of yacc.c  */
    6196 #line 954 "parser.yy"
     6168#line 951 "parser.yy"
    61976169    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (12)].flag), (yyvsp[(4) - (12)].constant), (yyvsp[(6) - (12)].en), (yyvsp[(8) - (12)].en), (yyvsp[(10) - (12)].en) ) ); }
    61986170    break;
    … …  
    62016173
    62026174/* Line 1806 of yacc.c  */
    6203 #line 956 "parser.yy"
     6175#line 953 "parser.yy"
    62046176    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (14)].flag), (yyvsp[(5) - (14)].constant), 0, (yyvsp[(8) - (14)].en), (yyvsp[(10) - (14)].en), (yyvsp[(12) - (14)].label) ) ); }
    62056177    break;
    … …  
    62086180
    62096181/* Line 1806 of yacc.c  */
    6210 #line 961 "parser.yy"
     6182#line 958 "parser.yy"
    62116183    { (yyval.flag) = false; }
    62126184    break;
    … …  
    62156187
    62166188/* Line 1806 of yacc.c  */
    6217 #line 963 "parser.yy"
     6189#line 960 "parser.yy"
    62186190    { (yyval.flag) = true; }
    62196191    break;
    … …  
    62226194
    62236195/* Line 1806 of yacc.c  */
    6224 #line 968 "parser.yy"
     6196#line 965 "parser.yy"
    62256197    { (yyval.en) = 0; }
    62266198    break;
    … …  
    62296201
    62306202/* Line 1806 of yacc.c  */
    6231 #line 975 "parser.yy"
     6203#line 972 "parser.yy"
    62326204    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    62336205    break;
    … …  
    62366208
    62376209/* Line 1806 of yacc.c  */
    6238 #line 980 "parser.yy"
     6210#line 977 "parser.yy"
    62396211    { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
    62406212    break;
    … …  
    62436215
    62446216/* Line 1806 of yacc.c  */
    6245 #line 982 "parser.yy"
     6217#line 979 "parser.yy"
    62466218    { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
    62476219    break;
    … …  
    62506222
    62516223/* Line 1806 of yacc.c  */
    6252 #line 987 "parser.yy"
     6224#line 984 "parser.yy"
    62536225    { (yyval.en) = 0; }
    62546226    break;
    … …  
    62576229
    62586230/* Line 1806 of yacc.c  */
    6259 #line 989 "parser.yy"
     6231#line 986 "parser.yy"
    62606232    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    62616233    break;
    … …  
    62646236
    62656237/* Line 1806 of yacc.c  */
    6266 #line 991 "parser.yy"
     6238#line 988 "parser.yy"
    62676239    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
    62686240    break;
    … …  
    62716243
    62726244/* Line 1806 of yacc.c  */
    6273 #line 996 "parser.yy"
     6245#line 993 "parser.yy"
    62746246    {
    62756247                        (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) );
    … …  
    62816253
    62826254/* Line 1806 of yacc.c  */
    6283 #line 1001 "parser.yy"
     6255#line 998 "parser.yy"
    62846256    {
    62856257                        (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) );
    … …  
    62916263
    62926264/* Line 1806 of yacc.c  */
    6293 #line 1011 "parser.yy"
     6265#line 1008 "parser.yy"
    62946266    { (yyval.decl) = 0; }
    62956267    break;
    … …  
    62986270
    62996271/* Line 1806 of yacc.c  */
    6300 #line 1018 "parser.yy"
     6272#line 1015 "parser.yy"
    63016273    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    63026274    break;
    … …  
    63056277
    63066278/* Line 1806 of yacc.c  */
    6307 #line 1023 "parser.yy"
     6279#line 1020 "parser.yy"
    63086280    { (yyval.decl) = 0; }
    63096281    break;
    … …  
    63126284
    63136285/* Line 1806 of yacc.c  */
    6314 #line 1030 "parser.yy"
     6286#line 1027 "parser.yy"
    63156287    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    63166288    break;
    … …  
    63196291
    63206292/* Line 1806 of yacc.c  */
    6321 #line 1044 "parser.yy"
     6293#line 1041 "parser.yy"
    63226294    {}
    63236295    break;
    … …  
    63266298
    63276299/* Line 1806 of yacc.c  */
    6328 #line 1045 "parser.yy"
     6300#line 1042 "parser.yy"
    63296301    {}
    63306302    break;
    … …  
    63336305
    63346306/* Line 1806 of yacc.c  */
    6335 #line 1074 "parser.yy"
     6307#line 1071 "parser.yy"
    63366308    {
    63376309                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    63436315
    63446316/* Line 1806 of yacc.c  */
    6345 #line 1081 "parser.yy"
     6317#line 1078 "parser.yy"
    63466318    {
    63476319                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    63536325
    63546326/* Line 1806 of yacc.c  */
    6355 #line 1086 "parser.yy"
     6327#line 1083 "parser.yy"
    63566328    {
    63576329                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
    … …  
    63636335
    63646336/* Line 1806 of yacc.c  */
    6365 #line 1096 "parser.yy"
     6337#line 1093 "parser.yy"
    63666338    {
    63676339                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
    … …  
    63736345
    63746346/* Line 1806 of yacc.c  */
    6375 #line 1101 "parser.yy"
     6347#line 1098 "parser.yy"
    63766348    {
    63776349                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
    … …  
    63836355
    63846356/* Line 1806 of yacc.c  */
    6385 #line 1106 "parser.yy"
     6357#line 1103 "parser.yy"
    63866358    {
    63876359                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
    … …  
    63936365
    63946366/* Line 1806 of yacc.c  */
    6395 #line 1114 "parser.yy"
     6367#line 1111 "parser.yy"
    63966368    {
    63976369                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    64036375
    64046376/* Line 1806 of yacc.c  */
    6405 #line 1119 "parser.yy"
     6377#line 1116 "parser.yy"
    64066378    {
    64076379                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    64136385
    64146386/* Line 1806 of yacc.c  */
    6415 #line 1124 "parser.yy"
     6387#line 1121 "parser.yy"
    64166388    {
    64176389                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    64236395
    64246396/* Line 1806 of yacc.c  */
    6425 #line 1129 "parser.yy"
     6397#line 1126 "parser.yy"
    64266398    {
    64276399                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    64336405
    64346406/* Line 1806 of yacc.c  */
    6435 #line 1134 "parser.yy"
     6407#line 1131 "parser.yy"
    64366408    {
    64376409                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
    … …  
    64436415
    64446416/* Line 1806 of yacc.c  */
    6445 #line 1142 "parser.yy"
     6417#line 1139 "parser.yy"
    64466418    {
    64476419                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(3) - (8)].tok), DeclarationNode::newTuple( 0 ), (yyvsp[(6) - (8)].decl), 0, true );
    … …  
    64526424
    64536425/* Line 1806 of yacc.c  */
    6454 #line 1165 "parser.yy"
     6426#line 1162 "parser.yy"
    64556427    {
    64566428                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
    … …  
    64616433
    64626434/* Line 1806 of yacc.c  */
    6463 #line 1169 "parser.yy"
     6435#line 1166 "parser.yy"
    64646436    {
    64656437                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
    … …  
    64706442
    64716443/* Line 1806 of yacc.c  */
    6472 #line 1176 "parser.yy"
     6444#line 1173 "parser.yy"
    64736445    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    64746446    break;
    … …  
    64776449
    64786450/* Line 1806 of yacc.c  */
    6479 #line 1180 "parser.yy"
     6451#line 1177 "parser.yy"
    64806452    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    64816453    break;
    … …  
    64846456
    64856457/* Line 1806 of yacc.c  */
    6486 #line 1185 "parser.yy"
     6458#line 1182 "parser.yy"
    64876459    {
    64886460                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    64946466
    64956467/* Line 1806 of yacc.c  */
    6496 #line 1190 "parser.yy"
     6468#line 1187 "parser.yy"
    64976469    {
    64986470                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65046476
    65056477/* Line 1806 of yacc.c  */
    6506 #line 1195 "parser.yy"
     6478#line 1192 "parser.yy"
    65076479    {
    65086480                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
    … …  
    65146486
    65156487/* Line 1806 of yacc.c  */
    6516 #line 1206 "parser.yy"
     6488#line 1203 "parser.yy"
    65176489    {
    65186490                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65246496
    65256497/* Line 1806 of yacc.c  */
    6526 #line 1211 "parser.yy"
     6498#line 1208 "parser.yy"
    65276499    {
    65286500                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65346506
    65356507/* Line 1806 of yacc.c  */
    6536 #line 1216 "parser.yy"
     6508#line 1213 "parser.yy"
    65376509    {
    65386510                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65446516
    65456517/* Line 1806 of yacc.c  */
    6546 #line 1221 "parser.yy"
     6518#line 1218 "parser.yy"
    65476519    {
    65486520                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65546526
    65556527/* Line 1806 of yacc.c  */
    6556 #line 1226 "parser.yy"
     6528#line 1223 "parser.yy"
    65576529    {
    65586530                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    65646536
    65656537/* Line 1806 of yacc.c  */
    6566 #line 1235 "parser.yy"
     6538#line 1232 "parser.yy"
    65676539    {
    65686540                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
    … …  
    65746546
    65756547/* Line 1806 of yacc.c  */
    6576 #line 1240 "parser.yy"
     6548#line 1237 "parser.yy"
    65776549    {
    65786550                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
    … …  
    65846556
    65856557/* Line 1806 of yacc.c  */
    6586 #line 1257 "parser.yy"
     6558#line 1254 "parser.yy"
    65876559    {
    65886560                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    65946566
    65956567/* Line 1806 of yacc.c  */
    6596 #line 1262 "parser.yy"
     6568#line 1259 "parser.yy"
    65976569    {
    65986570                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    66046576
    66056577/* Line 1806 of yacc.c  */
    6606 #line 1284 "parser.yy"
     6578#line 1281 "parser.yy"
    66076579    { (yyval.decl) = 0; }
    66086580    break;
    … …  
    66116583
    66126584/* Line 1806 of yacc.c  */
    6613 #line 1296 "parser.yy"
     6585#line 1293 "parser.yy"
    66146586    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66156587    break;
    … …  
    66186590
    66196591/* Line 1806 of yacc.c  */
    6620 #line 1307 "parser.yy"
     6592#line 1304 "parser.yy"
    66216593    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    66226594    break;
    … …  
    66256597
    66266598/* Line 1806 of yacc.c  */
    6627 #line 1309 "parser.yy"
     6599#line 1306 "parser.yy"
    66286600    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    66296601    break;
    … …  
    66326604
    66336605/* Line 1806 of yacc.c  */
    6634 #line 1311 "parser.yy"
     6606#line 1308 "parser.yy"
    66356607    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    66366608    break;
    … …  
    66396611
    66406612/* Line 1806 of yacc.c  */
    6641 #line 1313 "parser.yy"
     6613#line 1310 "parser.yy"
    66426614    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    66436615    break;
    … …  
    66466618
    66476619/* Line 1806 of yacc.c  */
    6648 #line 1315 "parser.yy"
     6620#line 1312 "parser.yy"
    66496621    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    66506622    break;
    … …  
    66536625
    66546626/* Line 1806 of yacc.c  */
    6655 #line 1317 "parser.yy"
     6627#line 1314 "parser.yy"
    66566628    {
    66576629                        typedefTable.enterScope();
    … …  
    66626634
    66636635/* Line 1806 of yacc.c  */
    6664 #line 1321 "parser.yy"
     6636#line 1318 "parser.yy"
    66656637    {
    66666638                        typedefTable.leaveScope();
    … …  
    66726644
    66736645/* Line 1806 of yacc.c  */
    6674 #line 1330 "parser.yy"
     6646#line 1327 "parser.yy"
    66756647    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66766648    break;
    … …  
    66796651
    66806652/* Line 1806 of yacc.c  */
    6681 #line 1332 "parser.yy"
     6653#line 1329 "parser.yy"
    66826654    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    66836655    break;
    … …  
    66866658
    66876659/* Line 1806 of yacc.c  */
    6688 #line 1343 "parser.yy"
     6660#line 1340 "parser.yy"
    66896661    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    66906662    break;
    … …  
    66936665
    66946666/* Line 1806 of yacc.c  */
    6695 #line 1348 "parser.yy"
     6667#line 1345 "parser.yy"
    66966668    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    66976669    break;
    … …  
    67006672
    67016673/* Line 1806 of yacc.c  */
    6702 #line 1350 "parser.yy"
     6674#line 1347 "parser.yy"
    67036675    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    67046676    break;
    … …  
    67076679
    67086680/* Line 1806 of yacc.c  */
    6709 #line 1352 "parser.yy"
     6681#line 1349 "parser.yy"
    67106682    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    67116683    break;
    … …  
    67146686
    67156687/* Line 1806 of yacc.c  */
     6688#line 1351 "parser.yy"
     6689    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     6690    break;
     6691
     6692  case 318:
     6693
     6694/* Line 1806 of yacc.c  */
    67166695#line 1354 "parser.yy"
    6717     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    6718     break;
    6719 
    6720   case 318:
    6721 
    6722 /* Line 1806 of yacc.c  */
    6723 #line 1357 "parser.yy"
    67246696    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; }
    67256697    break;
    … …  
    67286700
    67296701/* Line 1806 of yacc.c  */
     6702#line 1356 "parser.yy"
     6703    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
     6704    break;
     6705
     6706  case 320:
     6707
     6708/* Line 1806 of yacc.c  */
    67306709#line 1359 "parser.yy"
    6731     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    6732     break;
    6733 
    6734   case 320:
    6735 
    6736 /* Line 1806 of yacc.c  */
    6737 #line 1362 "parser.yy"
    67386710    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; }
    67396711    break;
    … …  
    67426714
    67436715/* Line 1806 of yacc.c  */
    6744 #line 1364 "parser.yy"
     6716#line 1361 "parser.yy"
    67456717    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    67466718    break;
    … …  
    67496721
    67506722/* Line 1806 of yacc.c  */
    6751 #line 1369 "parser.yy"
     6723#line 1366 "parser.yy"
    67526724    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    67536725    break;
    … …  
    67566728
    67576729/* Line 1806 of yacc.c  */
    6758 #line 1371 "parser.yy"
     6730#line 1368 "parser.yy"
    67596731    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    67606732    break;
    … …  
    67636735
    67646736/* Line 1806 of yacc.c  */
    6765 #line 1373 "parser.yy"
     6737#line 1370 "parser.yy"
    67666738    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    67676739    break;
    … …  
    67706742
    67716743/* Line 1806 of yacc.c  */
    6772 #line 1375 "parser.yy"
     6744#line 1372 "parser.yy"
    67736745    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    67746746    break;
    … …  
    67776749
    67786750/* Line 1806 of yacc.c  */
    6779 #line 1377 "parser.yy"
     6751#line 1374 "parser.yy"
    67806752    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
    67816753    break;
    … …  
    67846756
    67856757/* Line 1806 of yacc.c  */
    6786 #line 1379 "parser.yy"
     6758#line 1376 "parser.yy"
    67876759    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
    67886760    break;
    … …  
    67916763
    67926764/* Line 1806 of yacc.c  */
    6793 #line 1381 "parser.yy"
     6765#line 1378 "parser.yy"
    67946766    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
    67956767    break;
    … …  
    67986770
    67996771/* Line 1806 of yacc.c  */
    6800 #line 1383 "parser.yy"
     6772#line 1380 "parser.yy"
    68016773    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
    68026774    break;
    … …  
    68056777
    68066778/* Line 1806 of yacc.c  */
    6807 #line 1385 "parser.yy"
     6779#line 1382 "parser.yy"
    68086780    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    68096781    break;
    … …  
    68126784
    68136785/* Line 1806 of yacc.c  */
    6814 #line 1387 "parser.yy"
     6786#line 1384 "parser.yy"
    68156787    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    68166788    break;
    … …  
    68196791
    68206792/* Line 1806 of yacc.c  */
    6821 #line 1389 "parser.yy"
     6793#line 1386 "parser.yy"
    68226794    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
    68236795    break;
    … …  
    68266798
    68276799/* Line 1806 of yacc.c  */
    6828 #line 1391 "parser.yy"
     6800#line 1388 "parser.yy"
    68296801    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
    68306802    break;
    … …  
    68336805
    68346806/* Line 1806 of yacc.c  */
    6835 #line 1393 "parser.yy"
     6807#line 1390 "parser.yy"
    68366808    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    68376809    break;
    … …  
    68406812
    68416813/* Line 1806 of yacc.c  */
    6842 #line 1400 "parser.yy"
     6814#line 1397 "parser.yy"
    68436815    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68446816    break;
    … …  
    68476819
    68486820/* Line 1806 of yacc.c  */
    6849 #line 1402 "parser.yy"
     6821#line 1399 "parser.yy"
    68506822    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68516823    break;
    … …  
    68546826
    68556827/* Line 1806 of yacc.c  */
    6856 #line 1404 "parser.yy"
     6828#line 1401 "parser.yy"
    68576829    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68586830    break;
    … …  
    68616833
    68626834/* Line 1806 of yacc.c  */
    6863 #line 1406 "parser.yy"
     6835#line 1403 "parser.yy"
    68646836    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    68656837    break;
    … …  
    68686840
    68696841/* Line 1806 of yacc.c  */
    6870 #line 1412 "parser.yy"
     6842#line 1409 "parser.yy"
    68716843    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68726844    break;
    … …  
    68756847
    68766848/* Line 1806 of yacc.c  */
    6877 #line 1419 "parser.yy"
     6849#line 1416 "parser.yy"
    68786850    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68796851    break;
    … …  
    68826854
    68836855/* Line 1806 of yacc.c  */
    6884 #line 1421 "parser.yy"
     6856#line 1418 "parser.yy"
    68856857    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68866858    break;
    … …  
    68896861
    68906862/* Line 1806 of yacc.c  */
    6891 #line 1423 "parser.yy"
     6863#line 1420 "parser.yy"
    68926864    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    68936865    break;
    … …  
    68966868
    68976869/* Line 1806 of yacc.c  */
    6898 #line 1428 "parser.yy"
     6870#line 1425 "parser.yy"
    68996871    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    69006872    break;
    … …  
    69036875
    69046876/* Line 1806 of yacc.c  */
    6905 #line 1430 "parser.yy"
     6877#line 1427 "parser.yy"
    69066878    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    69076879    break;
    … …  
    69106882
    69116883/* Line 1806 of yacc.c  */
    6912 #line 1432 "parser.yy"
     6884#line 1429 "parser.yy"
    69136885    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    69146886    break;
    … …  
    69176889
    69186890/* Line 1806 of yacc.c  */
    6919 #line 1434 "parser.yy"
     6891#line 1431 "parser.yy"
    69206892    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    69216893    break;
    … …  
    69246896
    69256897/* Line 1806 of yacc.c  */
    6926 #line 1440 "parser.yy"
     6898#line 1437 "parser.yy"
    69276899    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69286900    break;
    … …  
    69316903
    69326904/* Line 1806 of yacc.c  */
    6933 #line 1442 "parser.yy"
     6905#line 1439 "parser.yy"
    69346906    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69356907    break;
    … …  
    69386910
    69396911/* Line 1806 of yacc.c  */
    6940 #line 1444 "parser.yy"
     6912#line 1441 "parser.yy"
    69416913    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    69426914    break;
    … …  
    69456917
    69466918/* Line 1806 of yacc.c  */
    6947 #line 1450 "parser.yy"
     6919#line 1447 "parser.yy"
    69486920    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69496921    break;
    … …  
    69526924
    69536925/* Line 1806 of yacc.c  */
    6954 #line 1452 "parser.yy"
     6926#line 1449 "parser.yy"
    69556927    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69566928    break;
    … …  
    69596931
    69606932/* Line 1806 of yacc.c  */
    6961 #line 1458 "parser.yy"
     6933#line 1455 "parser.yy"
    69626934    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69636935    break;
    … …  
    69666938
    69676939/* Line 1806 of yacc.c  */
    6968 #line 1460 "parser.yy"
     6940#line 1457 "parser.yy"
    69696941    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69706942    break;
    … …  
    69736945
    69746946/* Line 1806 of yacc.c  */
    6975 #line 1462 "parser.yy"
     6947#line 1459 "parser.yy"
    69766948    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    69776949    break;
    … …  
    69806952
    69816953/* Line 1806 of yacc.c  */
    6982 #line 1467 "parser.yy"
     6954#line 1464 "parser.yy"
    69836955    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    69846956    break;
    … …  
    69876959
    69886960/* Line 1806 of yacc.c  */
    6989 #line 1469 "parser.yy"
     6961#line 1466 "parser.yy"
    69906962    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    69916963    break;
    … …  
    69946966
    69956967/* Line 1806 of yacc.c  */
    6996 #line 1471 "parser.yy"
     6968#line 1468 "parser.yy"
    69976969    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    69986970    break;
    … …  
    70016973
    70026974/* Line 1806 of yacc.c  */
    7003 #line 1481 "parser.yy"
     6975#line 1478 "parser.yy"
    70046976    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), nullptr, nullptr, (yyvsp[(3) - (4)].decl), true ); }
    70056977    break;
    … …  
    70086980
    70096981/* Line 1806 of yacc.c  */
    7010 #line 1483 "parser.yy"
     6982#line 1480 "parser.yy"
    70116983    {
    70126984                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
    … …  
    70186990
    70196991/* Line 1806 of yacc.c  */
    7020 #line 1488 "parser.yy"
     6992#line 1485 "parser.yy"
    70216993    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    70226994    break;
    … …  
    70256997
    70266998/* Line 1806 of yacc.c  */
    7027 #line 1490 "parser.yy"
     6999#line 1487 "parser.yy"
    70287000    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); }
    70297001    break;
    … …  
    70327004
    70337005/* Line 1806 of yacc.c  */
    7034 #line 1492 "parser.yy"
     7006#line 1489 "parser.yy"
    70357007    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    70367008    break;
    … …  
    70397011
    70407012/* Line 1806 of yacc.c  */
    7041 #line 1494 "parser.yy"
     7013#line 1491 "parser.yy"
    70427014    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    70437015    break;
    … …  
    70467018
    70477019/* Line 1806 of yacc.c  */
    7048 #line 1499 "parser.yy"
     7020#line 1496 "parser.yy"
    70497021    { (yyval.aggKey) = DeclarationNode::Struct; }
    70507022    break;
    … …  
    70537025
    70547026/* Line 1806 of yacc.c  */
    7055 #line 1501 "parser.yy"
     7027#line 1498 "parser.yy"
    70567028    { (yyval.aggKey) = DeclarationNode::Union; }
    70577029    break;
    … …  
    70607032
    70617033/* Line 1806 of yacc.c  */
    7062 #line 1506 "parser.yy"
     7034#line 1503 "parser.yy"
    70637035    { (yyval.decl) = 0; }
    70647036    break;
    … …  
    70677039
    70687040/* Line 1806 of yacc.c  */
    7069 #line 1508 "parser.yy"
     7041#line 1505 "parser.yy"
    70707042    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    70717043    break;
    … …  
    70747046
    70757047/* Line 1806 of yacc.c  */
     7048#line 1511 "parser.yy"
     7049    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
     7050    break;
     7051
     7052  case 379:
     7053
     7054/* Line 1806 of yacc.c  */
    70767055#line 1514 "parser.yy"
    7077     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    7078     break;
    7079 
    7080   case 379:
    7081 
    7082 /* Line 1806 of yacc.c  */
    7083 #line 1517 "parser.yy"
    70847056    {   // mark all fields in list
    70857057                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
    … …  
    70927064
    70937065/* Line 1806 of yacc.c  */
    7094 #line 1527 "parser.yy"
     7066#line 1524 "parser.yy"
    70957067    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    70967068    break;
    … …  
    70997071
    71007072/* Line 1806 of yacc.c  */
    7101 #line 1529 "parser.yy"
     7073#line 1526 "parser.yy"
    71027074    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    71037075    break;
    … …  
    71067078
    71077079/* Line 1806 of yacc.c  */
    7108 #line 1531 "parser.yy"
     7080#line 1528 "parser.yy"
    71097081    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    71107082    break;
    … …  
    71137085
    71147086/* Line 1806 of yacc.c  */
    7115 #line 1536 "parser.yy"
     7087#line 1533 "parser.yy"
    71167088    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    71177089    break;
    … …  
    71207092
    71217093/* Line 1806 of yacc.c  */
    7122 #line 1538 "parser.yy"
     7094#line 1535 "parser.yy"
    71237095    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    71247096    break;
    … …  
    71277099
    71287100/* Line 1806 of yacc.c  */
    7129 #line 1543 "parser.yy"
     7101#line 1540 "parser.yy"
    71307102    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    71317103    break;
    … …  
    71347106
    71357107/* Line 1806 of yacc.c  */
     7108#line 1542 "parser.yy"
     7109    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
     7110    break;
     7111
     7112  case 388:
     7113
     7114/* Line 1806 of yacc.c  */
    71367115#line 1545 "parser.yy"
    7137     { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    7138     break;
    7139 
    7140   case 388:
     7116    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     7117    break;
     7118
     7119  case 389:
    71417120
    71427121/* Line 1806 of yacc.c  */
    … …  
    71457124    break;
    71467125
    7147   case 389:
    7148 
    7149 /* Line 1806 of yacc.c  */
    7150 #line 1551 "parser.yy"
    7151     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    7152     break;
    7153 
    71547126  case 391:
    71557127
    71567128/* Line 1806 of yacc.c  */
    7157 #line 1557 "parser.yy"
     7129#line 1554 "parser.yy"
    71587130    { (yyval.en) = 0; }
    71597131    break;
    … …  
    71627134
    71637135/* Line 1806 of yacc.c  */
    7164 #line 1559 "parser.yy"
     7136#line 1556 "parser.yy"
    71657137    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    71667138    break;
    … …  
    71697141
    71707142/* Line 1806 of yacc.c  */
    7171 #line 1564 "parser.yy"
     7143#line 1561 "parser.yy"
    71727144    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    71737145    break;
    … …  
    71767148
    71777149/* Line 1806 of yacc.c  */
    7178 #line 1573 "parser.yy"
     7150#line 1570 "parser.yy"
    71797151    { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(3) - (5)].decl) ); }
    71807152    break;
    … …  
    71837155
    71847156/* Line 1806 of yacc.c  */
    7185 #line 1575 "parser.yy"
     7157#line 1572 "parser.yy"
    71867158    {
    71877159                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
    … …  
    71937165
    71947166/* Line 1806 of yacc.c  */
    7195 #line 1580 "parser.yy"
     7167#line 1577 "parser.yy"
    71967168    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    71977169    break;
    … …  
    72007172
    72017173/* Line 1806 of yacc.c  */
    7202 #line 1582 "parser.yy"
     7174#line 1579 "parser.yy"
    72037175    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    72047176    break;
    … …  
    72077179
    72087180/* Line 1806 of yacc.c  */
    7209 #line 1587 "parser.yy"
     7181#line 1584 "parser.yy"
    72107182    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    72117183    break;
    … …  
    72147186
    72157187/* Line 1806 of yacc.c  */
    7216 #line 1589 "parser.yy"
     7188#line 1586 "parser.yy"
    72177189    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    72187190    break;
    … …  
    72217193
    72227194/* Line 1806 of yacc.c  */
    7223 #line 1594 "parser.yy"
     7195#line 1591 "parser.yy"
    72247196    { (yyval.en) = 0; }
    72257197    break;
    … …  
    72287200
    72297201/* Line 1806 of yacc.c  */
    7230 #line 1596 "parser.yy"
     7202#line 1593 "parser.yy"
    72317203    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    72327204    break;
    … …  
    72357207
    72367208/* Line 1806 of yacc.c  */
    7237 #line 1603 "parser.yy"
     7209#line 1600 "parser.yy"
    72387210    { (yyval.decl) = 0; }
    72397211    break;
    … …  
    72427214
    72437215/* Line 1806 of yacc.c  */
    7244 #line 1611 "parser.yy"
     7216#line 1608 "parser.yy"
    72457217    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72467218    break;
    … …  
    72497221
    72507222/* Line 1806 of yacc.c  */
    7251 #line 1613 "parser.yy"
     7223#line 1610 "parser.yy"
    72527224    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72537225    break;
    … …  
    72567228
    72577229/* Line 1806 of yacc.c  */
    7258 #line 1615 "parser.yy"
     7230#line 1612 "parser.yy"
    72597231    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    72607232    break;
    … …  
    72637235
    72647236/* Line 1806 of yacc.c  */
    7265 #line 1623 "parser.yy"
     7237#line 1620 "parser.yy"
    72667238    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72677239    break;
    … …  
    72707242
    72717243/* Line 1806 of yacc.c  */
    7272 #line 1625 "parser.yy"
     7244#line 1622 "parser.yy"
    72737245    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72747246    break;
    … …  
    72777249
    72787250/* Line 1806 of yacc.c  */
    7279 #line 1627 "parser.yy"
     7251#line 1624 "parser.yy"
    72807252    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    72817253    break;
    … …  
    72847256
    72857257/* Line 1806 of yacc.c  */
    7286 #line 1633 "parser.yy"
     7258#line 1630 "parser.yy"
    72877259    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    72887260    break;
    … …  
    72917263
    72927264/* Line 1806 of yacc.c  */
    7293 #line 1638 "parser.yy"
     7265#line 1635 "parser.yy"
    72947266    { (yyval.decl) = 0; }
    72957267    break;
    … …  
    72987270
    72997271/* Line 1806 of yacc.c  */
    7300 #line 1645 "parser.yy"
     7272#line 1642 "parser.yy"
    73017273    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    73027274    break;
    … …  
    73057277
    73067278/* Line 1806 of yacc.c  */
    7307 #line 1652 "parser.yy"
     7279#line 1649 "parser.yy"
    73087280    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    73097281    break;
    … …  
    73127284
    73137285/* Line 1806 of yacc.c  */
    7314 #line 1654 "parser.yy"
     7286#line 1651 "parser.yy"
    73157287    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    73167288    break;
    73177289
    73187290  case 425:
     7291
     7292/* Line 1806 of yacc.c  */
     7293#line 1660 "parser.yy"
     7294    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     7295    break;
     7296
     7297  case 426:
    73197298
    73207299/* Line 1806 of yacc.c  */
    … …  
    73237302    break;
    73247303
    7325   case 426:
    7326 
    7327 /* Line 1806 of yacc.c  */
    7328 #line 1666 "parser.yy"
    7329     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    7330     break;
    7331 
    73327304  case 427:
    73337305
    73347306/* Line 1806 of yacc.c  */
    7335 #line 1668 "parser.yy"
     7307#line 1665 "parser.yy"
    73367308    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    73377309    break;
    … …  
    73407312
    73417313/* Line 1806 of yacc.c  */
    7342 #line 1678 "parser.yy"
     7314#line 1675 "parser.yy"
    73437315    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    73447316    break;
    … …  
    73477319
    73487320/* Line 1806 of yacc.c  */
    7349 #line 1684 "parser.yy"
     7321#line 1681 "parser.yy"
    73507322    {
    73517323                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    73577329
    73587330/* Line 1806 of yacc.c  */
    7359 #line 1689 "parser.yy"
     7331#line 1686 "parser.yy"
    73607332    {
    73617333                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    73677339
    73687340/* Line 1806 of yacc.c  */
    7369 #line 1698 "parser.yy"
     7341#line 1695 "parser.yy"
    73707342    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73717343    break;
    … …  
    73747346
    73757347/* Line 1806 of yacc.c  */
    7376 #line 1707 "parser.yy"
     7348#line 1704 "parser.yy"
    73777349    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    73787350    break;
    … …  
    73817353
    73827354/* Line 1806 of yacc.c  */
    7383 #line 1709 "parser.yy"
     7355#line 1706 "parser.yy"
    73847356    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    73857357    break;
    … …  
    73887360
    73897361/* Line 1806 of yacc.c  */
    7390 #line 1734 "parser.yy"
     7362#line 1731 "parser.yy"
    73917363    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73927364    break;
    … …  
    73957367
    73967368/* Line 1806 of yacc.c  */
    7397 #line 1742 "parser.yy"
     7369#line 1739 "parser.yy"
    73987370    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    73997371    break;
    … …  
    74027374
    74037375/* Line 1806 of yacc.c  */
    7404 #line 1747 "parser.yy"
     7376#line 1744 "parser.yy"
    74057377    { (yyval.in) = 0; }
    74067378    break;
    … …  
    74097381
    74107382/* Line 1806 of yacc.c  */
    7411 #line 1749 "parser.yy"
     7383#line 1746 "parser.yy"
    74127384    { (yyval.in) = (yyvsp[(2) - (2)].in); }
    74137385    break;
    … …  
    74167388
    74177389/* Line 1806 of yacc.c  */
    7418 #line 1751 "parser.yy"
     7390#line 1748 "parser.yy"
    74197391    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    74207392    break;
    … …  
    74237395
    74247396/* Line 1806 of yacc.c  */
    7425 #line 1755 "parser.yy"
     7397#line 1752 "parser.yy"
    74267398    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    74277399    break;
    … …  
    74307402
    74317403/* Line 1806 of yacc.c  */
    7432 #line 1756 "parser.yy"
     7404#line 1753 "parser.yy"
    74337405    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    74347406    break;
    … …  
    74377409
    74387410/* Line 1806 of yacc.c  */
     7411#line 1758 "parser.yy"
     7412    { (yyval.in) = 0; }
     7413    break;
     7414
     7415  case 463:
     7416
     7417/* Line 1806 of yacc.c  */
     7418#line 1760 "parser.yy"
     7419    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
     7420    break;
     7421
     7422  case 464:
     7423
     7424/* Line 1806 of yacc.c  */
    74397425#line 1761 "parser.yy"
    7440     { (yyval.in) = 0; }
    7441     break;
    7442 
    7443   case 463:
     7426    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
     7427    break;
     7428
     7429  case 465:
    74447430
    74457431/* Line 1806 of yacc.c  */
    74467432#line 1763 "parser.yy"
    7447     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    7448     break;
    7449 
    7450   case 464:
    7451 
    7452 /* Line 1806 of yacc.c  */
    7453 #line 1764 "parser.yy"
    7454     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
    7455     break;
    7456 
    7457   case 465:
    7458 
    7459 /* Line 1806 of yacc.c  */
    7460 #line 1766 "parser.yy"
    74617433    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    74627434    break;
    … …  
    74657437
    74667438/* Line 1806 of yacc.c  */
    7467 #line 1782 "parser.yy"
     7439#line 1779 "parser.yy"
    74687440    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
    74697441    break;
    … …  
    74727444
    74737445/* Line 1806 of yacc.c  */
    7474 #line 1788 "parser.yy"
     7446#line 1785 "parser.yy"
    74757447    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
    74767448    break;
    … …  
    74797451
    74807452/* Line 1806 of yacc.c  */
     7453#line 1791 "parser.yy"
     7454    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
     7455    break;
     7456
     7457  case 471:
     7458
     7459/* Line 1806 of yacc.c  */
    74817460#line 1794 "parser.yy"
    7482     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
    7483     break;
    7484 
    7485   case 471:
    7486 
    7487 /* Line 1806 of yacc.c  */
    7488 #line 1797 "parser.yy"
    74897461    { (yyval.en) = (yyvsp[(3) - (5)].en); }
    74907462    break;
    … …  
    74937465
    74947466/* Line 1806 of yacc.c  */
    7495 #line 1799 "parser.yy"
     7467#line 1796 "parser.yy"
    74967468    { (yyval.en) = (yyvsp[(3) - (5)].en); }
    74977469    break;
    … …  
    75007472
    75017473/* Line 1806 of yacc.c  */
    7502 #line 1801 "parser.yy"
     7474#line 1798 "parser.yy"
    75037475    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
    75047476    break;
    … …  
    75077479
    75087480/* Line 1806 of yacc.c  */
    7509 #line 1803 "parser.yy"
     7481#line 1800 "parser.yy"
    75107482    { (yyval.en) = (yyvsp[(4) - (6)].en); }
    75117483    break;
    … …  
    75147486
    75157487/* Line 1806 of yacc.c  */
    7516 #line 1827 "parser.yy"
     7488#line 1824 "parser.yy"
    75177489    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75187490    break;
    … …  
    75217493
    75227494/* Line 1806 of yacc.c  */
    7523 #line 1829 "parser.yy"
     7495#line 1826 "parser.yy"
    75247496    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    75257497    break;
    … …  
    75287500
    75297501/* Line 1806 of yacc.c  */
    7530 #line 1831 "parser.yy"
     7502#line 1828 "parser.yy"
    75317503    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    75327504    break;
    … …  
    75357507
    75367508/* Line 1806 of yacc.c  */
    7537 #line 1837 "parser.yy"
     7509#line 1834 "parser.yy"
    75387510    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    75397511    break;
    … …  
    75427514
    75437515/* Line 1806 of yacc.c  */
    7544 #line 1839 "parser.yy"
     7516#line 1836 "parser.yy"
    75457517    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    75467518    break;
    … …  
    75497521
    75507522/* Line 1806 of yacc.c  */
    7551 #line 1844 "parser.yy"
     7523#line 1841 "parser.yy"
    75527524    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    75537525    break;
    … …  
    75567528
    75577529/* Line 1806 of yacc.c  */
    7558 #line 1850 "parser.yy"
     7530#line 1847 "parser.yy"
    75597531    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    75607532    break;
    … …  
    75637535
    75647536/* Line 1806 of yacc.c  */
    7565 #line 1855 "parser.yy"
     7537#line 1852 "parser.yy"
    75667538    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    75677539    break;
    … …  
    75707542
    75717543/* Line 1806 of yacc.c  */
    7572 #line 1857 "parser.yy"
     7544#line 1854 "parser.yy"
    75737545    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    75747546    break;
    … …  
    75777549
    75787550/* Line 1806 of yacc.c  */
    7579 #line 1863 "parser.yy"
     7551#line 1860 "parser.yy"
    75807552    { (yyval.tclass) = DeclarationNode::Otype; }
    75817553    break;
    … …  
    75847556
    75857557/* Line 1806 of yacc.c  */
    7586 #line 1865 "parser.yy"
     7558#line 1862 "parser.yy"
    75877559    { (yyval.tclass) = DeclarationNode::Ftype; }
    75887560    break;
    … …  
    75917563
    75927564/* Line 1806 of yacc.c  */
    7593 #line 1867 "parser.yy"
     7565#line 1864 "parser.yy"
    75947566    { (yyval.tclass) = DeclarationNode::Dtype; }
    75957567    break;
    … …  
    75987570
    75997571/* Line 1806 of yacc.c  */
    7600 #line 1872 "parser.yy"
     7572#line 1869 "parser.yy"
    76017573    { (yyval.decl) = 0; }
    76027574    break;
    … …  
    76057577
    76067578/* Line 1806 of yacc.c  */
    7607 #line 1874 "parser.yy"
     7579#line 1871 "parser.yy"
    76087580    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    76097581    break;
    … …  
    76127584
    76137585/* Line 1806 of yacc.c  */
    7614 #line 1879 "parser.yy"
     7586#line 1876 "parser.yy"
    76157587    {
    76167588                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
    … …  
    76227594
    76237595/* Line 1806 of yacc.c  */
    7624 #line 1884 "parser.yy"
     7596#line 1881 "parser.yy"
    76257597    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    76267598    break;
    … …  
    76297601
    76307602/* Line 1806 of yacc.c  */
    7631 #line 1886 "parser.yy"
     7603#line 1883 "parser.yy"
    76327604    { (yyval.decl) = 0; }
    76337605    break;
    … …  
    76367608
    76377609/* Line 1806 of yacc.c  */
     7610#line 1888 "parser.yy"
     7611    { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
     7612    break;
     7613
     7614  case 498:
     7615
     7616/* Line 1806 of yacc.c  */
    76387617#line 1891 "parser.yy"
    7639     { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
    7640     break;
    7641 
    7642   case 498:
    7643 
    7644 /* Line 1806 of yacc.c  */
    7645 #line 1894 "parser.yy"
    76467618    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
    76477619    break;
    … …  
    76507622
    76517623/* Line 1806 of yacc.c  */
    7652 #line 1896 "parser.yy"
     7624#line 1893 "parser.yy"
    76537625    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
    76547626    break;
    … …  
    76577629
    76587630/* Line 1806 of yacc.c  */
    7659 #line 1901 "parser.yy"
     7631#line 1898 "parser.yy"
    76607632    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    76617633    break;
    … …  
    76647636
    76657637/* Line 1806 of yacc.c  */
    7666 #line 1903 "parser.yy"
     7638#line 1900 "parser.yy"
    76677639    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    76687640    break;
    … …  
    76717643
    76727644/* Line 1806 of yacc.c  */
    7673 #line 1905 "parser.yy"
     7645#line 1902 "parser.yy"
    76747646    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    76757647    break;
    … …  
    76787650
    76797651/* Line 1806 of yacc.c  */
    7680 #line 1910 "parser.yy"
     7652#line 1907 "parser.yy"
    76817653    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    76827654    break;
    … …  
    76857657
    76867658/* Line 1806 of yacc.c  */
    7687 #line 1912 "parser.yy"
     7659#line 1909 "parser.yy"
    76887660    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    76897661    break;
    … …  
    76927664
    76937665/* Line 1806 of yacc.c  */
    7694 #line 1917 "parser.yy"
     7666#line 1914 "parser.yy"
    76957667    {
    76967668                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
    … …  
    77027674
    77037675/* Line 1806 of yacc.c  */
    7704 #line 1922 "parser.yy"
     7676#line 1919 "parser.yy"
    77057677    {
    77067678                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
    … …  
    77127684
    77137685/* Line 1806 of yacc.c  */
    7714 #line 1930 "parser.yy"
     7686#line 1927 "parser.yy"
    77157687    {
    77167688                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
    … …  
    77227694
    77237695/* Line 1806 of yacc.c  */
    7724 #line 1935 "parser.yy"
     7696#line 1932 "parser.yy"
    77257697    {
    77267698                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
    … …  
    77327704
    77337705/* Line 1806 of yacc.c  */
    7734 #line 1940 "parser.yy"
     7706#line 1937 "parser.yy"
    77357707    {
    77367708                        typedefTable.leaveTrait();
    … …  
    77437715
    77447716/* Line 1806 of yacc.c  */
    7745 #line 1950 "parser.yy"
     7717#line 1947 "parser.yy"
    77467718    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    77477719    break;
    … …  
    77507722
    77517723/* Line 1806 of yacc.c  */
    7752 #line 1960 "parser.yy"
     7724#line 1957 "parser.yy"
    77537725    {
    77547726                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    77607732
    77617733/* Line 1806 of yacc.c  */
    7762 #line 1965 "parser.yy"
     7734#line 1962 "parser.yy"
    77637735    {
    77647736                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    77707742
    77717743/* Line 1806 of yacc.c  */
    7772 #line 1970 "parser.yy"
     7744#line 1967 "parser.yy"
    77737745    {
    77747746                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
    … …  
    77807752
    77817753/* Line 1806 of yacc.c  */
    7782 #line 1978 "parser.yy"
     7754#line 1975 "parser.yy"
    77837755    {
    77847756                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    77907762
    77917763/* Line 1806 of yacc.c  */
    7792 #line 1983 "parser.yy"
     7764#line 1980 "parser.yy"
    77937765    {
    77947766                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    78007772
    78017773/* Line 1806 of yacc.c  */
    7802 #line 1993 "parser.yy"
     7774#line 1990 "parser.yy"
    78037775    {}
    78047776    break;
    … …  
    78077779
    78087780/* Line 1806 of yacc.c  */
    7809 #line 1995 "parser.yy"
     7781#line 1992 "parser.yy"
    78107782    { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl);    }
    78117783    break;
    … …  
    78147786
    78157787/* Line 1806 of yacc.c  */
    7816 #line 2001 "parser.yy"
     7788#line 1998 "parser.yy"
    78177789    { (yyval.decl) = (yyvsp[(1) - (3)].decl) != nullptr ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    78187790    break;
    … …  
    78217793
    78227794/* Line 1806 of yacc.c  */
    7823 #line 2006 "parser.yy"
     7795#line 2003 "parser.yy"
    78247796    { (yyval.decl) = 0; }
    78257797    break;
    … …  
    78287800
    78297801/* Line 1806 of yacc.c  */
    7830 #line 2014 "parser.yy"
     7802#line 2011 "parser.yy"
    78317803    {}
    78327804    break;
    … …  
    78357807
    78367808/* Line 1806 of yacc.c  */
    7837 #line 2016 "parser.yy"
     7809#line 2013 "parser.yy"
    78387810    {
    78397811                        linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
    … …  
    78457817
    78467818/* Line 1806 of yacc.c  */
    7847 #line 2021 "parser.yy"
     7819#line 2018 "parser.yy"
    78487820    {
    78497821                        linkage = linkageStack.top();
    … …  
    78567828
    78577829/* Line 1806 of yacc.c  */
    7858 #line 2027 "parser.yy"
     7830#line 2024 "parser.yy"
    78597831    {   // mark all fields in list
    78607832                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
    … …  
    78677839
    78687840/* Line 1806 of yacc.c  */
    7869 #line 2042 "parser.yy"
     7841#line 2039 "parser.yy"
    78707842    {
    78717843                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    78787850
    78797851/* Line 1806 of yacc.c  */
    7880 #line 2048 "parser.yy"
     7852#line 2045 "parser.yy"
    78817853    {
    78827854                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    78897861
    78907862/* Line 1806 of yacc.c  */
    7891 #line 2057 "parser.yy"
     7863#line 2054 "parser.yy"
    78927864    {
    78937865                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79007872
    79017873/* Line 1806 of yacc.c  */
    7902 #line 2063 "parser.yy"
     7874#line 2060 "parser.yy"
    79037875    {
    79047876                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79117883
    79127884/* Line 1806 of yacc.c  */
    7913 #line 2069 "parser.yy"
     7885#line 2066 "parser.yy"
    79147886    {
    79157887                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79227894
    79237895/* Line 1806 of yacc.c  */
    7924 #line 2075 "parser.yy"
     7896#line 2072 "parser.yy"
    79257897    {
    79267898                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79337905
    79347906/* Line 1806 of yacc.c  */
    7935 #line 2081 "parser.yy"
     7907#line 2078 "parser.yy"
    79367908    {
    79377909                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79447916
    79457917/* Line 1806 of yacc.c  */
    7946 #line 2089 "parser.yy"
     7918#line 2086 "parser.yy"
    79477919    {
    79487920                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79557927
    79567928/* Line 1806 of yacc.c  */
    7957 #line 2095 "parser.yy"
     7929#line 2092 "parser.yy"
    79587930    {
    79597931                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79667938
    79677939/* Line 1806 of yacc.c  */
    7968 #line 2103 "parser.yy"
     7940#line 2100 "parser.yy"
    79697941    {
    79707942                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79777949
    79787950/* Line 1806 of yacc.c  */
    7979 #line 2109 "parser.yy"
     7951#line 2106 "parser.yy"
    79807952    {
    79817953                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    79887960
    79897961/* Line 1806 of yacc.c  */
    7990 #line 2124 "parser.yy"
     7962#line 2121 "parser.yy"
    79917963    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    79927964    break;
    … …  
    79957967
    79967968/* Line 1806 of yacc.c  */
    7997 #line 2129 "parser.yy"
     7969#line 2126 "parser.yy"
    79987970    { delete (yyvsp[(3) - (5)].str); }
    79997971    break;
    … …  
    80027974
    80037975/* Line 1806 of yacc.c  */
    8004 #line 2134 "parser.yy"
     7976#line 2131 "parser.yy"
    80057977    { (yyval.decl) = 0; }
    80067978    break;
    … …  
    80097981
    80107982/* Line 1806 of yacc.c  */
    8011 #line 2141 "parser.yy"
     7983#line 2138 "parser.yy"
    80127984    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    80137985    break;
    … …  
    80167988
    80177989/* Line 1806 of yacc.c  */
    8018 #line 2147 "parser.yy"
     7990#line 2144 "parser.yy"
    80197991    { (yyval.decl) = 0; }
    80207992    break;
    … …  
    80237995
    80247996/* Line 1806 of yacc.c  */
    8025 #line 2158 "parser.yy"
     7997#line 2155 "parser.yy"
    80267998    { delete (yyvsp[(3) - (4)].en); }
    80277999    break;
    … …  
    80308002
    80318003/* Line 1806 of yacc.c  */
     8004#line 2159 "parser.yy"
     8005    { delete (yyvsp[(1) - (1)].tok); }
     8006    break;
     8007
     8008  case 560:
     8009
     8010/* Line 1806 of yacc.c  */
     8011#line 2160 "parser.yy"
     8012    { delete (yyvsp[(1) - (1)].decl); }
     8013    break;
     8014
     8015  case 561:
     8016
     8017/* Line 1806 of yacc.c  */
     8018#line 2161 "parser.yy"
     8019    { delete (yyvsp[(1) - (1)].decl); }
     8020    break;
     8021
     8022  case 562:
     8023
     8024/* Line 1806 of yacc.c  */
    80328025#line 2162 "parser.yy"
    8033     { delete (yyvsp[(1) - (1)].tok); }
    8034     break;
    8035 
    8036   case 560:
    8037 
    8038 /* Line 1806 of yacc.c  */
    8039 #line 2163 "parser.yy"
    80408026    { delete (yyvsp[(1) - (1)].decl); }
    80418027    break;
    80428028
    8043   case 561:
    8044 
    8045 /* Line 1806 of yacc.c  */
    8046 #line 2164 "parser.yy"
    8047     { delete (yyvsp[(1) - (1)].decl); }
    8048     break;
    8049 
    8050   case 562:
    8051 
    8052 /* Line 1806 of yacc.c  */
    8053 #line 2165 "parser.yy"
    8054     { delete (yyvsp[(1) - (1)].decl); }
    8055     break;
    8056 
    80578029  case 563:
     8030
     8031/* Line 1806 of yacc.c  */
     8032#line 2197 "parser.yy"
     8033    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8034    break;
     8035
     8036  case 565:
    80588037
    80598038/* Line 1806 of yacc.c  */
    … …  
    80628041    break;
    80638042
    8064   case 565:
    8065 
    8066 /* Line 1806 of yacc.c  */
    8067 #line 2203 "parser.yy"
     8043  case 566:
     8044
     8045/* Line 1806 of yacc.c  */
     8046#line 2202 "parser.yy"
    80688047    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80698048    break;
    80708049
    8071   case 566:
    8072 
    8073 /* Line 1806 of yacc.c  */
    8074 #line 2205 "parser.yy"
    8075     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8076     break;
    8077 
    80788050  case 567:
    80798051
    80808052/* Line 1806 of yacc.c  */
    8081 #line 2210 "parser.yy"
     8053#line 2207 "parser.yy"
    80828054    {
    80838055                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    80898061
    80908062/* Line 1806 of yacc.c  */
    8091 #line 2215 "parser.yy"
     8063#line 2212 "parser.yy"
    80928064    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80938065    break;
    … …  
    80968068
    80978069/* Line 1806 of yacc.c  */
    8098 #line 2220 "parser.yy"
     8070#line 2217 "parser.yy"
    80998071    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    81008072    break;
    … …  
    81038075
    81048076/* Line 1806 of yacc.c  */
    8105 #line 2222 "parser.yy"
     8077#line 2219 "parser.yy"
    81068078    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    81078079    break;
    … …  
    81108082
    81118083/* Line 1806 of yacc.c  */
    8112 #line 2224 "parser.yy"
     8084#line 2221 "parser.yy"
    81138085    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81148086    break;
    … …  
    81178089
    81188090/* Line 1806 of yacc.c  */
    8119 #line 2229 "parser.yy"
     8091#line 2226 "parser.yy"
    81208092    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    81218093    break;
    … …  
    81248096
    81258097/* Line 1806 of yacc.c  */
    8126 #line 2231 "parser.yy"
     8098#line 2228 "parser.yy"
    81278099    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81288100    break;
    … …  
    81318103
    81328104/* Line 1806 of yacc.c  */
    8133 #line 2233 "parser.yy"
     8105#line 2230 "parser.yy"
    81348106    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81358107    break;
    … …  
    81388110
    81398111/* Line 1806 of yacc.c  */
    8140 #line 2235 "parser.yy"
     8112#line 2232 "parser.yy"
    81418113    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81428114    break;
    … …  
    81458117
    81468118/* Line 1806 of yacc.c  */
    8147 #line 2240 "parser.yy"
     8119#line 2237 "parser.yy"
    81488120    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    81498121    break;
    … …  
    81528124
    81538125/* Line 1806 of yacc.c  */
    8154 #line 2242 "parser.yy"
     8126#line 2239 "parser.yy"
    81558127    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81568128    break;
    81578129
    81588130  case 578:
     8131
     8132/* Line 1806 of yacc.c  */
     8133#line 2248 "parser.yy"
     8134    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     8135    break;
     8136
     8137  case 580:
    81598138
    81608139/* Line 1806 of yacc.c  */
    … …  
    81638142    break;
    81648143
    8165   case 580:
    8166 
    8167 /* Line 1806 of yacc.c  */
    8168 #line 2254 "parser.yy"
     8144  case 581:
     8145
     8146/* Line 1806 of yacc.c  */
     8147#line 2256 "parser.yy"
     8148    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8149    break;
     8150
     8151  case 582:
     8152
     8153/* Line 1806 of yacc.c  */
     8154#line 2258 "parser.yy"
     8155    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8156    break;
     8157
     8158  case 583:
     8159
     8160/* Line 1806 of yacc.c  */
     8161#line 2260 "parser.yy"
     8162    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8163    break;
     8164
     8165  case 584:
     8166
     8167/* Line 1806 of yacc.c  */
     8168#line 2265 "parser.yy"
     8169    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8170    break;
     8171
     8172  case 585:
     8173
     8174/* Line 1806 of yacc.c  */
     8175#line 2267 "parser.yy"
     8176    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8177    break;
     8178
     8179  case 586:
     8180
     8181/* Line 1806 of yacc.c  */
     8182#line 2269 "parser.yy"
     8183    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8184    break;
     8185
     8186  case 587:
     8187
     8188/* Line 1806 of yacc.c  */
     8189#line 2274 "parser.yy"
     8190    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8191    break;
     8192
     8193  case 588:
     8194
     8195/* Line 1806 of yacc.c  */
     8196#line 2276 "parser.yy"
     8197    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8198    break;
     8199
     8200  case 589:
     8201
     8202/* Line 1806 of yacc.c  */
     8203#line 2278 "parser.yy"
     8204    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8205    break;
     8206
     8207  case 593:
     8208
     8209/* Line 1806 of yacc.c  */
     8210#line 2293 "parser.yy"
     8211    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
     8212    break;
     8213
     8214  case 594:
     8215
     8216/* Line 1806 of yacc.c  */
     8217#line 2295 "parser.yy"
     8218    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
     8219    break;
     8220
     8221  case 595:
     8222
     8223/* Line 1806 of yacc.c  */
     8224#line 2297 "parser.yy"
     8225    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8226    break;
     8227
     8228  case 596:
     8229
     8230/* Line 1806 of yacc.c  */
     8231#line 2302 "parser.yy"
     8232    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8233    break;
     8234
     8235  case 597:
     8236
     8237/* Line 1806 of yacc.c  */
     8238#line 2304 "parser.yy"
     8239    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8240    break;
     8241
     8242  case 598:
     8243
     8244/* Line 1806 of yacc.c  */
     8245#line 2306 "parser.yy"
     8246    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8247    break;
     8248
     8249  case 599:
     8250
     8251/* Line 1806 of yacc.c  */
     8252#line 2311 "parser.yy"
     8253    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8254    break;
     8255
     8256  case 600:
     8257
     8258/* Line 1806 of yacc.c  */
     8259#line 2313 "parser.yy"
     8260    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8261    break;
     8262
     8263  case 601:
     8264
     8265/* Line 1806 of yacc.c  */
     8266#line 2315 "parser.yy"
     8267    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8268    break;
     8269
     8270  case 602:
     8271
     8272/* Line 1806 of yacc.c  */
     8273#line 2330 "parser.yy"
    81698274    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81708275    break;
    81718276
    8172   case 581:
    8173 
    8174 /* Line 1806 of yacc.c  */
    8175 #line 2259 "parser.yy"
    8176     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8177     break;
    8178 
    8179   case 582:
    8180 
    8181 /* Line 1806 of yacc.c  */
    8182 #line 2261 "parser.yy"
    8183     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8184     break;
    8185 
    8186   case 583:
    8187 
    8188 /* Line 1806 of yacc.c  */
    8189 #line 2263 "parser.yy"
    8190     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8191     break;
    8192 
    8193   case 584:
    8194 
    8195 /* Line 1806 of yacc.c  */
    8196 #line 2268 "parser.yy"
    8197     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8198     break;
    8199 
    8200   case 585:
    8201 
    8202 /* Line 1806 of yacc.c  */
    8203 #line 2270 "parser.yy"
    8204     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8205     break;
    8206 
    8207   case 586:
    8208 
    8209 /* Line 1806 of yacc.c  */
    8210 #line 2272 "parser.yy"
    8211     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8212     break;
    8213 
    8214   case 587:
    8215 
    8216 /* Line 1806 of yacc.c  */
    8217 #line 2277 "parser.yy"
    8218     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8219     break;
    8220 
    8221   case 588:
    8222 
    8223 /* Line 1806 of yacc.c  */
    8224 #line 2279 "parser.yy"
    8225     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8226     break;
    8227 
    8228   case 589:
    8229 
    8230 /* Line 1806 of yacc.c  */
    8231 #line 2281 "parser.yy"
    8232     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8233     break;
    8234 
    8235   case 593:
    8236 
    8237 /* Line 1806 of yacc.c  */
    8238 #line 2296 "parser.yy"
    8239     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    8240     break;
    8241 
    8242   case 594:
    8243 
    8244 /* Line 1806 of yacc.c  */
    8245 #line 2298 "parser.yy"
    8246     { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    8247     break;
    8248 
    8249   case 595:
    8250 
    8251 /* Line 1806 of yacc.c  */
    8252 #line 2300 "parser.yy"
    8253     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8254     break;
    8255 
    8256   case 596:
    8257 
    8258 /* Line 1806 of yacc.c  */
    8259 #line 2305 "parser.yy"
    8260     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8261     break;
    8262 
    8263   case 597:
    8264 
    8265 /* Line 1806 of yacc.c  */
    8266 #line 2307 "parser.yy"
    8267     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8268     break;
    8269 
    8270   case 598:
    8271 
    8272 /* Line 1806 of yacc.c  */
    8273 #line 2309 "parser.yy"
    8274     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8275     break;
    8276 
    8277   case 599:
    8278 
    8279 /* Line 1806 of yacc.c  */
    8280 #line 2314 "parser.yy"
    8281     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8282     break;
    8283 
    8284   case 600:
    8285 
    8286 /* Line 1806 of yacc.c  */
    8287 #line 2316 "parser.yy"
    8288     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8289     break;
    8290 
    8291   case 601:
    8292 
    8293 /* Line 1806 of yacc.c  */
    8294 #line 2318 "parser.yy"
    8295     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8296     break;
    8297 
    8298   case 602:
     8277  case 604:
    82998278
    83008279/* Line 1806 of yacc.c  */
    … …  
    83038282    break;
    83048283
    8305   case 604:
    8306 
    8307 /* Line 1806 of yacc.c  */
    8308 #line 2336 "parser.yy"
     8284  case 605:
     8285
     8286/* Line 1806 of yacc.c  */
     8287#line 2335 "parser.yy"
    83098288    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83108289    break;
    83118290
    8312   case 605:
    8313 
    8314 /* Line 1806 of yacc.c  */
    8315 #line 2338 "parser.yy"
     8291  case 607:
     8292
     8293/* Line 1806 of yacc.c  */
     8294#line 2341 "parser.yy"
     8295    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8296    break;
     8297
     8298  case 608:
     8299
     8300/* Line 1806 of yacc.c  */
     8301#line 2346 "parser.yy"
     8302    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8303    break;
     8304
     8305  case 609:
     8306
     8307/* Line 1806 of yacc.c  */
     8308#line 2348 "parser.yy"
     8309    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8310    break;
     8311
     8312  case 610:
     8313
     8314/* Line 1806 of yacc.c  */
     8315#line 2350 "parser.yy"
     8316    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8317    break;
     8318
     8319  case 611:
     8320
     8321/* Line 1806 of yacc.c  */
     8322#line 2355 "parser.yy"
     8323    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8324    break;
     8325
     8326  case 612:
     8327
     8328/* Line 1806 of yacc.c  */
     8329#line 2357 "parser.yy"
     8330    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8331    break;
     8332
     8333  case 613:
     8334
     8335/* Line 1806 of yacc.c  */
     8336#line 2359 "parser.yy"
     8337    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8338    break;
     8339
     8340  case 614:
     8341
     8342/* Line 1806 of yacc.c  */
     8343#line 2361 "parser.yy"
     8344    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8345    break;
     8346
     8347  case 615:
     8348
     8349/* Line 1806 of yacc.c  */
     8350#line 2366 "parser.yy"
     8351    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8352    break;
     8353
     8354  case 616:
     8355
     8356/* Line 1806 of yacc.c  */
     8357#line 2368 "parser.yy"
     8358    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8359    break;
     8360
     8361  case 617:
     8362
     8363/* Line 1806 of yacc.c  */
     8364#line 2370 "parser.yy"
     8365    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8366    break;
     8367
     8368  case 618:
     8369
     8370/* Line 1806 of yacc.c  */
     8371#line 2380 "parser.yy"
    83168372    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83178373    break;
    83188374
    8319   case 607:
    8320 
    8321 /* Line 1806 of yacc.c  */
    8322 #line 2344 "parser.yy"
    8323     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8324     break;
    8325 
    8326   case 608:
    8327 
    8328 /* Line 1806 of yacc.c  */
    8329 #line 2349 "parser.yy"
    8330     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8331     break;
    8332 
    8333   case 609:
    8334 
    8335 /* Line 1806 of yacc.c  */
    8336 #line 2351 "parser.yy"
    8337     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8338     break;
    8339 
    8340   case 610:
    8341 
    8342 /* Line 1806 of yacc.c  */
    8343 #line 2353 "parser.yy"
    8344     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8345     break;
    8346 
    8347   case 611:
    8348 
    8349 /* Line 1806 of yacc.c  */
    8350 #line 2358 "parser.yy"
    8351     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8352     break;
    8353 
    8354   case 612:
    8355 
    8356 /* Line 1806 of yacc.c  */
    8357 #line 2360 "parser.yy"
    8358     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8359     break;
    8360 
    8361   case 613:
    8362 
    8363 /* Line 1806 of yacc.c  */
    8364 #line 2362 "parser.yy"
    8365     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8366     break;
    8367 
    8368   case 614:
    8369 
    8370 /* Line 1806 of yacc.c  */
    8371 #line 2364 "parser.yy"
    8372     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8373     break;
    8374 
    8375   case 615:
    8376 
    8377 /* Line 1806 of yacc.c  */
    8378 #line 2369 "parser.yy"
    8379     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8380     break;
    8381 
    8382   case 616:
    8383 
    8384 /* Line 1806 of yacc.c  */
    8385 #line 2371 "parser.yy"
    8386     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8387     break;
    8388 
    8389   case 617:
    8390 
    8391 /* Line 1806 of yacc.c  */
    8392 #line 2373 "parser.yy"
    8393     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8394     break;
    8395 
    8396   case 618:
     8375  case 620:
    83978376
    83988377/* Line 1806 of yacc.c  */
    … …  
    84018380    break;
    84028381
    8403   case 620:
    8404 
    8405 /* Line 1806 of yacc.c  */
    8406 #line 2386 "parser.yy"
     8382  case 621:
     8383
     8384/* Line 1806 of yacc.c  */
     8385#line 2385 "parser.yy"
    84078386    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84088387    break;
    84098388
    8410   case 621:
    8411 
    8412 /* Line 1806 of yacc.c  */
    8413 #line 2388 "parser.yy"
     8389  case 622:
     8390
     8391/* Line 1806 of yacc.c  */
     8392#line 2390 "parser.yy"
     8393    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     8394    break;
     8395
     8396  case 623:
     8397
     8398/* Line 1806 of yacc.c  */
     8399#line 2392 "parser.yy"
     8400    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     8401    break;
     8402
     8403  case 624:
     8404
     8405/* Line 1806 of yacc.c  */
     8406#line 2394 "parser.yy"
     8407    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8408    break;
     8409
     8410  case 625:
     8411
     8412/* Line 1806 of yacc.c  */
     8413#line 2399 "parser.yy"
     8414    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     8415    break;
     8416
     8417  case 626:
     8418
     8419/* Line 1806 of yacc.c  */
     8420#line 2401 "parser.yy"
     8421    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8422    break;
     8423
     8424  case 627:
     8425
     8426/* Line 1806 of yacc.c  */
     8427#line 2403 "parser.yy"
     8428    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     8429    break;
     8430
     8431  case 628:
     8432
     8433/* Line 1806 of yacc.c  */
     8434#line 2405 "parser.yy"
     8435    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8436    break;
     8437
     8438  case 629:
     8439
     8440/* Line 1806 of yacc.c  */
     8441#line 2410 "parser.yy"
     8442    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     8443    break;
     8444
     8445  case 630:
     8446
     8447/* Line 1806 of yacc.c  */
     8448#line 2412 "parser.yy"
     8449    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     8450    break;
     8451
     8452  case 631:
     8453
     8454/* Line 1806 of yacc.c  */
     8455#line 2414 "parser.yy"
     8456    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     8457    break;
     8458
     8459  case 632:
     8460
     8461/* Line 1806 of yacc.c  */
     8462#line 2445 "parser.yy"
    84148463    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84158464    break;
    84168465
    8417   case 622:
    8418 
    8419 /* Line 1806 of yacc.c  */
    8420 #line 2393 "parser.yy"
    8421     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    8422     break;
    8423 
    8424   case 623:
    8425 
    8426 /* Line 1806 of yacc.c  */
    8427 #line 2395 "parser.yy"
    8428     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    8429     break;
    8430 
    8431   case 624:
    8432 
    8433 /* Line 1806 of yacc.c  */
    8434 #line 2397 "parser.yy"
    8435     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8436     break;
    8437 
    8438   case 625:
    8439 
    8440 /* Line 1806 of yacc.c  */
    8441 #line 2402 "parser.yy"
    8442     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    8443     break;
    8444 
    8445   case 626:
    8446 
    8447 /* Line 1806 of yacc.c  */
    8448 #line 2404 "parser.yy"
    8449     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8450     break;
    8451 
    8452   case 627:
    8453 
    8454 /* Line 1806 of yacc.c  */
    8455 #line 2406 "parser.yy"
    8456     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    8457     break;
    8458 
    8459   case 628:
    8460 
    8461 /* Line 1806 of yacc.c  */
    8462 #line 2408 "parser.yy"
    8463     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8464     break;
    8465 
    8466   case 629:
    8467 
    8468 /* Line 1806 of yacc.c  */
    8469 #line 2413 "parser.yy"
    8470     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    8471     break;
    8472 
    8473   case 630:
    8474 
    8475 /* Line 1806 of yacc.c  */
    8476 #line 2415 "parser.yy"
    8477     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    8478     break;
    8479 
    8480   case 631:
    8481 
    8482 /* Line 1806 of yacc.c  */
    8483 #line 2417 "parser.yy"
    8484     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    8485     break;
    8486 
    8487   case 632:
     8466  case 634:
    84888467
    84898468/* Line 1806 of yacc.c  */
    … …  
    84928471    break;
    84938472
    8494   case 634:
    8495 
    8496 /* Line 1806 of yacc.c  */
    8497 #line 2451 "parser.yy"
     8473  case 635:
     8474
     8475/* Line 1806 of yacc.c  */
     8476#line 2450 "parser.yy"
    84988477    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84998478    break;
    85008479
    8501   case 635:
    8502 
    8503 /* Line 1806 of yacc.c  */
    8504 #line 2453 "parser.yy"
    8505     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    8506     break;
    8507 
    85088480  case 636:
    85098481
    85108482/* Line 1806 of yacc.c  */
    8511 #line 2458 "parser.yy"
     8483#line 2455 "parser.yy"
    85128484    {
    85138485                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    85198491
    85208492/* Line 1806 of yacc.c  */
    8521 #line 2463 "parser.yy"
     8493#line 2460 "parser.yy"
    85228494    {
    85238495                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    85298501
    85308502/* Line 1806 of yacc.c  */
    8531 #line 2471 "parser.yy"
     8503#line 2468 "parser.yy"
    85328504    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    85338505    break;
    … …  
    85368508
    85378509/* Line 1806 of yacc.c  */
    8538 #line 2473 "parser.yy"
     8510#line 2470 "parser.yy"
    85398511    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    85408512    break;
    … …  
    85438515
    85448516/* Line 1806 of yacc.c  */
    8545 #line 2475 "parser.yy"
     8517#line 2472 "parser.yy"
    85468518    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85478519    break;
    … …  
    85508522
    85518523/* Line 1806 of yacc.c  */
    8552 #line 2480 "parser.yy"
     8524#line 2477 "parser.yy"
    85538525    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    85548526    break;
    … …  
    85578529
    85588530/* Line 1806 of yacc.c  */
    8559 #line 2482 "parser.yy"
     8531#line 2479 "parser.yy"
    85608532    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85618533    break;
    … …  
    85648536
    85658537/* Line 1806 of yacc.c  */
    8566 #line 2487 "parser.yy"
     8538#line 2484 "parser.yy"
    85678539    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    85688540    break;
    … …  
    85718543
    85728544/* Line 1806 of yacc.c  */
    8573 #line 2489 "parser.yy"
     8545#line 2486 "parser.yy"
    85748546    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85758547    break;
    … …  
    85788550
    85798551/* Line 1806 of yacc.c  */
    8580 #line 2504 "parser.yy"
     8552#line 2501 "parser.yy"
    85818553    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85828554    break;
    … …  
    85858557
    85868558/* Line 1806 of yacc.c  */
    8587 #line 2506 "parser.yy"
     8559#line 2503 "parser.yy"
    85888560    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85898561    break;
    … …  
    85928564
    85938565/* Line 1806 of yacc.c  */
    8594 #line 2511 "parser.yy"
     8566#line 2508 "parser.yy"
    85958567    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    85968568    break;
    … …  
    85998571
    86008572/* Line 1806 of yacc.c  */
    8601 #line 2513 "parser.yy"
     8573#line 2510 "parser.yy"
    86028574    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    86038575    break;
    … …  
    86068578
    86078579/* Line 1806 of yacc.c  */
    8608 #line 2515 "parser.yy"
     8580#line 2512 "parser.yy"
    86098581    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    86108582    break;
    … …  
    86138585
    86148586/* Line 1806 of yacc.c  */
    8615 #line 2517 "parser.yy"
     8587#line 2514 "parser.yy"
    86168588    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    86178589    break;
    … …  
    86208592
    86218593/* Line 1806 of yacc.c  */
    8622 #line 2519 "parser.yy"
     8594#line 2516 "parser.yy"
    86238595    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86248596    break;
    … …  
    86278599
    86288600/* Line 1806 of yacc.c  */
    8629 #line 2525 "parser.yy"
     8601#line 2522 "parser.yy"
    86308602    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86318603    break;
    … …  
    86348606
    86358607/* Line 1806 of yacc.c  */
    8636 #line 2527 "parser.yy"
     8608#line 2524 "parser.yy"
    86378609    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86388610    break;
    … …  
    86418613
    86428614/* Line 1806 of yacc.c  */
    8643 #line 2529 "parser.yy"
     8615#line 2526 "parser.yy"
    86448616    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86458617    break;
    … …  
    86488620
    86498621/* Line 1806 of yacc.c  */
    8650 #line 2534 "parser.yy"
     8622#line 2531 "parser.yy"
    86518623    { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
    86528624    break;
    … …  
    86558627
    86568628/* Line 1806 of yacc.c  */
    8657 #line 2536 "parser.yy"
     8629#line 2533 "parser.yy"
    86588630    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    86598631    break;
    … …  
    86628634
    86638635/* Line 1806 of yacc.c  */
    8664 #line 2538 "parser.yy"
     8636#line 2535 "parser.yy"
    86658637    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86668638    break;
    … …  
    86698641
    86708642/* Line 1806 of yacc.c  */
    8671 #line 2544 "parser.yy"
     8643#line 2541 "parser.yy"
    86728644    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    86738645    break;
    … …  
    86768648
    86778649/* Line 1806 of yacc.c  */
    8678 #line 2546 "parser.yy"
     8650#line 2543 "parser.yy"
    86798651    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    86808652    break;
    … …  
    86838655
    86848656/* Line 1806 of yacc.c  */
    8685 #line 2552 "parser.yy"
     8657#line 2549 "parser.yy"
    86868658    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    86878659    break;
    … …  
    86908662
    86918663/* Line 1806 of yacc.c  */
    8692 #line 2554 "parser.yy"
     8664#line 2551 "parser.yy"
    86938665    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    86948666    break;
    … …  
    86978669
    86988670/* Line 1806 of yacc.c  */
    8699 #line 2556 "parser.yy"
     8671#line 2553 "parser.yy"
    87008672    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    87018673    break;
    … …  
    87048676
    87058677/* Line 1806 of yacc.c  */
    8706 #line 2558 "parser.yy"
     8678#line 2555 "parser.yy"
    87078679    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    87088680    break;
    … …  
    87118683
    87128684/* Line 1806 of yacc.c  */
    8713 #line 2573 "parser.yy"
     8685#line 2570 "parser.yy"
    87148686    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87158687    break;
    … …  
    87188690
    87198691/* Line 1806 of yacc.c  */
    8720 #line 2575 "parser.yy"
     8692#line 2572 "parser.yy"
    87218693    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87228694    break;
    … …  
    87258697
    87268698/* Line 1806 of yacc.c  */
    8727 #line 2580 "parser.yy"
     8699#line 2577 "parser.yy"
    87288700    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    87298701    break;
    … …  
    87328704
    87338705/* Line 1806 of yacc.c  */
    8734 #line 2582 "parser.yy"
     8706#line 2579 "parser.yy"
    87358707    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    87368708    break;
    … …  
    87398711
    87408712/* Line 1806 of yacc.c  */
    8741 #line 2584 "parser.yy"
     8713#line 2581 "parser.yy"
    87428714    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    87438715    break;
    … …  
    87468718
    87478719/* Line 1806 of yacc.c  */
    8748 #line 2586 "parser.yy"
     8720#line 2583 "parser.yy"
    87498721    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    87508722    break;
    … …  
    87538725
    87548726/* Line 1806 of yacc.c  */
    8755 #line 2588 "parser.yy"
     8727#line 2585 "parser.yy"
    87568728    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87578729    break;
    … …  
    87608732
    87618733/* Line 1806 of yacc.c  */
    8762 #line 2594 "parser.yy"
     8734#line 2591 "parser.yy"
    87638735    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87648736    break;
    … …  
    87678739
    87688740/* Line 1806 of yacc.c  */
    8769 #line 2596 "parser.yy"
     8741#line 2593 "parser.yy"
    87708742    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87718743    break;
    … …  
    87748746
    87758747/* Line 1806 of yacc.c  */
    8776 #line 2598 "parser.yy"
     8748#line 2595 "parser.yy"
    87778749    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87788750    break;
    … …  
    87818753
    87828754/* Line 1806 of yacc.c  */
    8783 #line 2603 "parser.yy"
     8755#line 2600 "parser.yy"
    87848756    { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
    87858757    break;
    … …  
    87888760
    87898761/* Line 1806 of yacc.c  */
    8790 #line 2605 "parser.yy"
     8762#line 2602 "parser.yy"
    87918763    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87928764    break;
    … …  
    87958767
    87968768/* Line 1806 of yacc.c  */
    8797 #line 2607 "parser.yy"
     8769#line 2604 "parser.yy"
    87988770    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87998771    break;
    … …  
    88028774
    88038775/* Line 1806 of yacc.c  */
    8804 #line 2614 "parser.yy"
     8776#line 2611 "parser.yy"
    88058777    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    88068778    break;
    … …  
    88098781
    88108782/* Line 1806 of yacc.c  */
     8783#line 2622 "parser.yy"
     8784    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     8785    break;
     8786
     8787  case 686:
     8788
     8789/* Line 1806 of yacc.c  */
    88118790#line 2625 "parser.yy"
    8812     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    8813     break;
    8814 
    8815   case 686:
    8816 
    8817 /* Line 1806 of yacc.c  */
    8818 #line 2628 "parser.yy"
    88198791    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    88208792    break;
    … …  
    88238795
    88248796/* Line 1806 of yacc.c  */
     8797#line 2627 "parser.yy"
     8798    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
     8799    break;
     8800
     8801  case 688:
     8802
     8803/* Line 1806 of yacc.c  */
    88258804#line 2630 "parser.yy"
    8826     { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    8827     break;
    8828 
    8829   case 688:
    8830 
    8831 /* Line 1806 of yacc.c  */
    8832 #line 2633 "parser.yy"
    88338805    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    88348806    break;
    … …  
    88378809
    88388810/* Line 1806 of yacc.c  */
    8839 #line 2635 "parser.yy"
     8811#line 2632 "parser.yy"
    88408812    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    88418813    break;
    … …  
    88448816
    88458817/* Line 1806 of yacc.c  */
    8846 #line 2637 "parser.yy"
     8818#line 2634 "parser.yy"
    88478819    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    88488820    break;
    … …  
    88518823
    88528824/* Line 1806 of yacc.c  */
    8853 #line 2651 "parser.yy"
     8825#line 2648 "parser.yy"
    88548826    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    88558827    break;
    … …  
    88588830
    88598831/* Line 1806 of yacc.c  */
    8860 #line 2653 "parser.yy"
     8832#line 2650 "parser.yy"
    88618833    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    88628834    break;
    … …  
    88658837
    88668838/* Line 1806 of yacc.c  */
    8867 #line 2658 "parser.yy"
     8839#line 2655 "parser.yy"
    88688840    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    88698841    break;
    … …  
    88728844
    88738845/* Line 1806 of yacc.c  */
    8874 #line 2660 "parser.yy"
     8846#line 2657 "parser.yy"
    88758847    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    88768848    break;
    … …  
    88798851
    88808852/* Line 1806 of yacc.c  */
    8881 #line 2662 "parser.yy"
     8853#line 2659 "parser.yy"
    88828854    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    88838855    break;
    … …  
    88868858
    88878859/* Line 1806 of yacc.c  */
    8888 #line 2664 "parser.yy"
     8860#line 2661 "parser.yy"
    88898861    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    88908862    break;
    … …  
    88938865
    88948866/* Line 1806 of yacc.c  */
    8895 #line 2666 "parser.yy"
     8867#line 2663 "parser.yy"
    88968868    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    88978869    break;
    … …  
    89008872
    89018873/* Line 1806 of yacc.c  */
    8902 #line 2672 "parser.yy"
     8874#line 2669 "parser.yy"
    89038875    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    89048876    break;
    … …  
    89078879
    89088880/* Line 1806 of yacc.c  */
    8909 #line 2674 "parser.yy"
     8881#line 2671 "parser.yy"
    89108882    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    89118883    break;
    … …  
    89148886
    89158887/* Line 1806 of yacc.c  */
    8916 #line 2676 "parser.yy"
     8888#line 2673 "parser.yy"
    89178889    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89188890    break;
    … …  
    89218893
    89228894/* Line 1806 of yacc.c  */
    8923 #line 2681 "parser.yy"
     8895#line 2678 "parser.yy"
    89248896    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    89258897    break;
    … …  
    89288900
    89298901/* Line 1806 of yacc.c  */
    8930 #line 2683 "parser.yy"
     8902#line 2680 "parser.yy"
    89318903    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    89328904    break;
    … …  
    89358907
    89368908/* Line 1806 of yacc.c  */
    8937 #line 2693 "parser.yy"
     8909#line 2690 "parser.yy"
    89388910    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    89398911    break;
    … …  
    89428914
    89438915/* Line 1806 of yacc.c  */
    8944 #line 2703 "parser.yy"
     8916#line 2700 "parser.yy"
    89458917    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89468918    break;
    … …  
    89498921
    89508922/* Line 1806 of yacc.c  */
    8951 #line 2705 "parser.yy"
     8923#line 2702 "parser.yy"
    89528924    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89538925    break;
    … …  
    89568928
    89578929/* Line 1806 of yacc.c  */
    8958 #line 2707 "parser.yy"
     8930#line 2704 "parser.yy"
    89598931    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89608932    break;
    … …  
    89638935
    89648936/* Line 1806 of yacc.c  */
    8965 #line 2709 "parser.yy"
     8937#line 2706 "parser.yy"
    89668938    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89678939    break;
    … …  
    89708942
    89718943/* Line 1806 of yacc.c  */
    8972 #line 2711 "parser.yy"
     8944#line 2708 "parser.yy"
    89738945    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89748946    break;
    … …  
    89778949
    89788950/* Line 1806 of yacc.c  */
    8979 #line 2713 "parser.yy"
     8951#line 2710 "parser.yy"
    89808952    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89818953    break;
    … …  
    89848956
    89858957/* Line 1806 of yacc.c  */
    8986 #line 2720 "parser.yy"
     8958#line 2717 "parser.yy"
    89878959    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89888960    break;
    … …  
    89918963
    89928964/* Line 1806 of yacc.c  */
    8993 #line 2722 "parser.yy"
     8965#line 2719 "parser.yy"
    89948966    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    89958967    break;
    … …  
    89988970
    89998971/* Line 1806 of yacc.c  */
    9000 #line 2724 "parser.yy"
     8972#line 2721 "parser.yy"
    90018973    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    90028974    break;
    … …  
    90058977
    90068978/* Line 1806 of yacc.c  */
    9007 #line 2726 "parser.yy"
     8979#line 2723 "parser.yy"
    90088980    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    90098981    break;
    … …  
    90128984
    90138985/* Line 1806 of yacc.c  */
     8986#line 2725 "parser.yy"
     8987    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     8988    break;
     8989
     8990  case 721:
     8991
     8992/* Line 1806 of yacc.c  */
    90148993#line 2728 "parser.yy"
     8994    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     8995    break;
     8996
     8997  case 722:
     8998
     8999/* Line 1806 of yacc.c  */
     9000#line 2730 "parser.yy"
    90159001    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90169002    break;
    90179003
    9018   case 721:
    9019 
    9020 /* Line 1806 of yacc.c  */
    9021 #line 2731 "parser.yy"
    9022     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9023     break;
    9024 
    9025   case 722:
    9026 
    9027 /* Line 1806 of yacc.c  */
    9028 #line 2733 "parser.yy"
     9004  case 723:
     9005
     9006/* Line 1806 of yacc.c  */
     9007#line 2732 "parser.yy"
     9008    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     9009    break;
     9010
     9011  case 724:
     9012
     9013/* Line 1806 of yacc.c  */
     9014#line 2734 "parser.yy"
     9015    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     9016    break;
     9017
     9018  case 725:
     9019
     9020/* Line 1806 of yacc.c  */
     9021#line 2736 "parser.yy"
    90299022    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90309023    break;
    90319024
    9032   case 723:
    9033 
    9034 /* Line 1806 of yacc.c  */
    9035 #line 2735 "parser.yy"
    9036     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    9037     break;
    9038 
    9039   case 724:
    9040 
    9041 /* Line 1806 of yacc.c  */
    9042 #line 2737 "parser.yy"
    9043     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    9044     break;
    9045 
    9046   case 725:
    9047 
    9048 /* Line 1806 of yacc.c  */
    9049 #line 2739 "parser.yy"
     9025  case 726:
     9026
     9027/* Line 1806 of yacc.c  */
     9028#line 2741 "parser.yy"
     9029    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
     9030    break;
     9031
     9032  case 727:
     9033
     9034/* Line 1806 of yacc.c  */
     9035#line 2743 "parser.yy"
     9036    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
     9037    break;
     9038
     9039  case 728:
     9040
     9041/* Line 1806 of yacc.c  */
     9042#line 2748 "parser.yy"
     9043    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
     9044    break;
     9045
     9046  case 729:
     9047
     9048/* Line 1806 of yacc.c  */
     9049#line 2750 "parser.yy"
     9050    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
     9051    break;
     9052
     9053  case 731:
     9054
     9055/* Line 1806 of yacc.c  */
     9056#line 2777 "parser.yy"
     9057    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     9058    break;
     9059
     9060  case 735:
     9061
     9062/* Line 1806 of yacc.c  */
     9063#line 2788 "parser.yy"
     9064    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9065    break;
     9066
     9067  case 736:
     9068
     9069/* Line 1806 of yacc.c  */
     9070#line 2790 "parser.yy"
     9071    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9072    break;
     9073
     9074  case 737:
     9075
     9076/* Line 1806 of yacc.c  */
     9077#line 2792 "parser.yy"
     9078    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9079    break;
     9080
     9081  case 738:
     9082
     9083/* Line 1806 of yacc.c  */
     9084#line 2794 "parser.yy"
     9085    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9086    break;
     9087
     9088  case 739:
     9089
     9090/* Line 1806 of yacc.c  */
     9091#line 2796 "parser.yy"
     9092    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     9093    break;
     9094
     9095  case 740:
     9096
     9097/* Line 1806 of yacc.c  */
     9098#line 2798 "parser.yy"
     9099    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     9100    break;
     9101
     9102  case 741:
     9103
     9104/* Line 1806 of yacc.c  */
     9105#line 2805 "parser.yy"
     9106    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
     9107    break;
     9108
     9109  case 742:
     9110
     9111/* Line 1806 of yacc.c  */
     9112#line 2807 "parser.yy"
     9113    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
     9114    break;
     9115
     9116  case 743:
     9117
     9118/* Line 1806 of yacc.c  */
     9119#line 2809 "parser.yy"
    90509120    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90519121    break;
    90529122
    9053   case 726:
    9054 
    9055 /* Line 1806 of yacc.c  */
    9056 #line 2744 "parser.yy"
    9057     { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    9058     break;
    9059 
    9060   case 727:
    9061 
    9062 /* Line 1806 of yacc.c  */
    9063 #line 2746 "parser.yy"
    9064     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    9065     break;
    9066 
    9067   case 728:
    9068 
    9069 /* Line 1806 of yacc.c  */
    9070 #line 2751 "parser.yy"
    9071     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
    9072     break;
    9073 
    9074   case 729:
    9075 
    9076 /* Line 1806 of yacc.c  */
    9077 #line 2753 "parser.yy"
    9078     { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
    9079     break;
    9080 
    9081   case 731:
    9082 
    9083 /* Line 1806 of yacc.c  */
    9084 #line 2780 "parser.yy"
    9085     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    9086     break;
    9087 
    9088   case 735:
    9089 
    9090 /* Line 1806 of yacc.c  */
    9091 #line 2791 "parser.yy"
    9092     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9093     break;
    9094 
    9095   case 736:
    9096 
    9097 /* Line 1806 of yacc.c  */
    9098 #line 2793 "parser.yy"
    9099     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9100     break;
    9101 
    9102   case 737:
    9103 
    9104 /* Line 1806 of yacc.c  */
    9105 #line 2795 "parser.yy"
    9106     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9107     break;
    9108 
    9109   case 738:
    9110 
    9111 /* Line 1806 of yacc.c  */
    9112 #line 2797 "parser.yy"
    9113     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9114     break;
    9115 
    9116   case 739:
    9117 
    9118 /* Line 1806 of yacc.c  */
    9119 #line 2799 "parser.yy"
    9120     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    9121     break;
    9122 
    9123   case 740:
    9124 
    9125 /* Line 1806 of yacc.c  */
    9126 #line 2801 "parser.yy"
    9127     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    9128     break;
    9129 
    9130   case 741:
    9131 
    9132 /* Line 1806 of yacc.c  */
    9133 #line 2808 "parser.yy"
     9123  case 744:
     9124
     9125/* Line 1806 of yacc.c  */
     9126#line 2811 "parser.yy"
    91349127    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    91359128    break;
    91369129
    9137   case 742:
    9138 
    9139 /* Line 1806 of yacc.c  */
    9140 #line 2810 "parser.yy"
     9130  case 745:
     9131
     9132/* Line 1806 of yacc.c  */
     9133#line 2813 "parser.yy"
    91419134    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    91429135    break;
    91439136
    9144   case 743:
    9145 
    9146 /* Line 1806 of yacc.c  */
    9147 #line 2812 "parser.yy"
     9137  case 746:
     9138
     9139/* Line 1806 of yacc.c  */
     9140#line 2815 "parser.yy"
    91489141    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    91499142    break;
    91509143
    9151   case 744:
    9152 
    9153 /* Line 1806 of yacc.c  */
    9154 #line 2814 "parser.yy"
    9155     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    9156     break;
    9157 
    9158   case 745:
    9159 
    9160 /* Line 1806 of yacc.c  */
    9161 #line 2816 "parser.yy"
    9162     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    9163     break;
    9164 
    9165   case 746:
    9166 
    9167 /* Line 1806 of yacc.c  */
    9168 #line 2818 "parser.yy"
    9169     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    9170     break;
    9171 
    91729144  case 747:
    91739145
    91749146/* Line 1806 of yacc.c  */
    9175 #line 2823 "parser.yy"
     9147#line 2820 "parser.yy"
    91769148    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    91779149    break;
    … …  
    91809152
    91819153/* Line 1806 of yacc.c  */
    9182 #line 2828 "parser.yy"
     9154#line 2825 "parser.yy"
    91839155    { (yyval.decl) = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), (yyvsp[(4) - (5)].decl), nullptr ); }
    91849156    break;
    … …  
    91879159
    91889160/* Line 1806 of yacc.c  */
    9189 #line 2830 "parser.yy"
     9161#line 2827 "parser.yy"
    91909162    { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
    91919163    break;
    … …  
    91949166
    91959167/* Line 1806 of yacc.c  */
    9196 #line 2832 "parser.yy"
     9168#line 2829 "parser.yy"
    91979169    { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
    91989170    break;
    … …  
    92019173
    92029174/* Line 1806 of yacc.c  */
    9203 #line 2856 "parser.yy"
     9175#line 2853 "parser.yy"
    92049176    { (yyval.en) = 0; }
    92059177    break;
    … …  
    92089180
    92099181/* Line 1806 of yacc.c  */
    9210 #line 2858 "parser.yy"
     9182#line 2855 "parser.yy"
    92119183    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    92129184    break;
    … …  
    92159187
    92169188/* Line 1806 of yacc.c  */
    9217 #line 9218 "Parser/parser.cc"
     9189#line 9190 "Parser/parser.cc"
    92189190      default: break;
    92199191    }
    … …  
    94469418
    94479419/* Line 2067 of yacc.c  */
    9448 #line 2861 "parser.yy"
     9420#line 2858 "parser.yy"
    94499421
    94509422// ----end of grammar----

  • src/Parser/parser.yy

    ra1e67dd rfe7b281  
    195195
    196196%type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
    197 %type<en> field field_list field_name
     197%type<en> field field_list
     198%type<tok> field_name
    198199
    199200%type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
    … …  
    378379                { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
    379380        | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
    380                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
    381381        | postfix_expression '.' INTEGERconstant
    382                 { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$3 ) ) ); }
    383382        | postfix_expression ARROW no_attr_identifier
    384383                { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
    385384        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
    386                         { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
    387385        | postfix_expression ICR
    388386                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
    … …  
    420418                // ambiguity with .0 so space required after field-selection, e.g.
    421419                //   struct S { int 0, 1; } s; s. 0 = 0; s. 1 = 1;
     420                { $$ = new ExpressionNode( build_varref( $1 ) ); }
    422421        | field_name '.' field
    423                 { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
     422                { $$ = new ExpressionNode( build_fieldSel( $3, build_varref( $1 ) ) ); }
    424423        | field_name '.' '[' push field_list pop ']'
    425                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
     424                { $$ = new ExpressionNode( build_fieldSel( $5, build_varref( $1 ) ) ); }
    426425        | field_name ARROW field
    427                 { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
     426                { $$ = new ExpressionNode( build_pfieldSel( $3, build_varref( $1 ) ) ); }
    428427        | field_name ARROW '[' push field_list pop ']'
    429                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
     428                { $$ = new ExpressionNode( build_pfieldSel( $5, build_varref( $1 ) ) ); }
    430429        ;
    431430
    432431field_name:
    433432        no_attr_identifier
    434                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
    435433                // x.1, x.[0, 0.0]
    436434        | INTEGERconstant
    437                 { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
    438435        ;
    439436

  • src/ResolvExpr/Alternative.cc

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Alternative.cc --
     7// Alternative.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    1212// Last Modified On : Sat May 16 23:54:23 2015
    1313// Update Count     : 2
    14 //
     14// 
    1515
    1616#include "Alternative.h"
    … …  
    2020
    2121namespace ResolvExpr {
    22         Alternative::Alternative() : cost( Cost::zero ), cvtCost( Cost::zero ), expr( 0 ) {}
     22        Alternative::Alternative() : expr( 0 ) {}
    2323
    2424        Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost )
    … …  
    3535                if ( &other == this ) return *this;
    3636                initialize( other, *this );
    37                 return *this;
    38         }
    39 
    40         Alternative::Alternative( Alternative && other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( other.expr ), env( other.env ) {
    41                 other.expr = nullptr;
    42         }
    43 
    44         Alternative & Alternative::operator=( Alternative && other ) {
    45                 if ( &other == this )  return *this;
    46                 delete expr;
    47                 cost = other.cost;
    48                 cvtCost = other.cvtCost;
    49                 expr = other.expr;
    50                 env = other.env;
    51                 other.expr = nullptr;
    5237                return *this;
    5338        }
    … …  
    6954                        expr->print( os, indent );
    7055                        os << "(types:" << std::endl;
    71                         os << std::string( indent+4, ' ' );
    72                         expr->get_result()->print( os, indent + 4 );
    73                         os << std::endl << ")" << std::endl;
     56                        printAll( expr->get_results(), os, indent + 4 );
     57                        os << ")" << std::endl;
    7458                } else {
    7559                        os << "Null expression!" << std::endl;

  • src/ResolvExpr/Alternative.h

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Alternative.h --
     7// Alternative.h -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    1212// Last Modified On : Sat May 16 23:54:39 2015
    1313// Update Count     : 2
    14 //
     14// 
    1515
    1616#ifndef ALTERNATIVE_H
    … …  
    3232                Alternative( const Alternative &other );
    3333                Alternative &operator=( const Alternative &other );
    34                 Alternative( Alternative && other );
    35                 Alternative &operator=( Alternative && other );
    3634                ~Alternative();
    37 
     35 
    3836                void initialize( const Alternative &src, Alternative &dest );
    39 
     37 
    4038                void print( std::ostream &os, int indent = 0 ) const;
    41 
     39 
    4240                Cost cost;
    4341                Cost cvtCost;

  • src/ResolvExpr/AlternativeFinder.cc

    ra1e67dd rfe7b281  
    3838#include "SynTree/TypeSubstitution.h"
    3939#include "SymTab/Validate.h"
    40 #include "Tuples/Tuples.h"
     40#include "Tuples/TupleAssignment.h"
     41#include "Tuples/NameMatcher.h"
    4142#include "Common/utility.h"
    4243#include "InitTweak/InitTweak.h"
    … …  
    6364        }
    6465
    65         Cost sumCost( const AltList &in ) {
    66                 Cost total;
    67                 for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
    68                         total += i->cost;
    69                 }
    70                 return total;
    71         }
    72 
    7366        namespace {
    7467                void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
    … …  
    8376                                out.push_back( i->expr->clone() );
    8477                        }
     78                }
     79
     80                Cost sumCost( const AltList &in ) {
     81                        Cost total;
     82                        for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
     83                                total += i->cost;
     84                        }
     85                        return total;
    8586                }
    8687
    … …  
    100101                                PruneStruct current( candidate );
    101102                                std::string mangleName;
    102                                 {
    103                                         Type * newType = candidate->expr->get_result()->clone();
     103                                for ( std::list< Type* >::const_iterator retType = candidate->expr->get_results().begin(); retType != candidate->expr->get_results().end(); ++retType ) {
     104                                        Type *newType = (*retType)->clone();
    104105                                        candidate->env.apply( newType );
    105                                         mangleName = SymTab::Mangler::mangle( newType );
     106                                        mangleName += SymTab::Mangler::mangle( newType );
    106107                                        delete newType;
    107108                                }
    … …  
    132133                                if ( ! target->second.isAmbiguous ) {
    133134                                        Alternative &alt = *target->second.candidate;
    134                                         alt.env.applyFree( alt.expr->get_result() );
     135                                        for ( std::list< Type* >::iterator result = alt.expr->get_results().begin(); result != alt.expr->get_results().end(); ++result ) {
     136                                                alt.env.applyFree( *result );
     137                                        }
    135138                                        *out++ = alt;
    136139                                }
    137140                        }
     141
     142                }
     143
     144                template< typename InputIterator, typename OutputIterator >
     145                void findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
     146                        AltList alternatives;
     147
     148                        // select the alternatives that have the minimum parameter cost
     149                        Cost minCost = Cost::infinity;
     150                        for ( AltList::iterator i = begin; i != end; ++i ) {
     151                                if ( i->cost < minCost ) {
     152                                        minCost = i->cost;
     153                                        i->cost = i->cvtCost;
     154                                        alternatives.clear();
     155                                        alternatives.push_back( *i );
     156                                } else if ( i->cost == minCost ) {
     157                                        i->cost = i->cvtCost;
     158                                        alternatives.push_back( *i );
     159                                }
     160                        }
     161                        std::copy( alternatives.begin(), alternatives.end(), out );
     162                }
     163
     164                template< typename InputIterator >
     165                void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
     166                        while ( begin != end ) {
     167                                result.simpleCombine( (*begin++).env );
     168                        }
    138169                }
    139170
    140171                void renameTypes( Expression *expr ) {
    141                         expr->get_result()->accept( global_renamer );
     172                        for ( std::list< Type* >::iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
     173                                (*i)->accept( global_renamer );
     174                        }
    142175                }
    143176        }
    … …  
    171204                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
    172205                        if ( adjust ) {
    173                                 adjustExprType( i->expr->get_result(), i->env, indexer );
     206                                adjustExprTypeList( i->expr->get_results().begin(), i->expr->get_results().end(), i->env, indexer );
    174207                        }
    175208                }
    … …  
    208241
    209242        template< typename StructOrUnionType >
    210         void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
    211 
    212                 // by this point, member must be a name expr
    213                 NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member );
    214                 const std::string & name = nameExpr->get_name();
     243        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name ) {
    215244                std::list< Declaration* > members;
    216245                aggInst->lookup( name, members );
    … …  
    225254        }
    226255
    227         void AlternativeFinder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
    228                 if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) {
    229                         // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning
    230                         // xxx - this should be improved by memoizing the value of constant exprs
    231                         // during parsing and reusing that information here.
    232                         std::stringstream ss( constantExpr->get_constant()->get_value() );
    233                         int val;
    234                         std::string tmp;
    235                         if ( ss >> val && ! (ss >> tmp) ) {
    236                                 if ( val >= 0 && (unsigned int)val < tupleType->size() ) {
    237                                         alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
    238                                 } // if
    239                         } // if
    240                 } // if
    241         }
    242 
    243256        void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) {
    244257                alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
    … …  
    246259
    247260        Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
    248                 ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
    249                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
    250                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
     261                ApplicationExpr *appExpr = dynamic_cast< ApplicationExpr* >( alt.expr );
     262                assert( appExpr );
     263                PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
     264                assert( pointer );
     265                FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
     266                assert( function );
    251267
    252268                Cost convCost( 0, 0, 0 );
    … …  
    254270                std::list< DeclarationWithType* >::iterator formal = formals.begin();
    255271                std::list< Expression* >& actuals = appExpr->get_args();
    256 
    257                 std::list< Type * > formalTypes;
    258                 std::list< Type * >::iterator formalType = formalTypes.end();
    259 
    260272                for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
    261 
    262273                        PRINT(
    263274                                std::cerr << "actual expression:" << std::endl;
    264275                                (*actualExpr)->print( std::cerr, 8 );
    265276                                std::cerr << "--- results are" << std::endl;
    266                                 (*actualExpr)->get_result()->print( std::cerr, 8 );
     277                                printAll( (*actualExpr)->get_results(), std::cerr, 8 );
    267278                        )
    268279                        std::list< DeclarationWithType* >::iterator startFormal = formal;
    269280                        Cost actualCost;
    270                         std::list< Type * > flatActualTypes;
    271                         flatten( (*actualExpr)->get_result(), back_inserter( flatActualTypes ) );
    272                         for ( std::list< Type* >::iterator actualType = flatActualTypes.begin(); actualType != flatActualTypes.end(); ++actualType ) {
    273 
    274 
    275                                 // tuple handling code
    276                                 if ( formalType == formalTypes.end() ) {
    277                                         // the type of the formal parameter may be a tuple type. To make this easier to work with,
    278                                         // flatten the tuple type and traverse the resulting list of types, incrementing the formal
    279                                         // iterator once its types have been extracted. Once a particular formal parameter's type has
    280                                         // been exhausted load the next formal parameter's type.
    281                                         if ( formal == formals.end() ) {
    282                                                 if ( function->get_isVarArgs() ) {
    283                                                         convCost += Cost( 1, 0, 0 );
    284                                                         break;
    285                                                 } else {
    286                                                         return Cost::infinity;
    287                                                 }
     281                        for ( std::list< Type* >::iterator actual = (*actualExpr)->get_results().begin(); actual != (*actualExpr)->get_results().end(); ++actual ) {
     282                                if ( formal == formals.end() ) {
     283                                        if ( function->get_isVarArgs() ) {
     284                                                convCost += Cost( 1, 0, 0 );
     285                                                break;
     286                                        } else {
     287                                                return Cost::infinity;
    288288                                        }
    289                                         formalTypes.clear();
    290                                         flatten( (*formal)->get_type(), back_inserter( formalTypes ) );
    291                                         formalType = formalTypes.begin();
    292                                         ++formal;
    293289                                }
    294 
    295290                                PRINT(
    296291                                        std::cerr << std::endl << "converting ";
    297                                         (*actualType)->print( std::cerr, 8 );
     292                                        (*actual)->print( std::cerr, 8 );
    298293                                        std::cerr << std::endl << " to ";
    299294                                        (*formal)->get_type()->print( std::cerr, 8 );
    300295                                )
    301                                 Cost newCost = conversionCost( *actualType, *formalType, indexer, alt.env );
     296                                Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
    302297                                PRINT(
    303298                                        std::cerr << std::endl << "cost is" << newCost << std::endl;
    … …  
    310305                                actualCost += newCost;
    311306
    312                                 convCost += Cost( 0, polyCost( *formalType, alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
    313 
    314                                 formalType++;
     307                                convCost += Cost( 0, polyCost( (*formal)->get_type(), alt.env, indexer ) + polyCost( *actual, alt.env, indexer ), 0 );
     308
     309                                formal++;
    315310                        }
    316311                        if ( actualCost != Cost( 0, 0, 0 ) ) {
    … …  
    361356        /// Adds type variables to the open variable set and marks their assertions
    362357        void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
    363                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
     358                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
    364359                        unifiableVars[ (*tyvar)->get_name() ] = (*tyvar)->get_kind();
    365360                        for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
    … …  
    370365        }
    371366
    372         /// instantiate a single argument by matching actuals from [actualIt, actualEnd) against formalType,
    373         /// producing expression(s) in out and their total cost in cost.
    374         template< typename AltIterator, typename OutputIterator >
    375         bool instantiateArgument( Type * formalType, Initializer * defaultValue, AltIterator & actualIt, AltIterator actualEnd, OpenVarSet & openVars, TypeEnvironment & resultEnv, AssertionSet & resultNeed, AssertionSet & resultHave, const SymTab::Indexer & indexer, Cost & cost, OutputIterator out ) {
    376                 if ( TupleType * tupleType = dynamic_cast< TupleType * >( formalType ) ) {
    377                         // formalType is a TupleType - group actuals into a TupleExpr whose type unifies with the TupleType
    378                         TupleExpr * tupleExpr = new TupleExpr();
    379                         for ( Type * type : *tupleType ) {
    380                                 if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( tupleExpr->get_exprs() ) ) ) {
    381                                         delete tupleExpr;
    382                                         return false;
    383                                 }
    384                         }
    385                         tupleExpr->set_result( Tuples::makeTupleType( tupleExpr->get_exprs() ) );
    386                         *out++ = tupleExpr;
    387                 } else if ( actualIt != actualEnd ) {
    388                         // both actualType and formalType are atomic (non-tuple) types - if they unify
    389                         // then accept actual as an argument, otherwise return false (fail to instantiate argument)
    390                         Expression * actual = actualIt->expr;
    391                         Type * actualType = actual->get_result();
    392                         PRINT(
    393                                 std::cerr << "formal type is ";
    394                                 formalType->print( std::cerr );
    395                                 std::cerr << std::endl << "actual type is ";
    396                                 actualType->print( std::cerr );
    397                                 std::cerr << std::endl;
    398                         )
    399                         if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
    400                                 return false;
    401                         }
    402                         // move the expression from the alternative to the output iterator
    403                         *out++ = actual;
    404                         actualIt->expr = nullptr;
    405                         cost += actualIt->cost;
    406                         ++actualIt;
    407                 } else {
    408                         // End of actuals - Handle default values
    409                         if ( SingleInit *si = dynamic_cast<SingleInit *>( defaultValue )) {
    410                                 // so far, only constant expressions are accepted as default values
    411                                 if ( ConstantExpr *cnstexpr = dynamic_cast<ConstantExpr *>( si->get_value()) ) {
    412                                         if ( Constant *cnst = dynamic_cast<Constant *>( cnstexpr->get_constant() ) ) {
    413                                                 if ( unify( formalType, cnst->get_type(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
    414                                                         // xxx - Don't know if this is right
    415                                                         *out++ = cnstexpr->clone();
    416                                                         return true;
    417                                                 } // if
    418                                         } // if
    419                                 } // if
    420                         } // if
    421                         return false;
    422                 } // if
    423                 return true;
    424         }
    425 
    426         bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, const AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave, AltList & out ) {
     367        bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave ) {
    427368                simpleCombineEnvironments( actuals.begin(), actuals.end(), resultEnv );
    428369                // make sure we don't widen any existing bindings
    … …  
    432373                resultEnv.extractOpenVars( openVars );
    433374
    434                 // flatten actuals so that each actual has an atomic (non-tuple) type
    435                 AltList exploded;
    436                 Tuples::explode( actuals, back_inserter( exploded ) );
    437 
    438                 AltList::iterator actualExpr = exploded.begin();
    439                 AltList::iterator actualEnd = exploded.end();
    440                 for ( DeclarationWithType * formal : formals ) {
    441                         // match flattened actuals with formal parameters - actuals will be grouped to match
    442                         // with formals as appropriate
    443                         Cost cost;
    444                         std::list< Expression * > newExprs;
    445                         ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
    446                         if ( ! instantiateArgument( obj->get_type(), obj->get_init(), actualExpr, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( newExprs ) ) ) {
    447                                 deleteAll( newExprs );
    448                                 return false;
    449                         }
    450                         // success - produce argument as a new alternative
    451                         assert( newExprs.size() == 1 );
    452                         out.push_back( Alternative( newExprs.front(), resultEnv, cost ) );
    453                 }
    454                 if ( actualExpr != actualEnd ) {
    455                         // there are still actuals remaining, but we've run out of formal parameters to match against
    456                         // this is okay only if the function is variadic
    457                         if ( ! isVarArgs ) {
    458                                 return false;
    459                         }
    460                         out.splice( out.end(), exploded, actualExpr, actualEnd );
     375                /*
     376                  Tuples::NameMatcher matcher( formals );
     377                  try {
     378                  matcher.match( actuals );
     379                  } catch ( Tuples::NoMatch &e ) {
     380                  std::cerr << "Alternative doesn't match: " << e.message << std::endl;
     381                  }
     382                */
     383                std::list< DeclarationWithType* >::iterator formal = formals.begin();
     384                for ( AltList::const_iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
     385                        for ( std::list< Type* >::iterator actual = actualExpr->expr->get_results().begin(); actual != actualExpr->expr->get_results().end(); ++actual ) {
     386                                if ( formal == formals.end() ) {
     387                                        return isVarArgs;
     388                                }
     389                                PRINT(
     390                                        std::cerr << "formal type is ";
     391                                        (*formal)->get_type()->print( std::cerr );
     392                                        std::cerr << std::endl << "actual type is ";
     393                                        (*actual)->print( std::cerr );
     394                                        std::cerr << std::endl;
     395                                )
     396                                if ( ! unify( (*formal)->get_type(), *actual, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
     397                                        return false;
     398                                }
     399                                formal++;
     400                        }
     401                }
     402                // Handling of default values
     403                while ( formal != formals.end() ) {
     404                        if ( ObjectDecl *od = dynamic_cast<ObjectDecl *>( *formal ) )
     405                                if ( SingleInit *si = dynamic_cast<SingleInit *>( od->get_init() ))
     406                                        // so far, only constant expressions are accepted as default values
     407                                        if ( ConstantExpr *cnstexpr = dynamic_cast<ConstantExpr *>( si->get_value()) )
     408                                                if ( Constant *cnst = dynamic_cast<Constant *>( cnstexpr->get_constant() ) )
     409                                                        if ( unify( (*formal)->get_type(), cnst->get_type(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
     410                                                                // XXX Don't know if this is right
     411                                                                actuals.push_back( Alternative( cnstexpr->clone(), env, Cost::zero ) );
     412                                                                formal++;
     413                                                                if ( formal == formals.end()) break;
     414                                                        }
     415                        return false;
    461416                }
    462417                return true;
    … …  
    545500                                //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
    546501                                Expression *varExpr = new VariableExpr( candDecl );
    547                                 delete varExpr->get_result();
    548                                 varExpr->set_result( adjType->clone() );
     502                                deleteAll( varExpr->get_results() );
     503                                varExpr->get_results().clear();
     504                                varExpr->get_results().push_front( adjType->clone() );
    549505                                PRINT(
    550506                                        std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
    … …  
    589545
    590546        template< typename OutputIterator >
    591         void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const AltList &actualAlt, OutputIterator out ) {
     547        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, AltList &actualAlt, OutputIterator out ) {
    592548                OpenVarSet openVars;
    593549                AssertionSet resultNeed, resultHave;
    594550                TypeEnvironment resultEnv;
    595551                makeUnifiableVars( funcType, openVars, resultNeed );
    596                 AltList instantiatedActuals; // filled by instantiate function
    597                 if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave, instantiatedActuals ) ) {
     552                if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave ) ) {
    598553                        ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
    599                         Alternative newAlt( appExpr, resultEnv, sumCost( instantiatedActuals ) );
    600                         makeExprList( instantiatedActuals, appExpr->get_args() );
     554                        Alternative newAlt( appExpr, resultEnv, sumCost( actualAlt ) );
     555                        makeExprList( actualAlt, appExpr->get_args() );
    601556                        PRINT(
    602557                                std::cerr << "need assertions:" << std::endl;
    … …  
    619574                                PointerType pt( Type::Qualifiers(), v.clone() );
    620575                                UntypedExpr *vexpr = untypedExpr->clone();
    621                                 vexpr->set_result( pt.clone() );
     576                                vexpr->get_results().push_front( pt.clone() );
    622577                                alternatives.push_back( Alternative( vexpr, env, Cost()) );
    623578                                return;
    … …  
    632587                combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
    633588
    634                 // take care of possible tuple assignments
    635                 // if not tuple assignment, assignment is taken care of as a normal function call
    636                 Tuples::handleTupleAssignment( *this, untypedExpr, possibilities );
     589                Tuples::TupleAssignSpotter tassign( this );
     590                if ( tassign.isTupleAssignment( untypedExpr, possibilities ) ) {
     591                        // take care of possible tuple assignments, or discard expression
     592                        return;
     593                } // else ...
    637594
    638595                AltList candidates;
    … …  
    647604                                // check if the type is pointer to function
    648605                                PointerType *pointer;
    649                                 if ( ( pointer = dynamic_cast< PointerType* >( func->expr->get_result() ) ) ) {
     606                                if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
    650607                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
    651608                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
    … …  
    683640                                                // check if the type is pointer to function
    684641                                                PointerType *pointer;
    685                                                 if ( ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result() ) ) ) {
     642                                                if ( funcOp->expr->get_results().size() == 1
     643                                                        && ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_results().front() ) ) ) {
    686644                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
    687645                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
    … …  
    707665
    708666                        PRINT(
    709                                 ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( withFunc->expr );
    710                                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
    711                                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
     667                                ApplicationExpr *appExpr = dynamic_cast< ApplicationExpr* >( withFunc->expr );
     668                                assert( appExpr );
     669                                PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
     670                                assert( pointer );
     671                                FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
     672                                assert( function );
    712673                                std::cerr << "Case +++++++++++++" << std::endl;
    713674                                std::cerr << "formals are:" << std::endl;
    … …  
    731692
    732693        bool isLvalue( Expression *expr ) {
    733                 // xxx - recurse into tuples?
    734                 return expr->has_result() && expr->get_result()->get_isLvalue();
     694                for ( std::list< Type* >::const_iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
     695                        if ( !(*i)->get_isLvalue() ) return false;
     696                } // for
     697                return true;
    735698        }
    736699
    … …  
    746709
    747710        void AlternativeFinder::visit( CastExpr *castExpr ) {
    748                 Type *& toType = castExpr->get_result();
    749                 toType = resolveTypeof( toType, indexer );
    750                 SymTab::validateType( toType, &indexer );
    751                 adjustExprType( toType, env, indexer );
     711                for ( std::list< Type* >::iterator i = castExpr->get_results().begin(); i != castExpr->get_results().end(); ++i ) {
     712                        *i = resolveTypeof( *i, indexer );
     713                        SymTab::validateType( *i, &indexer );
     714                        adjustExprType( *i, env, indexer );
     715                } // for
    752716
    753717                AlternativeFinder finder( indexer, env );
    … …  
    763727                        // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
    764728                        // to.
    765                         int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
     729                        int discardedValues = (*i).expr->get_results().size() - castExpr->get_results().size();
    766730                        if ( discardedValues < 0 ) continue;
    767                         // xxx - may need to go into tuple types and extract relavent types and use unifyList
     731                        std::list< Type* >::iterator candidate_end = (*i).expr->get_results().begin();
     732                        std::advance( candidate_end, castExpr->get_results().size() );
    768733                        // unification run for side-effects
    769                         unify( castExpr->get_result(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
    770                         Cost thisCost = castCost( (*i).expr->get_result(), castExpr->get_result(), indexer, i->env );
     734                        unifyList( castExpr->get_results().begin(), castExpr->get_results().end(),
     735                                           (*i).expr->get_results().begin(), candidate_end,
     736                                   i->env, needAssertions, haveAssertions, openVars, indexer );
     737                        Cost thisCost = castCostList( (*i).expr->get_results().begin(), candidate_end,
     738                                                                                  castExpr->get_results().begin(), castExpr->get_results().end(),
     739                                                                                  indexer, i->env );
    771740                        if ( thisCost != Cost::infinity ) {
    772741                                // count one safe conversion for each value that is thrown away
    … …  
    791760
    792761                for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
    793                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
    794                                 addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    795                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) {
    796                                 addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    797                         } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( agg->expr->get_result() ) ) {
    798                                 addTupleMembers( tupleType, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
     762                        if ( agg->expr->get_results().size() == 1 ) {
     763                                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
     764                                        addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
     765                                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
     766                                        addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
     767                                } // if
    799768                        } // if
    800769                } // for
    … …  
    822791                        renameTypes( alternatives.back().expr );
    823792                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
    824                                 NameExpr nameExpr( "" );
    825                                 addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
     793                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
    826794                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
    827                                 NameExpr nameExpr( "" );
    828                                 addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
     795                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
    829796                        } // if
    830797                } // for
    … …  
    927894                        alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
    928895                        for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
    929                                 alternatives.back().expr->set_result( (*i)->get_type()->clone() );
     896                                alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
    930897                        } // for
    931898                } // if
    … …  
    950917                                                        finder.find( attrExpr->get_expr() );
    951918                                                        for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
    952                                                                 if ( choice->expr->get_result()->size() == 1 ) {
    953                                                                         resolveAttr(*i, function, choice->expr->get_result(), choice->env );
     919                                                                if ( choice->expr->get_results().size() == 1 ) {
     920                                                                        resolveAttr(*i, function, choice->expr->get_results().front(), choice->env );
    954921                                                                } // fi
    955922                                                        } // for
    … …  
    993960                                        AssertionSet needAssertions, haveAssertions;
    994961                                        Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );
    995                                         Type* commonType;
    996                                         if ( unify( second->expr->get_result(), third->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
     962                                        std::list< Type* > commonTypes;
     963                                        if ( unifyList( second->expr->get_results().begin(), second->expr->get_results().end(), third->expr->get_results().begin(), third->expr->get_results().end(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonTypes ) ) {
    997964                                                ConditionalExpr *newExpr = new ConditionalExpr( first->expr->clone(), second->expr->clone(), third->expr->clone() );
    998                                                 newExpr->set_result( commonType ? commonType : second->expr->get_result()->clone() );
     965                                                std::list< Type* >::const_iterator original = second->expr->get_results().begin();
     966                                                std::list< Type* >::const_iterator commonType = commonTypes.begin();
     967                                                for ( ; original != second->expr->get_results().end() && commonType != commonTypes.end(); ++original, ++commonType ) {
     968                                                        if ( *commonType ) {
     969                                                                newExpr->get_results().push_back( *commonType );
     970                                                        } else {
     971                                                                newExpr->get_results().push_back( (*original)->clone() );
     972                                                        } // if
     973                                                } // for
    999974                                                newAlt.expr = newExpr;
    1000975                                                inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );
    … …  
    1024999                        TupleExpr *newExpr = new TupleExpr;
    10251000                        makeExprList( *i, newExpr->get_exprs() );
    1026                         newExpr->set_result( Tuples::makeTupleType( newExpr->get_exprs() ) );
     1001                        for ( std::list< Expression* >::const_iterator resultExpr = newExpr->get_exprs().begin(); resultExpr != newExpr->get_exprs().end(); ++resultExpr ) {
     1002                                for ( std::list< Type* >::const_iterator resultType = (*resultExpr)->get_results().begin(); resultType != (*resultExpr)->get_results().end(); ++resultType ) {
     1003                                        newExpr->get_results().push_back( (*resultType)->clone() );
     1004                                } // for
     1005                        } // for
    10271006
    10281007                        TypeEnvironment compositeEnv;
    … …  
    10451024                }
    10461025        }
    1047 
    1048         void AlternativeFinder::visit( TupleIndexExpr *tupleExpr ) {
    1049                 alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
    1050         }
    1051 
    1052         void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) {
    1053                 alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
    1054         }
    1055 
    1056         void AlternativeFinder::visit( UniqueExpr *unqExpr ) {
    1057                 AlternativeFinder finder( indexer, env );
    1058                 finder.findWithAdjustment( unqExpr->get_expr() );
    1059                 for ( Alternative & alt : finder.alternatives ) {
    1060                         // xxx - it's possible that this won't always do the right thing, i.e. two UniqueExprs
    1061                         // with the same ID may resolve to different expressions. If this ever happens, it might be necessary
    1062                         // to try to select an alternative here (i.e. error is there is not a unique min-cost expression).
    1063                         // One other thought is to to resolve each ID once and map the IDs to resolved expressions,
    1064                         // but this isn't as simple as it sounds since the alternative is not selected here, meaning it might
    1065                         // require complicated tracking throughout the system.
    1066 
    1067                         // brand the new UniqueExprs with the same id so that they are recognized as the same expression by the expansion pass
    1068                         alternatives.push_back( Alternative( new UniqueExpr( alt.expr->clone(), unqExpr->get_id() ), env, Cost::zero ) );
    1069                 }
    1070         }
    1071 
    10721026} // namespace ResolvExpr
    10731027

  • src/ResolvExpr/AlternativeFinder.h

    ra1e67dd rfe7b281  
    6767                virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
    6868                virtual void visit( ConstructorExpr * ctorExpr );
    69                 virtual void visit( TupleIndexExpr *tupleExpr );
    70                 virtual void visit( TupleAssignExpr *tupleExpr );
    71                 virtual void visit( UniqueExpr *unqExpr );
    72                 /// Runs a new alternative finder on each element in [begin, end)
    73                 /// and writes each alternative finder to out.
     69          public:  // xxx - temporary hack - should make Tuples::TupleAssignment a friend
    7470                template< typename InputIterator, typename OutputIterator >
    7571                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
    7672
     73          private:
    7774                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
    78                 template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
    79                 /// Adds alternatives for member expressions where the left side has tuple type
    80                 void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
     75                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name );
    8176                /// Adds alternatives for offsetof expressions, given the base type and name of the member
    8277                template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
    83                 bool instantiateFunction( std::list< DeclarationWithType* >& formals, const AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave, AltList & out );
     78                bool instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave );
    8479                template< typename OutputIterator >
    85                 void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const AltList &actualAlt, OutputIterator out );
     80                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, AltList &actualAlt, OutputIterator out );
    8681                template< typename OutputIterator >
    8782                void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
    … …  
    9489
    9590        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
    96 
    97         template< typename InputIterator, typename OutputIterator >
    98         void findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
    99                 AltList alternatives;
    100 
    101                 // select the alternatives that have the minimum parameter cost
    102                 Cost minCost = Cost::infinity;
    103                 for ( InputIterator i = begin; i != end; ++i ) {
    104                         if ( i->cost < minCost ) {
    105                                 minCost = i->cost;
    106                                 i->cost = i->cvtCost;
    107                                 alternatives.clear();
    108                                 alternatives.push_back( *i );
    109                         } else if ( i->cost == minCost ) {
    110                                 i->cost = i->cvtCost;
    111                                 alternatives.push_back( *i );
    112                         }
    113                 }
    114                 std::copy( alternatives.begin(), alternatives.end(), out );
    115         }
    116 
    117         Cost sumCost( const AltList &in );
    118 
    119         template< typename InputIterator >
    120         void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
    121                 while ( begin != end ) {
    122                         result.simpleCombine( (*begin++).env );
    123                 }
    124         }
    12591} // namespace ResolvExpr
    12692

  • src/ResolvExpr/AlternativePrinter.cc

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // AlternativePrinter.cc --
     7// AlternativePrinter.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    3333                for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
    3434                        os << "Alternative " << count++ << " ==============" << std::endl;
    35                         i->expr->get_result()->print( os );
     35                        printAll( i->expr->get_results(), os );
    3636                        //    i->print( os );
    3737                        os << std::endl;

  • src/ResolvExpr/ConversionCost.cc

    ra1e67dd rfe7b281  
    240240                        std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
    241241                        std::list< Type* >::const_iterator destIt = destAsTuple->get_types().begin();
    242                         while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
     242                        while ( srcIt != tupleType->get_types().end() ) {
    243243                                Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
    244244                                if ( newCost == Cost::infinity ) {

  • src/ResolvExpr/FindOpenVars.cc

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // FindOpenVars.cc --
     7// FindOpenVars.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    4747        void FindOpenVars::common_action( Type *type ) {
    4848                if ( nextIsOpen ) {
    49                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
     49                        for ( std::list< TypeDecl* >::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
    5050                                openVars[ (*i)->get_name() ] = (*i)->get_kind();
    5151                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
    … …  
    5656                        }
    5757                } else {
    58                         for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
     58                        for ( std::list< TypeDecl* >::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
    5959                                closedVars[ (*i)->get_name() ] = (*i)->get_kind();
    6060                                for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {

  • src/ResolvExpr/RenameVars.cc

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // RenameVars.cc --
     7// RenameVars.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    125125                        mapStack.push_front( mapStack.front() );
    126126                        // renames all "forall" type names to `_${level}_${name}'
    127                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
     127                        for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
    128128                                std::ostringstream output;
    129129                                output << "_" << level << "_" << (*i)->get_name();

  • src/ResolvExpr/ResolveTypeof.cc

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // ResolveTypeof.cc --
     7// ResolveTypeof.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    5858                if ( typeofType->get_expr() ) {
    5959                        Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer );
    60                         assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
    61                         Type *newType = newExpr->get_result();
     60                        assert( newExpr->get_results().size() > 0 );
     61                        Type *newType;
     62                        if ( newExpr->get_results().size() > 1 ) {
     63                                TupleType *tupleType = new TupleType( Type::Qualifiers() );
     64                                cloneAll( newExpr->get_results(), tupleType->get_types() );
     65                                newType = tupleType;
     66                        } else {
     67                                newType = newExpr->get_results().front()->clone();
     68                        } // if
    6269                        delete typeofType;
    6370                        return newType;

  • src/ResolvExpr/Resolver.cc

    ra1e67dd rfe7b281  
    1919#include "RenameVars.h"
    2020#include "ResolveTypeof.h"
    21 #include "typeops.h"
    2221#include "SynTree/Statement.h"
    2322#include "SynTree/Type.h"
    … …  
    3837
    3938                virtual void visit( FunctionDecl *functionDecl );
    40                 virtual void visit( ObjectDecl *objectDecl );
     39                virtual void visit( ObjectDecl *functionDecl );
    4140                virtual void visit( TypeDecl *typeDecl );
    4241                virtual void visit( EnumDecl * enumDecl );
    … …  
    6867          void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
    6968          void fallbackInit( ConstructorInit * ctorInit );
    70                 Type * functionReturn;
     69                std::list< Type * > functionReturn;
    7170                Type *initContext;
    7271                Type *switchType;
    … …  
    158157                        const TypeEnvironment *newEnv = 0;
    159158                        for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
    160                                 if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) {
     159                                if ( i->expr->get_results().size() == 1 && isIntegralType( i->expr->get_results().front() ) ) {
    161160                                        if ( newExpr ) {
    162161                                                throw SemanticError( "Too many interpretations for case control expression", untyped );
    … …  
    235234                Type *new_type = resolveTypeof( functionDecl->get_type(), *this );
    236235                functionDecl->set_type( new_type );
    237                 ValueGuard< Type * > oldFunctionReturn( functionReturn );
    238                 functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
     236                std::list< Type * > oldFunctionReturn = functionReturn;
     237                functionReturn.clear();
     238                for ( std::list< DeclarationWithType * >::const_iterator i = functionDecl->get_functionType()->get_returnVals().begin(); i != functionDecl->get_functionType()->get_returnVals().end(); ++i ) {
     239                        functionReturn.push_back( (*i)->get_type() );
     240                } // for
    239241                SymTab::Indexer::visit( functionDecl );
     242                functionReturn = oldFunctionReturn;
    240243        }
    241244
    … …  
    335338        void Resolver::visit( ReturnStmt *returnStmt ) {
    336339                if ( returnStmt->get_expr() ) {
    337                         CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
     340                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr() );
     341                        cloneAll( functionReturn, castExpr->get_results() );
    338342                        Expression *newExpr = findSingleExpression( castExpr, *this );
    339343                        delete castExpr;
    … …  
    380384                                if ( isCharType( at->get_base() ) ) {
    381385                                        // check if the resolved type is char *
    382                                         if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
     386                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_results().front() ) ) {
    383387                                                if ( isCharType( pt->get_base() ) ) {
    384388                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
    … …  
    442446                                (*iter)->accept( *this );
    443447                        } // for
    444                 } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) {
    445                         for ( Type * t : *tt ) {
    446                                 if ( iter == end ) break;
    447                                 initContext = t;
    448                                 (*iter++)->accept( *this );
    449                         }
    450448                } else if ( StructInstType * st = dynamic_cast< StructInstType * >( initContext ) ) {
    451449                        resolveAggrInit( st->get_baseStruct(), iter, end );

  • src/ResolvExpr/TypeEnvironment.cc

    ra1e67dd rfe7b281  
    158158        }
    159159
    160         void TypeEnvironment::add( const Type::ForallList &tyDecls ) {
    161                 for ( Type::ForallList::const_iterator i = tyDecls.begin(); i != tyDecls.end(); ++i ) {
     160        void TypeEnvironment::add( const std::list< TypeDecl* > &tyDecls ) {
     161                for ( std::list< TypeDecl* >::const_iterator i = tyDecls.begin(); i != tyDecls.end(); ++i ) {
    162162                        EqvClass newClass;
    163163                        newClass.vars.insert( (*i)->get_name() );

  • src/ResolvExpr/TypeEnvironment.h

    ra1e67dd rfe7b281  
    5555                bool lookup( const std::string &var, EqvClass &eqvClass ) const;
    5656                void add( const EqvClass &eqvClass );
    57                 void add( const Type::ForallList &tyDecls );
     57                void add( const std::list< TypeDecl* > &tyDecls );
    5858                template< typename SynTreeClass > int apply( SynTreeClass *&type ) const;
    5959                template< typename SynTreeClass > int applyFree( SynTreeClass *&type ) const;

  • src/ResolvExpr/Unify.cc

    ra1e67dd rfe7b281  
    598598        }
    599599
    600         // xxx - compute once and store in the FunctionType?
    601         Type * extractResultType( FunctionType * function ) {
    602                 if ( function->get_returnVals().size() == 0 ) {
    603                         return new VoidType( Type::Qualifiers() );
    604                 } else if ( function->get_returnVals().size() == 1 ) {
    605                         return function->get_returnVals().front()->get_type()->clone();
    606                 } else {
    607                         TupleType * tupleType = new TupleType( Type::Qualifiers() );
    608                         for ( DeclarationWithType * decl : function->get_returnVals() ) {
    609                                 tupleType->get_types().push_back( decl->get_type()->clone() );
    610                         } // for
    611                         return tupleType;
    612                 }
    613         }
    614600} // namespace ResolvExpr
    615601

  • src/ResolvExpr/typeops.h

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // typeops.h --
     7// typeops.h -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    3030                typedef typename InputIterator::value_type SetType;
    3131                typedef typename std::list< typename SetType::value_type > ListType;
    32 
     32 
    3333                if ( begin == end )     {
    3434                        *out++ = ListType();
    3535                        return;
    3636                } // if
    37 
     37 
    3838                InputIterator current = begin;
    3939                begin++;
    … …  
    4141                std::list< ListType > recursiveResult;
    4242                combos( begin, end, back_inserter( recursiveResult ) );
    43 
     43 
    4444                for ( typename std::list< ListType >::const_iterator i = recursiveResult.begin(); i != recursiveResult.end(); ++i ) {
    4545                        for ( typename ListType::const_iterator j = current->begin(); j != current->end(); ++j ) {
    … …  
    5252                } // for
    5353        }
    54 
     54 
    5555        // in AdjustExprType.cc
    5656        /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
    … …  
    144144        }
    145145
    146         /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
    147         Type * extractResultType( FunctionType * functionType );
    148 
    149146        // in CommonType.cc
    150147        Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
    … …  
    155152        // in Occurs.cc
    156153        bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
    157 
    158         // flatten tuple type into list of types
    159         template< typename OutputIterator >
    160         void flatten( Type * type, OutputIterator out ) {
    161                 if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
    162                         for ( Type * t : tupleType->get_types() ) {
    163                                 flatten( t, out );
    164                         }
    165                 } else {
    166                         *out++ = type;
    167                 }
    168         }
    169154} // namespace ResolvExpr
    170155

  • src/SymTab/Autogen.cc

    ra1e67dd rfe7b281  
    116116                // This happens before function pointer type conversion, so need to do it manually here
    117117                VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
    118                 Type * assignVarExprType = assignVarExpr->get_result();
     118                Type *& assignVarExprType = assignVarExpr->get_results().front();
    119119                assignVarExprType = new PointerType( Type::Qualifiers(), assignVarExprType );
    120                 assignVarExpr->set_result( assignVarExprType );
    121120                ApplicationExpr * assignExpr = new ApplicationExpr( assignVarExpr );
    122121                assignExpr->get_args().push_back( new VariableExpr( dstParam ) );

  • src/SymTab/Indexer.cc

    ra1e67dd rfe7b281  
    4040
    4141namespace SymTab {
    42         template< typename TreeType, typename VisitorType >
    43         inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
     42        template< typename Container, typename VisitorType >
     43        inline void acceptAllNewScope( Container &container, VisitorType &visitor ) {
    4444                visitor.enterScope();
    45                 maybeAccept( tree, visitor );
     45                acceptAll( container, visitor );
    4646                visitor.leaveScope();
    4747        }
    … …  
    143143                for ( DeclarationWithType * decl : copy ) {
    144144                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ) ) {
    145                                 std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
     145                                std::list< DeclarationWithType * > params = function->get_functionType()->get_parameters();
    146146                                assert( ! params.empty() );
    147147                                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
    … …  
    337337
    338338        void Indexer::visit( ApplicationExpr *applicationExpr ) {
    339                 acceptNewScope( applicationExpr->get_result(), *this );
     339                acceptAllNewScope( applicationExpr->get_results(), *this );
    340340                maybeAccept( applicationExpr->get_function(), *this );
    341341                acceptAll( applicationExpr->get_args(), *this );
    … …  
    343343
    344344        void Indexer::visit( UntypedExpr *untypedExpr ) {
    345                 acceptNewScope( untypedExpr->get_result(), *this );
     345                acceptAllNewScope( untypedExpr->get_results(), *this );
    346346                acceptAll( untypedExpr->get_args(), *this );
    347347        }
    348348
    349349        void Indexer::visit( NameExpr *nameExpr ) {
    350                 acceptNewScope( nameExpr->get_result(), *this );
     350                acceptAllNewScope( nameExpr->get_results(), *this );
    351351        }
    352352
    353353        void Indexer::visit( AddressExpr *addressExpr ) {
    354                 acceptNewScope( addressExpr->get_result(), *this );
     354                acceptAllNewScope( addressExpr->get_results(), *this );
    355355                maybeAccept( addressExpr->get_arg(), *this );
    356356        }
    357357
    358358        void Indexer::visit( LabelAddressExpr *labAddressExpr ) {
    359                 acceptNewScope( labAddressExpr->get_result(), *this );
     359                acceptAllNewScope( labAddressExpr->get_results(), *this );
    360360                maybeAccept( labAddressExpr->get_arg(), *this );
    361361        }
    362362
    363363        void Indexer::visit( CastExpr *castExpr ) {
    364                 acceptNewScope( castExpr->get_result(), *this );
     364                acceptAllNewScope( castExpr->get_results(), *this );
    365365                maybeAccept( castExpr->get_arg(), *this );
    366366        }
    367367
    368368        void Indexer::visit( UntypedMemberExpr *memberExpr ) {
    369                 acceptNewScope( memberExpr->get_result(), *this );
     369                acceptAllNewScope( memberExpr->get_results(), *this );
    370370                maybeAccept( memberExpr->get_aggregate(), *this );
    371371        }
    372372
    373373        void Indexer::visit( MemberExpr *memberExpr ) {
    374                 acceptNewScope( memberExpr->get_result(), *this );
     374                acceptAllNewScope( memberExpr->get_results(), *this );
    375375                maybeAccept( memberExpr->get_aggregate(), *this );
    376376        }
    377377
    378378        void Indexer::visit( VariableExpr *variableExpr ) {
    379                 acceptNewScope( variableExpr->get_result(), *this );
     379                acceptAllNewScope( variableExpr->get_results(), *this );
    380380        }
    381381
    382382        void Indexer::visit( ConstantExpr *constantExpr ) {
    383                 acceptNewScope( constantExpr->get_result(), *this );
     383                acceptAllNewScope( constantExpr->get_results(), *this );
    384384                maybeAccept( constantExpr->get_constant(), *this );
    385385        }
    386386
    387387        void Indexer::visit( SizeofExpr *sizeofExpr ) {
    388                 acceptNewScope( sizeofExpr->get_result(), *this );
     388                acceptAllNewScope( sizeofExpr->get_results(), *this );
    389389                if ( sizeofExpr->get_isType() ) {
    390390                        maybeAccept( sizeofExpr->get_type(), *this );
    … …  
    395395
    396396        void Indexer::visit( AlignofExpr *alignofExpr ) {
    397                 acceptNewScope( alignofExpr->get_result(), *this );
     397                acceptAllNewScope( alignofExpr->get_results(), *this );
    398398                if ( alignofExpr->get_isType() ) {
    399399                        maybeAccept( alignofExpr->get_type(), *this );
    … …  
    404404
    405405        void Indexer::visit( UntypedOffsetofExpr *offsetofExpr ) {
    406                 acceptNewScope( offsetofExpr->get_result(), *this );
     406                acceptAllNewScope( offsetofExpr->get_results(), *this );
    407407                maybeAccept( offsetofExpr->get_type(), *this );
    408408        }
    409409
    410410        void Indexer::visit( OffsetofExpr *offsetofExpr ) {
    411                 acceptNewScope( offsetofExpr->get_result(), *this );
     411                acceptAllNewScope( offsetofExpr->get_results(), *this );
    412412                maybeAccept( offsetofExpr->get_type(), *this );
    413413                maybeAccept( offsetofExpr->get_member(), *this );
    … …  
    415415
    416416        void Indexer::visit( OffsetPackExpr *offsetPackExpr ) {
    417                 acceptNewScope( offsetPackExpr->get_result(), *this );
     417                acceptAllNewScope( offsetPackExpr->get_results(), *this );
    418418                maybeAccept( offsetPackExpr->get_type(), *this );
    419419        }
    420420
    421421        void Indexer::visit( AttrExpr *attrExpr ) {
    422                 acceptNewScope( attrExpr->get_result(), *this );
     422                acceptAllNewScope( attrExpr->get_results(), *this );
    423423                if ( attrExpr->get_isType() ) {
    424424                        maybeAccept( attrExpr->get_type(), *this );
    … …  
    429429
    430430        void Indexer::visit( LogicalExpr *logicalExpr ) {
    431                 acceptNewScope( logicalExpr->get_result(), *this );
     431                acceptAllNewScope( logicalExpr->get_results(), *this );
    432432                maybeAccept( logicalExpr->get_arg1(), *this );
    433433                maybeAccept( logicalExpr->get_arg2(), *this );
    … …  
    435435
    436436        void Indexer::visit( ConditionalExpr *conditionalExpr ) {
    437                 acceptNewScope( conditionalExpr->get_result(), *this );
     437                acceptAllNewScope( conditionalExpr->get_results(), *this );
    438438                maybeAccept( conditionalExpr->get_arg1(), *this );
    439439                maybeAccept( conditionalExpr->get_arg2(), *this );
    … …  
    442442
    443443        void Indexer::visit( CommaExpr *commaExpr ) {
    444                 acceptNewScope( commaExpr->get_result(), *this );
     444                acceptAllNewScope( commaExpr->get_results(), *this );
    445445                maybeAccept( commaExpr->get_arg1(), *this );
    446446                maybeAccept( commaExpr->get_arg2(), *this );
    … …  
    448448
    449449        void Indexer::visit( TupleExpr *tupleExpr ) {
    450                 acceptNewScope( tupleExpr->get_result(), *this );
     450                acceptAllNewScope( tupleExpr->get_results(), *this );
    451451                acceptAll( tupleExpr->get_exprs(), *this );
    452452        }
    453453
    454         void Indexer::visit( TupleAssignExpr *tupleExpr ) {
    455                 acceptNewScope( tupleExpr->get_result(), *this );
    456                 enterScope();
    457                 acceptAll( tupleExpr->get_tempDecls(), *this );
    458                 acceptAll( tupleExpr->get_assigns(), *this );
    459                 leaveScope();
     454        void Indexer::visit( SolvedTupleExpr *tupleExpr ) {
     455                acceptAllNewScope( tupleExpr->get_results(), *this );
     456                acceptAll( tupleExpr->get_exprs(), *this );
    460457        }
    461458
    462459        void Indexer::visit( TypeExpr *typeExpr ) {
    463                 acceptNewScope( typeExpr->get_result(), *this );
     460                acceptAllNewScope( typeExpr->get_results(), *this );
    464461                maybeAccept( typeExpr->get_type(), *this );
    465462        }
    … …  
    472469
    473470        void Indexer::visit( UntypedValofExpr *valofExpr ) {
    474                 acceptNewScope( valofExpr->get_result(), *this );
     471                acceptAllNewScope( valofExpr->get_results(), *this );
    475472                maybeAccept( valofExpr->get_body(), *this );
    476473        }

  • src/SymTab/Indexer.h

    ra1e67dd rfe7b281  
    6464                virtual void visit( ConditionalExpr *conditionalExpr );
    6565                virtual void visit( CommaExpr *commaExpr );
     66                virtual void visit( TupleExpr *tupleExpr );
     67                virtual void visit( SolvedTupleExpr *tupleExpr );
    6668                virtual void visit( TypeExpr *typeExpr );
    6769                virtual void visit( AsmExpr *asmExpr );
    6870                virtual void visit( UntypedValofExpr *valofExpr );
    69                 virtual void visit( TupleExpr *tupleExpr );
    70                 virtual void visit( TupleAssignExpr *tupleExpr );
    7171
    7272                virtual void visit( TraitInstType *contextInst );

  • src/SymTab/Mangler.cc

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // Mangler.cc --
     7// Mangler.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    3535                return mangler.get_mangleName();
    3636        }
    37 
     37       
    3838        Mangler::Mangler( bool mangleOverridable, bool typeMode )
    3939                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {}
    40 
     40               
    4141        Mangler::Mangler( const Mangler &rhs ) : mangleName() {
    4242                varNums = rhs.varNums;
    … …  
    115115                        "Ir",   // LongDoubleImaginary
    116116                };
    117 
     117 
    118118                printQualifiers( basicType );
    119119                mangleName << btLetter[ basicType->get_kind() ];
    … …  
    253253                // skip if not including qualifiers
    254254                if ( typeMode ) return;
    255 
     255               
    256256                if ( ! type->get_forall().empty() ) {
    257257                        std::list< std::string > assertionNames;
    258258                        int tcount = 0, dcount = 0, fcount = 0;
    259259                        mangleName << "A";
    260                         for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
     260                        for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
    261261                                switch ( (*i)->get_kind() ) {
    262262                                  case TypeDecl::Any:

  • src/SymTab/Validate.cc

    ra1e67dd rfe7b281  
    2323// - All enumeration constants have type EnumInstType.
    2424//
    25 // - The type "void" never occurs in lists of function parameter or return types.  A function
    26 //   taking no arguments has no argument types.
     25// - The type "void" never occurs in lists of function parameter or return types; neither do tuple types.  A function
     26//   taking no arguments has no argument types, and tuples are flattened.
    2727//
    2828// - No context instances exist; they are all replaced by the set of declarations signified by the context, instantiated
    … …  
    429429        /// Fix up assertions
    430430        void forallFixer( Type *func ) {
    431                 for ( Type::ForallList::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
     431                for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
    432432                        std::list< DeclarationWithType * > toBeDone, nextRound;
    433433                        toBeDone.splice( toBeDone.end(), (*type )->get_assertions() );

  • src/SynTree/AddressExpr.cc

    ra1e67dd rfe7b281  
    1919
    2020AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
    21         if ( arg->has_result() ) {
    22                 set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
    23         }
     21        for ( std::list< Type* >::const_iterator i = arg->get_results().begin(); i != arg->get_results().end(); ++i ) {
     22                get_results().push_back( new PointerType( Type::Qualifiers(), (*i)->clone() ) );
     23        } // for
    2424}
    2525
    … …  
    3535        if ( arg ) {
    3636                os << std::string( indent+2, ' ' );
    37                 arg->print( os, indent+2 );
     37    arg->print( os, indent+2 );
    3838        } // if
    3939}

  • src/SynTree/ApplicationExpr.cc

    ra1e67dd rfe7b281  
    2121#include "TypeSubstitution.h"
    2222#include "Common/utility.h"
    23 #include "ResolvExpr/typeops.h"
     23
    2424
    2525ParamEntry::ParamEntry( const ParamEntry &other ) :
    … …  
    4343
    4444ApplicationExpr::ApplicationExpr( Expression *funcExpr ) : function( funcExpr ) {
    45         PointerType *pointer = safe_dynamic_cast< PointerType* >( funcExpr->get_result() );
    46         FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
     45        PointerType *pointer = dynamic_cast< PointerType* >( funcExpr->get_results().front() );
     46        assert( pointer );
     47        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
     48        assert( function );
    4749
    48         set_result( ResolvExpr::extractResultType( function ) );
    49 
    50         assert( has_result() );
     50        for ( std::list< DeclarationWithType* >::const_iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
     51                get_results().push_back( (*i)->get_type()->clone() );
     52        } // for
    5153}
    5254

  • src/SynTree/CommaExpr.cc

    ra1e67dd rfe7b281  
    2323        // to false on all result types. Actually doing this causes some strange things
    2424        // to happen in later passes (particularly, Specialize, Lvalue, and Box). This needs to be looked into.
    25         set_result( maybeClone( arg2->get_result() ) );
    26         // get_type->set_isLvalue( false );
     25        cloneAll( arg2->get_results(), get_results() );
     26        // for ( Type *& type : get_results() ) {
     27        //      type->set_isLvalue( false );
     28        // }
    2729}
    2830

  • src/SynTree/Expression.cc

    ra1e67dd rfe7b281  
    3131
    3232
    33 Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
    34 
    35 Expression::Expression( const Expression &other ) : result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
     33Expression::Expression( Expression *_aname ) : env( 0 ), argName( _aname ) {}
     34
     35Expression::Expression( const Expression &other ) : env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
     36        cloneAll( other.results, results );
    3637}
    3738
    … …  
    3940        delete env;
    4041        delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
    41         delete result;
     42        deleteAll( results );
     43}
     44
     45void Expression::add_result( Type *t ) {
     46        if ( TupleType *tuple = dynamic_cast< TupleType* >( t ) ) {
     47                std::copy( tuple->get_types().begin(), tuple->get_types().end(), back_inserter( results ) );
     48        } else {
     49                results.push_back(t);
     50        } // if
    4251}
    4352
    … …  
    5968
    6069ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
    61         set_result( constant.get_type()->clone() );
     70        add_result( constant.get_type()->clone() );
    6271}
    6372
    … …  
    7685        assert( var );
    7786        assert( var->get_type() );
    78         Type * type = var->get_type()->clone();
    79         type->set_isLvalue( true );
    80         set_result( type );
     87        add_result( var->get_type()->clone() );
     88        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
     89                (*i)->set_isLvalue( true );
     90        } // for
    8191}
    8292
    … …  
    100110SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
    101111                Expression( _aname ), expr(expr_), type(0), isType(false) {
    102         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
     112        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    103113}
    104114
    105115SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
    106116                Expression( _aname ), expr(0), type(type_), isType(true) {
    107         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
     117        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    108118}
    109119
    … …  
    131141AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
    132142                Expression( _aname ), expr(expr_), type(0), isType(false) {
    133         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
     143        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    134144}
    135145
    136146AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
    137147                Expression( _aname ), expr(0), type(type_), isType(true) {
    138         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
     148        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    139149}
    140150
    … …  
    162172UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
    163173                Expression( _aname ), type(type_), member(member_) {
    164         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
     174        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    165175}
    166176
    … …  
    187197OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
    188198                Expression( _aname ), type(type_), member(member_) {
    189         set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
     199        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
    190200}
    191201
    … …  
    219229
    220230OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
    221         set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
     231        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
    222232}
    223233
    … …  
    274284
    275285CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
    276         set_result(toType);
     286        add_result(toType);
    277287}
    278288
    279289CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
    280         set_result( new VoidType( Type::Qualifiers() ) );
    281290}
    282291
    … …  
    294303        arg->print(os, indent+2);
    295304        os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
    296         os << std::string( indent+2, ' ' );
    297         if ( result->isVoid() ) {
    298                 os << "nothing";
     305        if ( results.empty() ) {
     306                os << std::string( indent+2, ' ' ) << "nothing" << std::endl;
    299307        } else {
    300                 result->print( os, indent+2 );
     308                printAll(results, os, indent+2);
    301309        } // if
    302         os << std::endl;
    303         Expression::print( os, indent );
    304 }
    305 
    306 UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
     310        Expression::print( os, indent );
     311}
     312
     313UntypedMemberExpr::UntypedMemberExpr( std::string _member, Expression *_aggregate, Expression *_aname ) :
    307314                Expression( _aname ), member(_member), aggregate(_aggregate) {}
    308315
    309316UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
    310                 Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
     317                Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
    311318}
    312319
    313320UntypedMemberExpr::~UntypedMemberExpr() {
    314321        delete aggregate;
    315         delete member;
    316322}
    317323
    318324void UntypedMemberExpr::print( std::ostream &os, int indent ) const {
    319         os << "Untyped Member Expression, with field: " << std::endl;
    320         os << std::string( indent+2, ' ' );
    321         get_member()->print(os, indent+4);
    322         os << std::string( indent+2, ' ' );
     325        os << "Untyped Member Expression, with field: " << get_member();
    323326
    324327        Expression *agg = get_aggregate();
    325         os << "from aggregate: " << std::endl;
     328        os << ", from aggregate: ";
    326329        if (agg != 0) {
    327                 os << std::string( indent + 4, ' ' );
    328                 agg->print(os, indent + 4);
     330                os << std::string( indent + 2, ' ' );
     331                agg->print(os, indent + 2);
    329332        }
    330333        os << std::string( indent+2, ' ' );
    … …  
    335338MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
    336339                Expression( _aname ), member(_member), aggregate(_aggregate) {
    337         set_result( member->get_type()->clone() );
    338         get_result()->set_isLvalue( true );
     340        add_result( member->get_type()->clone() );
     341        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
     342                (*i)->set_isLvalue( true );
     343        } // for
    339344}
    340345
    … …  
    367372}
    368373
    369 UntypedExpr::UntypedExpr( Expression *_function, const std::list<Expression *> &_args, Expression *_aname ) :
    370                 Expression( _aname ), function(_function), args(_args) {}
     374
     375UntypedExpr::UntypedExpr( Expression *_function, Expression *_aname ) : Expression( _aname ), function( _function ) {}
    371376
    372377UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
    … …  
    374379        cloneAll( other.args, args );
    375380}
     381
     382UntypedExpr::UntypedExpr( Expression *_function, std::list<Expression *> &_args, Expression *_aname ) :
     383                Expression( _aname ), function(_function), args(_args) {}
    376384
    377385UntypedExpr::~UntypedExpr() {
    … …  
    411419LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
    412420                Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
    413         set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
     421        add_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
    414422}
    415423
    … …  
    469477ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
    470478        assert( callExpr );
    471         assert( callExpr->has_result() );
    472         set_result( callExpr->get_result()->clone() );
     479        cloneAll( callExpr->get_results(), results );
    473480}
    474481
    … …  
    503510        Expression * arg = InitTweak::getCallArg( callExpr, 0 );
    504511        assert( arg );
    505         set_result( maybeClone( arg->get_result() ) );
     512        cloneAll( arg->get_results(), results );
    506513}
    507514
    … …  
    523530
    524531CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
    525         assert( type && initializer );
    526         set_result( type->clone() );
    527 }
    528 
    529 CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( other.type->clone() ), initializer( other.initializer->clone() ) {}
     532        add_result( type->clone() );
     533}
     534
     535CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
    530536
    531537CompoundLiteralExpr::~CompoundLiteralExpr() {
    … …  
    536542void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
    537543        os << "Compound Literal Expression: " << std::endl;
    538         os << std::string( indent+2, ' ' );
    539         type->print( os, indent + 2 );
    540         os << std::string( indent+2, ' ' );
    541         initializer->print( os, indent + 2 );
     544        if ( type ) type->print( os, indent + 2 );
     545        if ( initializer ) initializer->print( os, indent + 2 );
    542546}
    543547
    … …  
    553557
    554558RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
    555 RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
     559RangeExpr::RangeExpr( const RangeExpr &other ) : low( other.low->clone() ), high( other.high->clone() ) {}
    556560void RangeExpr::print( std::ostream &os, int indent ) const {
    557         os << "Range Expression: ";
     561        os << std::string( indent, ' ' ) << "Range Expression: ";
    558562        low->print( os, indent );
    559563        os << " ... ";
    560564        high->print( os, indent );
    561 }
    562 
    563 StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
    564         assert( statements );
    565         std::list< Statement * > & body = statements->get_kids();
    566         if ( ! body.empty() ) {
    567                 if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
    568                         set_result( maybeClone( exprStmt->get_expr()->get_result() ) );
    569                 }
    570         }
    571 }
    572 StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {}
    573 StmtExpr::~StmtExpr() {
    574         delete statements;
    575 }
    576 void StmtExpr::print( std::ostream &os, int indent ) const {
    577         os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
    578         statements->print( os, indent+2 );
    579 }
    580 
    581 
    582 long long UniqueExpr::count = 0;
    583 UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( new Expression* ), id( idVal ) {
    584         assert( count != -1 );
    585         if ( id == -1 ) id = count++;
    586         set_expr( expr );
    587         assert( expr );
    588         if ( expr->get_result() ) {
    589                 set_result( expr->get_result()->clone() );
    590         }
    591 }
    592 UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( other.expr ), id( other.id ) {
    593 }
    594 UniqueExpr::~UniqueExpr() {
    595         if ( expr.unique() ) {
    596                 delete *expr;
    597         }
    598 }
    599 void UniqueExpr::print( std::ostream &os, int indent ) const {
    600         os << "Unique Expression with id:" << id << std::endl << std::string( indent+2, ' ' );
    601         get_expr()->print( os, indent+2 );
    602565}
    603566

  • src/SynTree/Expression.h

    ra1e67dd rfe7b281  
    3232        virtual ~Expression();
    3333
    34         Type *& get_result() { return result; }
    35         void set_result( Type *newValue ) { result = newValue; }
    36         bool has_result() const { return result != nullptr; }
     34        std::list<Type *>& get_results() { return results; }
     35        void add_result( Type *t );
    3736
    3837        TypeSubstitution *get_env() const { return env; }
    … …  
    4847        virtual void print( std::ostream &os, int indent = 0 ) const;
    4948  protected:
    50         Type * result;
     49        std::list<Type *> results;
    5150        TypeSubstitution *env;
    5251        Expression* argName; // if expression is used as an argument, it can be "designated" by this name
    … …  
    9998class UntypedExpr : public Expression {
    10099  public:
    101         UntypedExpr( Expression *function, const std::list<Expression *> &args = std::list< Expression * >(), Expression *_aname = nullptr );
     100        UntypedExpr( Expression *function, Expression *_aname = nullptr );
    102101        UntypedExpr( const UntypedExpr &other );
     102        UntypedExpr( Expression *function, std::list<Expression *> &args, Expression *_aname = nullptr );
    103103        virtual ~UntypedExpr();
    104104
    … …  
    200200class UntypedMemberExpr : public Expression {
    201201  public:
    202         UntypedMemberExpr( Expression *member, Expression *aggregate, Expression *_aname = nullptr );
     202        UntypedMemberExpr( std::string member, Expression *aggregate, Expression *_aname = nullptr );
    203203        UntypedMemberExpr( const UntypedMemberExpr &other );
    204204        virtual ~UntypedMemberExpr();
    205205
    206         Expression * get_member() const { return member; }
    207         void set_member( Expression * newValue ) { member = newValue; }
     206        std::string get_member() const { return member; }
     207        void set_member( const std::string &newValue ) { member = newValue; }
    208208        Expression *get_aggregate() const { return aggregate; }
    209209        void set_aggregate( Expression *newValue ) { aggregate = newValue; }
    … …  
    214214        virtual void print( std::ostream &os, int indent = 0 ) const;
    215215  private:
    216         Expression *member;
     216        std::string member;
    217217        Expression *aggregate;
    218218};
    … …  
    483483};
    484484
     485/// TupleExpr represents a tuple expression ( [a, b, c] )
     486class TupleExpr : public Expression {
     487  public:
     488        TupleExpr( Expression *_aname = nullptr );
     489        TupleExpr( const TupleExpr &other );
     490        virtual ~TupleExpr();
     491
     492        void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
     493        std::list<Expression*>& get_exprs() { return exprs; }
     494
     495        virtual TupleExpr *clone() const { return new TupleExpr( *this ); }
     496        virtual void accept( Visitor &v ) { v.visit( this ); }
     497        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     498        virtual void print( std::ostream &os, int indent = 0 ) const;
     499  private:
     500        std::list<Expression*> exprs;
     501};
     502
     503/// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
     504class SolvedTupleExpr : public Expression {
     505  public:
     506        SolvedTupleExpr( Expression *_aname = nullptr ) : Expression( _aname ) {}
     507        SolvedTupleExpr( std::list<Expression *> &, Expression *_aname = nullptr );
     508        SolvedTupleExpr( const SolvedTupleExpr &other );
     509        virtual ~SolvedTupleExpr() {}
     510
     511        std::list<Expression*> &get_exprs() { return exprs; }
     512
     513        virtual SolvedTupleExpr *clone() const { return new SolvedTupleExpr( *this ); }
     514        virtual void accept( Visitor &v ) { v.visit( this ); }
     515        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     516        virtual void print( std::ostream &os, int indent = 0 ) const;
     517  private:
     518        std::list<Expression*> exprs;
     519};
     520
    485521/// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
    486522class TypeExpr : public Expression {
    … …  
    582618        CompoundLiteralExpr( Type * type, Initializer * initializer );
    583619        CompoundLiteralExpr( const CompoundLiteralExpr &other );
    584         virtual ~CompoundLiteralExpr();
     620        ~CompoundLiteralExpr();
    585621
    586622        Type * get_type() const { return type; }
    … …  
    634670  private:
    635671        Expression *low, *high;
    636 };
    637 
    638 /// TupleExpr represents a tuple expression ( [a, b, c] )
    639 class TupleExpr : public Expression {
    640   public:
    641         TupleExpr( const std::list< Expression * > & exprs = std::list< Expression * >(), Expression *_aname = nullptr );
    642         TupleExpr( const TupleExpr &other );
    643         virtual ~TupleExpr();
    644 
    645         void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
    646         std::list<Expression*>& get_exprs() { return exprs; }
    647 
    648         virtual TupleExpr *clone() const { return new TupleExpr( *this ); }
    649         virtual void accept( Visitor &v ) { v.visit( this ); }
    650         virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    651         virtual void print( std::ostream &os, int indent = 0 ) const;
    652   private:
    653         std::list<Expression*> exprs;
    654 };
    655 
    656 /// TupleIndexExpr represents an element selection operation on a tuple value, e.g. t.3 after processing by the expression analyzer
    657 class TupleIndexExpr : public Expression {
    658   public:
    659         TupleIndexExpr( Expression * tuple, unsigned int index );
    660         TupleIndexExpr( const TupleIndexExpr &other );
    661         virtual ~TupleIndexExpr();
    662 
    663         Expression * get_tuple() const { return tuple; }
    664         int get_index() const { return index; }
    665         TupleIndexExpr * set_tuple( Expression *newValue ) { tuple = newValue; return this; }
    666         TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
    667 
    668         virtual TupleIndexExpr *clone() const { return new TupleIndexExpr( *this ); }
    669         virtual void accept( Visitor &v ) { v.visit( this ); }
    670         virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    671         virtual void print( std::ostream &os, int indent = 0 ) const;
    672   private:
    673         Expression * tuple;
    674         unsigned int index;
    675 };
    676 
    677 /// MemberTupleExpr represents a tuple member selection operation on a struct type, e.g. s.[a, b, c] after processing by the expression analyzer
    678 class MemberTupleExpr : public Expression {
    679   public:
    680         MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname = nullptr );
    681         MemberTupleExpr( const MemberTupleExpr &other );
    682         virtual ~MemberTupleExpr();
    683 
    684         Expression * get_member() const { return member; }
    685         Expression * get_aggregate() const { return aggregate; }
    686         MemberTupleExpr * set_member( Expression *newValue ) { member = newValue; return this; }
    687         MemberTupleExpr * set_aggregate( Expression *newValue ) { aggregate = newValue; return this; }
    688 
    689         virtual MemberTupleExpr *clone() const { return new MemberTupleExpr( *this ); }
    690         virtual void accept( Visitor &v ) { v.visit( this ); }
    691         virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    692         virtual void print( std::ostream &os, int indent = 0 ) const;
    693   private:
    694         Expression * member;
    695         Expression * aggregate;
    696 };
    697 
    698 /// TupleAssignExpr represents a multiple assignment operation, where both sides of the assignment have tuple type, e.g. [a, b, c] = [d, e, f];, a mass assignment operation, where the left hand side has tuple type and the right hand side does not, e.g. [a, b, c] = 5.0;, or a tuple ctor/dtor expression
    699 class TupleAssignExpr : public Expression {
    700   public:
    701         TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
    702         TupleAssignExpr( const TupleAssignExpr &other );
    703         virtual ~TupleAssignExpr();
    704 
    705         std::list< Expression * > & get_assigns() { return assigns; }
    706         std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
    707 
    708         virtual TupleAssignExpr *clone() const { return new TupleAssignExpr( *this ); }
    709         virtual void accept( Visitor &v ) { v.visit( this ); }
    710         virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    711         virtual void print( std::ostream &os, int indent = 0 ) const;
    712   private:
    713         std::list< Expression * > assigns; // assignment expressions that use tempDecls
    714         std::list< ObjectDecl * > tempDecls; // temporaries for address of lhs exprs
    715 };
    716 
    717 /// StmtExpr represents a GCC 'statement expression', e.g. ({ int x = 5; x; })
    718 class StmtExpr : public Expression {
    719 public:
    720         StmtExpr( CompoundStmt *statements );
    721         StmtExpr( const StmtExpr & other );
    722         virtual ~StmtExpr();
    723 
    724         CompoundStmt * get_statements() const { return statements; }
    725         StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
    726 
    727         virtual StmtExpr *clone() const { return new StmtExpr( *this ); }
    728         virtual void accept( Visitor &v ) { v.visit( this ); }
    729         virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    730         virtual void print( std::ostream &os, int indent = 0 ) const;
    731 private:
    732         CompoundStmt * statements;
    733 };
    734 
    735 class UniqueExpr : public Expression {
    736 public:
    737         UniqueExpr( Expression * expr, long long idVal = -1 );
    738         UniqueExpr( const UniqueExpr & other );
    739         ~UniqueExpr();
    740 
    741         Expression * get_expr() const { return *expr; }
    742         UniqueExpr * set_expr( Expression * newValue ) { *expr = newValue; return this; }
    743 
    744         int get_id() const { return id; }
    745 
    746         virtual UniqueExpr *clone() const { return new UniqueExpr( *this ); }
    747         virtual void accept( Visitor &v ) { v.visit( this ); }
    748         virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    749         virtual void print( std::ostream &os, int indent = 0 ) const;
    750 private:
    751         std::shared_ptr< Expression * > expr;
    752         int id;
    753         static long long count;
    754672};
    755673

  • src/SynTree/Initializer.h

    ra1e67dd rfe7b281  
    2323
    2424#include <cassert>
    25 
    26 const std::list<Expression*> noDesignators;
    2725
    2826// Initializer: base class for object initializers (provide default values)

  • src/SynTree/Mutator.cc

    ra1e67dd rfe7b281  
    178178
    179179Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
    180         applicationExpr->set_result( maybeMutate( applicationExpr->get_result(), *this ) );
     180        mutateAll( applicationExpr->get_results(), *this );
    181181        applicationExpr->set_function( maybeMutate( applicationExpr->get_function(), *this ) );
    182182        mutateAll( applicationExpr->get_args(), *this );
    … …  
    185185
    186186Expression *Mutator::mutate( UntypedExpr *untypedExpr ) {
    187         untypedExpr->set_result( maybeMutate( untypedExpr->get_result(), *this ) );
     187        mutateAll( untypedExpr->get_results(), *this );
    188188        mutateAll( untypedExpr->get_args(), *this );
    189189        return untypedExpr;
    … …  
    191191
    192192Expression *Mutator::mutate( NameExpr *nameExpr ) {
    193         nameExpr->set_result( maybeMutate( nameExpr->get_result(), *this ) );
     193        mutateAll( nameExpr->get_results(), *this );
    194194        return nameExpr;
    195195}
    196196
    197197Expression *Mutator::mutate( AddressExpr *addressExpr ) {
    198         addressExpr->set_result( maybeMutate( addressExpr->get_result(), *this ) );
     198        mutateAll( addressExpr->get_results(), *this );
    199199        addressExpr->set_arg( maybeMutate( addressExpr->get_arg(), *this ) );
    200200        return addressExpr;
    … …  
    202202
    203203Expression *Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
    204         labelAddressExpr->set_result( maybeMutate( labelAddressExpr->get_result(), *this ) );
     204        mutateAll( labelAddressExpr->get_results(), *this );
    205205        labelAddressExpr->set_arg( maybeMutate( labelAddressExpr->get_arg(), *this ) );
    206206        return labelAddressExpr;
    … …  
    208208
    209209Expression *Mutator::mutate( CastExpr *castExpr ) {
    210         castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
     210        mutateAll( castExpr->get_results(), *this );
    211211        castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
    212212        return castExpr;
    … …  
    214214
    215215Expression *Mutator::mutate( UntypedMemberExpr *memberExpr ) {
    216         memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
    217         memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
    218         memberExpr->set_member( maybeMutate( memberExpr->get_member(), *this ) );
    219         return memberExpr;
    220 }
    221 
    222 Expression *Mutator::mutate( MemberExpr *memberExpr ) {
    223         memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
     216        mutateAll( memberExpr->get_results(), *this );
    224217        memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
    225218        return memberExpr;
    226219}
    227220
     221Expression *Mutator::mutate( MemberExpr *memberExpr ) {
     222        mutateAll( memberExpr->get_results(), *this );
     223        memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
     224        return memberExpr;
     225}
     226
    228227Expression *Mutator::mutate( VariableExpr *variableExpr ) {
    229         variableExpr->set_result( maybeMutate( variableExpr->get_result(), *this ) );
     228        mutateAll( variableExpr->get_results(), *this );
    230229        return variableExpr;
    231230}
    232231
    233232Expression *Mutator::mutate( ConstantExpr *constantExpr ) {
    234         constantExpr->set_result( maybeMutate( constantExpr->get_result(), *this ) );
     233        mutateAll( constantExpr->get_results(), *this );
    235234//  maybeMutate( constantExpr->get_constant(), *this )
    236235        return constantExpr;
    … …  
    238237
    239238Expression *Mutator::mutate( SizeofExpr *sizeofExpr ) {
    240         sizeofExpr->set_result( maybeMutate( sizeofExpr->get_result(), *this ) );
     239        mutateAll( sizeofExpr->get_results(), *this );
    241240        if ( sizeofExpr->get_isType() ) {
    242241                sizeofExpr->set_type( maybeMutate( sizeofExpr->get_type(), *this ) );
    … …  
    248247
    249248Expression *Mutator::mutate( AlignofExpr *alignofExpr ) {
    250         alignofExpr->set_result( maybeMutate( alignofExpr->get_result(), *this ) );
     249        mutateAll( alignofExpr->get_results(), *this );
    251250        if ( alignofExpr->get_isType() ) {
    252251                alignofExpr->set_type( maybeMutate( alignofExpr->get_type(), *this ) );
    … …  
    258257
    259258Expression *Mutator::mutate( UntypedOffsetofExpr *offsetofExpr ) {
    260         offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
     259        mutateAll( offsetofExpr->get_results(), *this );
    261260        offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
    262261        return offsetofExpr;
    … …  
    264263
    265264Expression *Mutator::mutate( OffsetofExpr *offsetofExpr ) {
    266         offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
     265        mutateAll( offsetofExpr->get_results(), *this );
    267266        offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
    268267        offsetofExpr->set_member( maybeMutate( offsetofExpr->get_member(), *this ) );
    … …  
    271270
    272271Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
    273         offsetPackExpr->set_result( maybeMutate( offsetPackExpr->get_result(), *this ) );
     272        mutateAll( offsetPackExpr->get_results(), *this );
    274273        offsetPackExpr->set_type( maybeMutate( offsetPackExpr->get_type(), *this ) );
    275274        return offsetPackExpr;
    … …  
    277276
    278277Expression *Mutator::mutate( AttrExpr *attrExpr ) {
    279         attrExpr->set_result( maybeMutate( attrExpr->get_result(), *this ) );
     278        mutateAll( attrExpr->get_results(), *this );
    280279        if ( attrExpr->get_isType() ) {
    281280                attrExpr->set_type( maybeMutate( attrExpr->get_type(), *this ) );
    … …  
    287286
    288287Expression *Mutator::mutate( LogicalExpr *logicalExpr ) {
    289         logicalExpr->set_result( maybeMutate( logicalExpr->get_result(), *this ) );
     288        mutateAll( logicalExpr->get_results(), *this );
    290289        logicalExpr->set_arg1( maybeMutate( logicalExpr->get_arg1(), *this ) );
    291290        logicalExpr->set_arg2( maybeMutate( logicalExpr->get_arg2(), *this ) );
    … …  
    294293
    295294Expression *Mutator::mutate( ConditionalExpr *conditionalExpr ) {
    296         conditionalExpr->set_result( maybeMutate( conditionalExpr->get_result(), *this ) );
     295        mutateAll( conditionalExpr->get_results(), *this );
    297296        conditionalExpr->set_arg1( maybeMutate( conditionalExpr->get_arg1(), *this ) );
    298297        conditionalExpr->set_arg2( maybeMutate( conditionalExpr->get_arg2(), *this ) );
    … …  
    302301
    303302Expression *Mutator::mutate( CommaExpr *commaExpr ) {
    304         commaExpr->set_result( maybeMutate( commaExpr->get_result(), *this ) );
     303        mutateAll( commaExpr->get_results(), *this );
    305304        commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
    306305        commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
    … …  
    308307}
    309308
     309Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
     310        mutateAll( tupleExpr->get_results(), *this );
     311        mutateAll( tupleExpr->get_exprs(), *this );
     312        return tupleExpr;
     313}
     314
     315Expression *Mutator::mutate( SolvedTupleExpr *tupleExpr ) {
     316        mutateAll( tupleExpr->get_results(), *this );
     317        mutateAll( tupleExpr->get_exprs(), *this );
     318        return tupleExpr;
     319}
     320
    310321Expression *Mutator::mutate( TypeExpr *typeExpr ) {
    311         typeExpr->set_result( maybeMutate( typeExpr->get_result(), *this ) );
     322        mutateAll( typeExpr->get_results(), *this );
    312323        typeExpr->set_type( maybeMutate( typeExpr->get_type(), *this ) );
    313324        return typeExpr;
    … …  
    329340
    330341Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) {
    331         ctorExpr->set_result( maybeMutate( ctorExpr->get_result(), *this ) );
     342        mutateAll( ctorExpr->get_results(), *this );
    332343        ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) );
    333344        return ctorExpr;
    … …  
    335346
    336347Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
    337         compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) );
     348        mutateAll( compLitExpr->get_results(), *this );
    338349        compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) );
    339350        compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
    … …  
    342353
    343354Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
    344         valofExpr->set_result( maybeMutate( valofExpr->get_result(), *this ) );
     355        mutateAll( valofExpr->get_results(), *this );
    345356        return valofExpr;
    346357}
    … …  
    350361        rangeExpr->set_high( maybeMutate( rangeExpr->get_high(), *this ) );
    351362        return rangeExpr;
    352 }
    353 
    354 Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
    355         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
    356         mutateAll( tupleExpr->get_exprs(), *this );
    357         return tupleExpr;
    358 }
    359 
    360 Expression *Mutator::mutate( TupleIndexExpr *tupleExpr ) {
    361         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
    362         tupleExpr->set_tuple( maybeMutate( tupleExpr->get_tuple(), *this ) );
    363         return tupleExpr;
    364 }
    365 
    366 Expression *Mutator::mutate( MemberTupleExpr *tupleExpr ) {
    367         tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
    368         tupleExpr->set_member( maybeMutate( tupleExpr->get_member(), *this ) );
    369         tupleExpr->set_aggregate( maybeMutate( tupleExpr->get_aggregate(), *this ) );
    370         return tupleExpr;
    371 }
    372 
    373 Expression *Mutator::mutate( TupleAssignExpr *assignExpr ) {
    374         assignExpr->set_result( maybeMutate( assignExpr->get_result(), *this ) );
    375         mutateAll( assignExpr->get_tempDecls(), *this );
    376         mutateAll( assignExpr->get_assigns(), *this );
    377         return assignExpr;
    378 }
    379 
    380 Expression *Mutator::mutate( StmtExpr *stmtExpr ) {
    381         stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
    382         stmtExpr->set_statements( maybeMutate( stmtExpr->get_statements(), *this ) );
    383         return stmtExpr;
    384 }
    385 
    386 Expression *Mutator::mutate( UniqueExpr *uniqueExpr ) {
    387         uniqueExpr->set_result( maybeMutate( uniqueExpr->get_result(), *this ) );
    388         uniqueExpr->set_expr( maybeMutate( uniqueExpr->get_expr(), *this ) );
    389         return uniqueExpr;
    390363}
    391364

  • src/SynTree/Mutator.h

    ra1e67dd rfe7b281  
    7171        virtual Expression* mutate( ConditionalExpr *conditionalExpr );
    7272        virtual Expression* mutate( CommaExpr *commaExpr );
     73        virtual Expression* mutate( TupleExpr *tupleExpr );
     74        virtual Expression* mutate( SolvedTupleExpr *tupleExpr );
    7375        virtual Expression* mutate( TypeExpr *typeExpr );
    7476        virtual Expression* mutate( AsmExpr *asmExpr );
    … …  
    7880        virtual Expression* mutate( UntypedValofExpr *valofExpr );
    7981        virtual Expression* mutate( RangeExpr *rangeExpr );
    80         virtual Expression* mutate( TupleExpr *tupleExpr );
    81         virtual Expression* mutate( TupleIndexExpr *tupleExpr );
    82         virtual Expression* mutate( MemberTupleExpr *tupleExpr );
    83         virtual Expression* mutate( TupleAssignExpr *assignExpr );
    84         virtual Expression* mutate( StmtExpr * stmtExpr );
    85         virtual Expression* mutate( UniqueExpr * uniqueExpr );
    8682
    8783        virtual Type* mutate( VoidType *basicType );

  • src/SynTree/ReferenceToType.cc

    ra1e67dd rfe7b281  
    5656        }
    5757} // namespace
    58 
    59 StructInstType::StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct ) : Parent( tq, baseStruct->get_name() ), baseStruct( baseStruct ) {}
    6058
    6159std::string StructInstType::typeString() const { return "struct"; }

  • src/SynTree/SynTree.h

    ra1e67dd rfe7b281  
    7676class ConditionalExpr;
    7777class CommaExpr;
     78class TupleExpr;
     79class SolvedTupleExpr;
    7880class TypeExpr;
    7981class AsmExpr;
    … …  
    8385class UntypedValofExpr;
    8486class RangeExpr;
    85 class TupleExpr;
    86 class TupleIndexExpr;
    87 class MemberTupleExpr;
    88 class TupleAssignExpr;
    89 class StmtExpr;
    90 class UniqueExpr;
    9187
    9288class Type;

  • src/SynTree/TupleExpr.cc

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TupleExpr.cc --
     7// TupleExpr.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    1616#include "Expression.h"
    1717#include "Common/utility.h"
    18 #include "Type.h"
    19 #include "Declaration.h"
    20 #include "Tuples/Tuples.h"
    2118
    22 TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
    23         if ( ! exprs.empty() ) {
    24                 if ( std::all_of( exprs.begin(), exprs.end(), [](Expression * expr) { return expr->get_result(); } ) ) {
    25                         set_result( Tuples::makeTupleType( exprs ) );
    26                 }
    27         }
     19TupleExpr::TupleExpr( Expression *_aname ) : Expression( _aname ) {
    2820}
    2921
    … …  
    3729
    3830void TupleExpr::print( std::ostream &os, int indent ) const {
    39         os << "Tuple:" << std::endl;
     31        os << std::string( indent, ' ' ) << "Tuple:" << std::endl;
    4032        printAll( exprs, os, indent+2 );
    4133        Expression::print( os, indent );
    4234}
    4335
    44 TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) : tuple( tuple ), index( index )  {
    45         TupleType * type = safe_dynamic_cast< TupleType * >( tuple->get_result() );
    46         assert( type->size() > index );
    47         set_result( (*std::next( type->get_types().begin(), index ))->clone() );
    48         get_result()->set_isLvalue( type->get_isLvalue() );
     36SolvedTupleExpr::SolvedTupleExpr( std::list<Expression *> &_exprs, Expression *_aname ) : Expression( _aname ) {
     37        std::copy(_exprs.begin(), _exprs.end(), back_inserter(exprs));
    4938}
    5039
    51 TupleIndexExpr::TupleIndexExpr( const TupleIndexExpr &other ) : Expression( other ), tuple( other.tuple->clone() ), index( other.index ) {
     40SolvedTupleExpr::SolvedTupleExpr( const SolvedTupleExpr &other ) : Expression( other ) {
     41        cloneAll( other.exprs, exprs );
    5242}
    5343
    54 TupleIndexExpr::~TupleIndexExpr() {
    55         delete tuple;
    56 }
    57 
    58 void TupleIndexExpr::print( std::ostream &os, int indent ) const {
    59         os << "Tuple Index Expression, with tuple:" << std::endl;
    60         os << std::string( indent+2, ' ' );
    61         tuple->print( os, indent+2 );
    62         os << std::string( indent+2, ' ' ) << "with index: " << index << std::endl;
     44void SolvedTupleExpr::print( std::ostream &os, int indent ) const {
     45        os << std::string( indent, ' ' ) << "Solved Tuple:" << std::endl;
     46        printAll( exprs, os, indent+2 );
    6347        Expression::print( os, indent );
    6448}
    65 
    66 MemberTupleExpr::MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname ) : Expression( _aname ) {
    67         set_result( maybeClone( member->get_result() ) ); // xxx - ???
    68 }
    69 
    70 MemberTupleExpr::MemberTupleExpr( const MemberTupleExpr &other ) : Expression( other ), member( other.member->clone() ), aggregate( other.aggregate->clone() ) {
    71 }
    72 
    73 MemberTupleExpr::~MemberTupleExpr() {
    74         delete member;
    75         delete aggregate;
    76 }
    77 
    78 void MemberTupleExpr::print( std::ostream &os, int indent ) const {
    79         os << "Member Tuple Expression, with aggregate:" << std::endl;
    80         os << std::string( indent+2, ' ' );
    81         aggregate->print( os, indent+2 );
    82         os << std::string( indent+2, ' ' ) << "with member: " << std::endl;
    83         os << std::string( indent+2, ' ' );
    84         member->print( os, indent+2 );
    85         Expression::print( os, indent );
    86 }
    87 
    88 
    89 TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ), assigns( assigns ), tempDecls( tempDecls ) {
    90         set_result( Tuples::makeTupleType( assigns ) );
    91 }
    92 
    93 TupleAssignExpr::TupleAssignExpr( const TupleAssignExpr &other ) : Expression( other ), tempDecls( other.tempDecls ) /* temporary */ {
    94         cloneAll( other.assigns, assigns );
    95         // xxx - clone needs to go into assigns and replace tempDecls
    96 }
    97 
    98 TupleAssignExpr::~TupleAssignExpr() {
    99         deleteAll( assigns );
    100         // deleteAll( tempDecls );
    101 }
    102 
    103 void TupleAssignExpr::print( std::ostream &os, int indent ) const {
    104         os << "Tuple Assignment Expression, with temporaries:" << std::endl;
    105         printAll( tempDecls, os, indent+4 );
    106         os << std::string( indent+2, ' ' ) << "with assignments: " << std::endl;
    107         printAll( assigns, os, indent+4 );
    108         Expression::print( os, indent );
    109 }
    110 
    111 
    11249
    11350// Local Variables: //

  • src/SynTree/TupleType.cc

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TupleType.cc --
     7// TupleType.cc -- 
    88//
    99// Author           : Richard C. Bilson
    … …  
    1717#include "Common/utility.h"
    1818
    19 TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types ) : Type( tq ), types( types ) {
     19TupleType::TupleType( const Type::Qualifiers &tq ) : Type( tq ) {
    2020}
    2121

  • src/SynTree/Type.h

    ra1e67dd rfe7b281  
    2020#include "Visitor.h"
    2121#include "Mutator.h"
    22 #include "Common/utility.h"
    2322
    2423class Type {
    … …  
    2827                Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isAttribute ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isAttribute( isAttribute ) {}
    2928
    30                 Qualifiers &operator&=( const Qualifiers &other );
    3129                Qualifiers &operator+=( const Qualifiers &other );
    3230                Qualifiers &operator-=( const Qualifiers &other );
    … …  
    6563        void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
    6664        void set_isAttribute( bool newValue ) { tq.isAttribute = newValue; }
    67 
    68         typedef std::list<TypeDecl *> ForallList;
    69         ForallList& get_forall() { return forall; }
    70 
    71         /// How many elemental types are represented by this type
    72         virtual unsigned size() const { return 1; };
    73         virtual bool isVoid() const { return size() == 0; }
     65        std::list<TypeDecl*>& get_forall() { return forall; }
    7466
    7567        virtual Type *clone() const = 0;
    … …  
    7971  private:
    8072        Qualifiers tq;
    81         ForallList forall;
     73        std::list<TypeDecl*> forall;
    8274};
    8375
    … …  
    8577  public:
    8678        VoidType( const Type::Qualifiers &tq );
    87 
    88         virtual unsigned size() const { return 0; };
    8979
    9080        virtual VoidType *clone() const { return new VoidType( *this ); }
    … …  
    244234  public:
    245235        StructInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseStruct( 0 ) {}
    246         StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct );
    247236        StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
    248237
    … …  
    359348class TupleType : public Type {
    360349  public:
    361         TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types = std::list< Type * >() );
     350        TupleType( const Type::Qualifiers &tq );
    362351        TupleType( const TupleType& );
    363352        virtual ~TupleType();
    364353
    365         typedef std::list<Type*> value_type;
    366         typedef value_type::iterator iterator;
    367 
    368354        std::list<Type*>& get_types() { return types; }
    369         virtual unsigned size() const { return types.size(); };
    370 
    371         iterator begin() { return types.begin(); }
    372         iterator end() { return types.end(); }
    373355
    374356        virtual TupleType *clone() const { return new TupleType( *this ); }
    … …  
    460442};
    461443
    462 inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
    463         isConst &= other.isConst;
    464         isVolatile &= other.isVolatile;
    465         isRestrict &= other.isRestrict;
    466         isLvalue &= other.isLvalue;
    467         isAtomic &= other.isAtomic;
    468         return *this;
    469 }
    470 
    471444inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
    472445        isConst |= other.isConst;

  • src/SynTree/TypeSubstitution.cc

    ra1e67dd rfe7b281  
    7272Type *TypeSubstitution::lookup( std::string formalType ) const {
    7373        TypeEnvType::const_iterator i = typeEnv.find( formalType );
    74 
     74       
    7575        // break on not in substitution set
    7676        if ( i == typeEnv.end() ) return 0;
    77 
     77       
    7878        // attempt to transitively follow TypeInstType links.
    7979        while ( TypeInstType *actualType = dynamic_cast< TypeInstType* >( i->second ) ) {
    8080                const std::string& typeName = actualType->get_name();
    81 
     81               
    8282                // break cycles in the transitive follow
    8383                if ( formalType == typeName ) break;
    84 
     84               
    8585                // Look for the type this maps to, returning previous mapping if none-such
    8686                i = typeEnv.find( typeName );
    8787                if ( i == typeEnv.end() ) return actualType;
    8888        }
    89 
     89       
    9090        // return type from substitution set
    9191        return i->second;
    92 
     92       
    9393#if 0
    9494        if ( i == typeEnv.end() ) {
    … …  
    149149        // bind type variables from forall-qualifiers
    150150        if ( freeOnly ) {
    151                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
     151                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
    152152                        boundVars.insert( (*tyvar )->get_name() );
    153153                } // for
    … …  
    163163        // bind type variables from forall-qualifiers
    164164        if ( freeOnly ) {
    165                 for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
     165                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
    166166                        boundVars.insert( (*tyvar )->get_name() );
    167167                } // for

  • src/SynTree/Visitor.cc

    ra1e67dd rfe7b281  
    150150
    151151void Visitor::visit( ApplicationExpr *applicationExpr ) {
    152         maybeAccept( applicationExpr->get_result(), *this );
     152        acceptAll( applicationExpr->get_results(), *this );
    153153        maybeAccept( applicationExpr->get_function(), *this );
    154154        acceptAll( applicationExpr->get_args(), *this );
    … …  
    156156
    157157void Visitor::visit( UntypedExpr *untypedExpr ) {
    158         maybeAccept( untypedExpr->get_result(), *this );
     158        acceptAll( untypedExpr->get_results(), *this );
    159159        acceptAll( untypedExpr->get_args(), *this );
    160160}
    161161
    162162void Visitor::visit( NameExpr *nameExpr ) {
    163         maybeAccept( nameExpr->get_result(), *this );
     163        acceptAll( nameExpr->get_results(), *this );
    164164}
    165165
    166166void Visitor::visit( AddressExpr *addressExpr ) {
    167         maybeAccept( addressExpr->get_result(), *this );
     167        acceptAll( addressExpr->get_results(), *this );
    168168        maybeAccept( addressExpr->get_arg(), *this );
    169169}
    170170
    171171void Visitor::visit( LabelAddressExpr *labAddressExpr ) {
    172         maybeAccept( labAddressExpr->get_result(), *this );
     172        acceptAll( labAddressExpr->get_results(), *this );
    173173        maybeAccept( labAddressExpr->get_arg(), *this );
    174174}
    175175
    176176void Visitor::visit( CastExpr *castExpr ) {
    177         maybeAccept( castExpr->get_result(), *this );
     177        acceptAll( castExpr->get_results(), *this );
    178178        maybeAccept( castExpr->get_arg(), *this );
    179179}
    180180
    181181void Visitor::visit( UntypedMemberExpr *memberExpr ) {
    182         maybeAccept( memberExpr->get_result(), *this );
     182        acceptAll( memberExpr->get_results(), *this );
    183183        maybeAccept( memberExpr->get_aggregate(), *this );
    184         maybeAccept( memberExpr->get_member(), *this );
    185184}
    186185
    187186void Visitor::visit( MemberExpr *memberExpr ) {
    188         maybeAccept( memberExpr->get_result(), *this );
     187        acceptAll( memberExpr->get_results(), *this );
    189188        maybeAccept( memberExpr->get_aggregate(), *this );
    190189}
    191190
    192191void Visitor::visit( VariableExpr *variableExpr ) {
    193         maybeAccept( variableExpr->get_result(), *this );
     192        acceptAll( variableExpr->get_results(), *this );
    194193}
    195194
    196195void Visitor::visit( ConstantExpr *constantExpr ) {
    197         maybeAccept( constantExpr->get_result(), *this );
     196        acceptAll( constantExpr->get_results(), *this );
    198197        maybeAccept( constantExpr->get_constant(), *this );
    199198}
    200199
    201200void Visitor::visit( SizeofExpr *sizeofExpr ) {
    202         maybeAccept( sizeofExpr->get_result(), *this );
     201        acceptAll( sizeofExpr->get_results(), *this );
    203202        if ( sizeofExpr->get_isType() ) {
    204203                maybeAccept( sizeofExpr->get_type(), *this );
    … …  
    209208
    210209void Visitor::visit( AlignofExpr *alignofExpr ) {
    211         maybeAccept( alignofExpr->get_result(), *this );
     210        acceptAll( alignofExpr->get_results(), *this );
    212211        if ( alignofExpr->get_isType() ) {
    213212                maybeAccept( alignofExpr->get_type(), *this );
    … …  
    218217
    219218void Visitor::visit( UntypedOffsetofExpr *offsetofExpr ) {
    220         maybeAccept( offsetofExpr->get_result(), *this );
     219        acceptAll( offsetofExpr->get_results(), *this );
    221220        maybeAccept( offsetofExpr->get_type(), *this );
    222221}
    223222
    224223void Visitor::visit( OffsetofExpr *offsetofExpr ) {
    225         maybeAccept( offsetofExpr->get_result(), *this );
     224        acceptAll( offsetofExpr->get_results(), *this );
    226225        maybeAccept( offsetofExpr->get_type(), *this );
    227226        maybeAccept( offsetofExpr->get_member(), *this );
    … …  
    229228
    230229void Visitor::visit( OffsetPackExpr *offsetPackExpr ) {
    231         maybeAccept( offsetPackExpr->get_result(), *this );
     230        acceptAll( offsetPackExpr->get_results(), *this );
    232231        maybeAccept( offsetPackExpr->get_type(), *this );
    233232}
    234233
    235234void Visitor::visit( AttrExpr *attrExpr ) {
    236         maybeAccept( attrExpr->get_result(), *this );
     235        acceptAll( attrExpr->get_results(), *this );
    237236        if ( attrExpr->get_isType() ) {
    238237                maybeAccept( attrExpr->get_type(), *this );
    … …  
    243242
    244243void Visitor::visit( LogicalExpr *logicalExpr ) {
    245         maybeAccept( logicalExpr->get_result(), *this );
     244        acceptAll( logicalExpr->get_results(), *this );
    246245        maybeAccept( logicalExpr->get_arg1(), *this );
    247246        maybeAccept( logicalExpr->get_arg2(), *this );
    … …  
    249248
    250249void Visitor::visit( ConditionalExpr *conditionalExpr ) {
    251         maybeAccept( conditionalExpr->get_result(), *this );
     250        acceptAll( conditionalExpr->get_results(), *this );
    252251        maybeAccept( conditionalExpr->get_arg1(), *this );
    253252        maybeAccept( conditionalExpr->get_arg2(), *this );
    … …  
    256255
    257256void Visitor::visit( CommaExpr *commaExpr ) {
    258         maybeAccept( commaExpr->get_result(), *this );
     257        acceptAll( commaExpr->get_results(), *this );
    259258        maybeAccept( commaExpr->get_arg1(), *this );
    260259        maybeAccept( commaExpr->get_arg2(), *this );
    261260}
    262261
     262void Visitor::visit( TupleExpr *tupleExpr ) {
     263        acceptAll( tupleExpr->get_results(), *this );
     264        acceptAll( tupleExpr->get_exprs(), *this );
     265}
     266
     267void Visitor::visit( SolvedTupleExpr *tupleExpr ) {
     268        acceptAll( tupleExpr->get_results(), *this );
     269        acceptAll( tupleExpr->get_exprs(), *this );
     270}
     271
    263272void Visitor::visit( TypeExpr *typeExpr ) {
    264         maybeAccept( typeExpr->get_result(), *this );
     273        acceptAll( typeExpr->get_results(), *this );
    265274        maybeAccept( typeExpr->get_type(), *this );
    266275}
    … …  
    279288
    280289void Visitor::visit( ConstructorExpr * ctorExpr ) {
    281         maybeAccept( ctorExpr->get_result(), *this );
     290        acceptAll( ctorExpr->get_results(), *this );
    282291        maybeAccept( ctorExpr->get_callExpr(), *this );
    283292}
    284293
    285294void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
    286         maybeAccept( compLitExpr->get_result(), *this );
     295        acceptAll( compLitExpr->get_results(), *this );
    287296        maybeAccept( compLitExpr->get_type(), *this );
    288297        maybeAccept( compLitExpr->get_initializer(), *this );
    … …  
    290299
    291300void Visitor::visit( UntypedValofExpr *valofExpr ) {
    292         maybeAccept( valofExpr->get_result(), *this );
     301        acceptAll( valofExpr->get_results(), *this );
    293302        maybeAccept( valofExpr->get_body(), *this );
    294303}
    … …  
    297306        maybeAccept( rangeExpr->get_low(), *this );
    298307        maybeAccept( rangeExpr->get_high(), *this );
    299 }
    300 
    301 void Visitor::visit( TupleExpr *tupleExpr ) {
    302         maybeAccept( tupleExpr->get_result(), *this );
    303         acceptAll( tupleExpr->get_exprs(), *this );
    304 }
    305 
    306 void Visitor::visit( TupleIndexExpr *tupleExpr ) {
    307         maybeAccept( tupleExpr->get_result(), *this );
    308         maybeAccept( tupleExpr->get_tuple(), *this );
    309 }
    310 
    311 void Visitor::visit( MemberTupleExpr *tupleExpr ) {
    312         maybeAccept( tupleExpr->get_result(), *this );
    313         maybeAccept( tupleExpr->get_member(), *this );
    314         maybeAccept( tupleExpr->get_aggregate(), *this );
    315 }
    316 
    317 void Visitor::visit( TupleAssignExpr *assignExpr ) {
    318         maybeAccept( assignExpr->get_result(), *this );
    319         acceptAll( assignExpr->get_tempDecls(), *this );
    320         acceptAll( assignExpr->get_assigns(), *this );
    321 }
    322 
    323 void Visitor::visit( StmtExpr *stmtExpr ) {
    324         maybeAccept( stmtExpr->get_result(), *this );
    325         maybeAccept( stmtExpr->get_statements(), *this );
    326 }
    327 
    328 void Visitor::visit( UniqueExpr *uniqueExpr ) {
    329         maybeAccept( uniqueExpr->get_result(), *this );
    330         maybeAccept( uniqueExpr->get_expr(), *this );
    331308}
    332309

  • src/SynTree/Visitor.h

    ra1e67dd rfe7b281  
    7171        virtual void visit( ConditionalExpr *conditionalExpr );
    7272        virtual void visit( CommaExpr *commaExpr );
     73        virtual void visit( TupleExpr *tupleExpr );
     74        virtual void visit( SolvedTupleExpr *tupleExpr );
    7375        virtual void visit( TypeExpr *typeExpr );
    7476        virtual void visit( AsmExpr *asmExpr );
    … …  
    7880        virtual void visit( UntypedValofExpr *valofExpr );
    7981        virtual void visit( RangeExpr *rangeExpr );
    80         virtual void visit( TupleExpr *tupleExpr );
    81         virtual void visit( TupleIndexExpr *tupleExpr );
    82         virtual void visit( MemberTupleExpr *tupleExpr );
    83         virtual void visit( TupleAssignExpr *assignExpr );
    84         virtual void visit( StmtExpr * stmtExpr );
    85         virtual void visit( UniqueExpr * uniqueExpr );
    8682
    8783        virtual void visit( VoidType *basicType );

  • src/Tuples/TupleAssignment.cc

    ra1e67dd rfe7b281  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // TupleAssignment.cc --
     7// TupleAssignment.cc -- 
    88//
    99// Author           : Rodolfo G. Esteves
    … …  
    1818#include "ResolvExpr/typeops.h"
    1919#include "SynTree/Expression.h"
    20 #include "SynTree/Initializer.h"
    21 #include "Tuples.h"
     20#include "TupleAssignment.h"
    2221#include "Common/SemanticError.h"
    23 #include "InitTweak/InitTweak.h"
    2422
    2523#include <functional>
    … …  
    2927#include <cassert>
    3028#include <set>
    31 #include <unordered_set>
    3229
    3330namespace Tuples {
    34         class TupleAssignSpotter {
    35           public:
    36                 // dispatcher for Tuple (multiple and mass) assignment operations
    37                 TupleAssignSpotter( ResolvExpr::AlternativeFinder & );
    38                 void spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities );
    39 
    40           private:
    41                 void match();
    42 
    43                 struct Matcher {
    44                   public:
    45                         Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts );
    46                         virtual ~Matcher() {}
    47                         virtual void match( std::list< Expression * > &out ) = 0;
    48                         ResolvExpr::AltList lhs, rhs;
    49                         TupleAssignSpotter &spotter;
    50                         std::list< ObjectDecl * > tmpDecls;
    51                 };
    52 
    53                 struct MassAssignMatcher : public Matcher {
    54                   public:
    55                         MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts );
    56                         virtual void match( std::list< Expression * > &out );
    57                 };
    58 
    59                 struct MultipleAssignMatcher : public Matcher {
    60                   public:
    61                         MultipleAssignMatcher( TupleAssignSpotter &spot, const ResolvExpr::AltList & alts );
    62                         virtual void match( std::list< Expression * > &out );
    63                 };
    64 
    65                 ResolvExpr::AlternativeFinder &currentFinder;
    66                 std::string fname;
    67                 std::unique_ptr< Matcher > matcher;
    68         };
    69 
    70         /// true if expr is an expression of tuple type, i.e. a tuple expression, tuple variable, or MRV (multiple-return-value) function
    71         bool isTuple( Expression *expr ) {
     31        TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder *f = 0 )
     32                : currentFinder(f), matcher(0), hasMatched( false ) {}
     33
     34        bool TupleAssignSpotter::pointsToTuple( Expression *expr ) {
     35                // also check for function returning tuple of reference types
     36                if (AddressExpr *addr = dynamic_cast<AddressExpr *>(expr) )
     37                        if ( isTuple(addr->get_arg() ) )
     38                                return true;
     39                return false;
     40        }
     41
     42        bool TupleAssignSpotter::isTupleVar( DeclarationWithType *decl ) {
     43                if ( dynamic_cast<TupleType *>(decl->get_type()) )
     44                        return true;
     45                return false;
     46        }
     47
     48        bool TupleAssignSpotter::isTuple( Expression *expr, bool isRight ) {
     49                // true if `expr' is an expression returning a tuple: tuple, tuple variable or MRV function
    7250                if ( ! expr ) return false;
    73                 assert( expr->has_result() );
    74                 return dynamic_cast<TupleExpr *>(expr) || expr->get_result()->size() > 1;
    75         }
    76 
    77         template< typename AltIter >
    78         bool isMultAssign( AltIter begin, AltIter end ) {
    79                 // multiple assignment if more than one alternative in the range or if
    80                 // the alternative is a tuple
    81                 if ( begin == end ) return false;
    82                 if ( isTuple( begin->expr ) ) return true;
    83                 return ++begin != end;
    84         }
    85 
    86         bool pointsToTuple( Expression *expr ) {
    87                 // also check for function returning tuple of reference types
    88                 if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
    89                         return pointsToTuple( castExpr->get_arg() );
    90                 } else if ( AddressExpr *addr = dynamic_cast< AddressExpr * >( expr) ) {
    91                         return isTuple( addr->get_arg() );
    92                 }
    93                 return false;
    94         }
    95 
    96         void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
    97                 TupleAssignSpotter spotter( currentFinder );
    98                 spotter.spot( expr, possibilities );
    99         }
    100 
    101         TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder &f )
    102                 : currentFinder(f) {}
    103 
    104         void TupleAssignSpotter::spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
    105                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
    106                         if ( InitTweak::isCtorDtorAssign( op->get_name() ) ) {
    107                                 fname = op->get_name();
    108                                 for ( std::list<ResolvExpr::AltList>::const_iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
    109                                         if ( ali->size() == 0 ) continue; // AlternativeFinder will natrually handle this case, if it's legal
    110                                         if ( ali->size() <= 1 && InitTweak::isAssignment( op->get_name() ) ) {
    111                                                 // what does it mean if an assignment takes 1 argument? maybe someone defined such a function, in which case AlternativeFinder will naturally handle it
    112                                                 continue;
    113                                         }
    114 
    115                                         assert( ! ali->empty() );
    116                                         // grab args 2-N and group into a TupleExpr
    117                                         const ResolvExpr::Alternative & alt1 = ali->front();
    118                                         auto begin = std::next(ali->begin(), 1), end = ali->end();
    119                                         if ( pointsToTuple(alt1.expr) ) {
    120                                                 if ( isMultAssign( begin, end ) ) {
    121                                                         matcher.reset( new MultipleAssignMatcher( *this, *ali ) );
    122                                                 } else {
     51
     52                if ( dynamic_cast<TupleExpr *>(expr) )
     53                        return true;
     54                else if ( VariableExpr *var = dynamic_cast<VariableExpr *>(expr) ) {
     55                        if ( isTupleVar(var->get_var()) )
     56                                return true;
     57                }
     58
     59                return false;
     60        }
     61
     62        bool TupleAssignSpotter::match() {
     63                assert ( matcher != 0 );
     64
     65                std::list< Expression * > new_assigns;
     66                if ( ! matcher->match(new_assigns) )
     67                        return false;
     68
     69                if ( new_assigns.empty() ) return false;
     70                /*return */matcher->solve( new_assigns );
     71                if ( dynamic_cast<TupleAssignSpotter::MultipleAssignMatcher *>( matcher ) ) {
     72                        // now resolve new assignments
     73                        std::list< Expression * > solved_assigns;
     74                        ResolvExpr::AltList solved_alts;
     75                        assert( currentFinder != 0 );
     76
     77                        ResolvExpr::AltList current;
     78                        for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
     79                                //try {
     80                                ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
     81                                finder.findWithAdjustment(*i);
     82                                // prune expressions that don't coincide with
     83                                ResolvExpr::AltList alts = finder.get_alternatives();
     84                                assert( alts.size() == 1 );
     85                                assert(alts.front().expr != 0 );
     86                                current.push_back( finder.get_alternatives().front() );
     87                                solved_assigns.push_back( alts.front().expr->clone() );
     88                                //solved_assigns.back()->print(std::cerr);
     89                                /*} catch( ... ) {
     90                                  continue; // no reasonable alternative found
     91                                  }*/
     92                        }
     93                        options.add_option( current );
     94
     95                        return true;
     96                } else { // mass assignment
     97                        //if ( new_assigns.empty() ) return false;
     98                        std::list< Expression * > solved_assigns;
     99                        ResolvExpr::AltList solved_alts;
     100                        assert( currentFinder != 0 );
     101
     102                        ResolvExpr::AltList current;
     103                        if ( optMass.empty() ) {
     104                                for ( std::list< Expression * >::size_type i = 0; i != new_assigns.size(); ++i )
     105                                        optMass.push_back( ResolvExpr::AltList() );
     106                        }
     107                        int cnt = 0;
     108                        for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i, cnt++ ) {
     109
     110                                ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
     111                                finder.findWithAdjustment(*i);
     112                                ResolvExpr::AltList alts = finder.get_alternatives();
     113                                assert( alts.size() == 1 );
     114                                assert(alts.front().expr != 0 );
     115                                current.push_back( finder.get_alternatives().front() );
     116                                optMass[cnt].push_back( finder.get_alternatives().front() );
     117                                solved_assigns.push_back( alts.front().expr->clone() );
     118                        }
     119
     120                        return true;
     121                }
     122
     123                return false;
     124        }
     125
     126        bool TupleAssignSpotter::isMVR( Expression *expr ) {
     127                if ( expr->get_results().size() > 1 ) {
     128                        // MVR processing
     129                        return true;
     130                }
     131                return false;
     132        }
     133
     134        bool TupleAssignSpotter::isTupleAssignment( UntypedExpr * expr, std::list<ResolvExpr::AltList> &possibilities ) {
     135                if (  NameExpr *assgnop = dynamic_cast< NameExpr * >(expr->get_function()) ) {
     136
     137                        if ( assgnop->get_name() == std::string("?=?") ) {
     138
     139                                for ( std::list<ResolvExpr::AltList>::iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
     140                                        assert( ali->size() == 2 );
     141                                        ResolvExpr::AltList::iterator opit = ali->begin();
     142                                        ResolvExpr::Alternative op1 = *opit, op2 = *(++opit);
     143
     144                                        if ( pointsToTuple(op1.expr) ) { // also handles tuple vars
     145                                                if ( isTuple( op2.expr, true ) )
     146                                                        matcher = new MultipleAssignMatcher(op1.expr, op2.expr);
     147                                                else if ( isMVR( op2.expr ) ) {
     148                                                        // handle MVR differently
     149                                                } else
    123150                                                        // mass assignment
    124                                                         matcher.reset( new MassAssignMatcher( *this,  *ali ) );
     151                                                        matcher = new MassAssignMatcher(op1.expr, op2.expr);
     152
     153                                                std::list< ResolvExpr::AltList > options;
     154                                                if ( match() )
     155                                                        /*
     156                                                          if ( hasMatched ) {
     157                                                          // throw SemanticError("Ambiguous tuple assignment");
     158                                                          } else {*/
     159                                                        // Matched for the first time
     160                                                        hasMatched = true;
     161                                                /*} */
     162                                        } /* else if ( isTuple( op2 ) )
     163                                                 throw SemanticError("Inapplicable tuple assignment.");
     164                                          */
     165                                }
     166
     167                                if ( hasMatched ) {
     168                                        if ( dynamic_cast<TupleAssignSpotter::MultipleAssignMatcher *>( matcher ) ) {
     169                                                //options.print( std::cerr );
     170                                                std::list< ResolvExpr::AltList >best = options.get_best();
     171                                                if ( best.size() == 1 ) {
     172                                                        std::list<Expression *> solved_assigns;
     173                                                        for ( ResolvExpr::AltList::iterator i = best.front().begin(); i != best.front().end(); ++i ) {
     174                                                                solved_assigns.push_back( i->expr );
     175                                                        }
     176                                                        /* assigning cost zero? */
     177                                                        currentFinder->get_alternatives().push_front( ResolvExpr::Alternative(new SolvedTupleExpr(solved_assigns/*, SolvedTupleExpr::MULTIPLE*/), currentFinder->get_environ(), ResolvExpr::Cost() ) );
    125178                                                }
    126                                                 match();
     179                                        } else {
     180                                                assert( ! optMass.empty() );
     181                                                ResolvExpr::AltList winners;
     182                                                for ( std::vector< ResolvExpr::AltList >::iterator i = optMass.begin(); i != optMass.end(); ++i )
     183                                                        findMinCostAlt( i->begin(), i->end(), back_inserter(winners) );
     184
     185                                                std::list< Expression *> solved_assigns;
     186                                                for ( ResolvExpr::AltList::iterator i = winners.begin(); i != winners.end(); ++i )
     187                                                        solved_assigns.push_back( i->expr );
     188                                                currentFinder->get_alternatives().push_front( ResolvExpr::Alternative(new SolvedTupleExpr(solved_assigns/*, SolvedTupleExpr::MASS*/), currentFinder->get_environ(), ResolvExpr::Cost() ) );
    127189                                        }
    128190                                }
    129191                        }
    130192                }
    131         }
    132 
    133         void TupleAssignSpotter::match() {
    134                 assert ( matcher != 0 );
    135 
    136                 std::list< Expression * > new_assigns;
    137                 matcher->match( new_assigns );
    138 
    139                 if ( new_assigns.empty() ) return;
    140                 ResolvExpr::AltList current;
    141                 // now resolve new assignments
    142                 for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
    143                         ResolvExpr::AlternativeFinder finder( currentFinder.get_indexer(), currentFinder.get_environ() );
    144                         try {
    145                                 finder.findWithAdjustment(*i);
    146                         } catch (...) {
    147                                 return; // xxx - no match should not mean failure, it just means this particular tuple assignment isn't valid
     193                return hasMatched;
     194        }
     195
     196        void TupleAssignSpotter::Matcher::init( Expression *_lhs, Expression *_rhs ) {
     197                lhs.clear();
     198                if (AddressExpr *addr = dynamic_cast<AddressExpr *>(_lhs) )
     199                        if ( TupleExpr *tuple = dynamic_cast<TupleExpr *>(addr->get_arg()) )
     200                                std::copy( tuple->get_exprs().begin(), tuple->get_exprs().end(), back_inserter(lhs) );
     201
     202                rhs.clear();
     203        }
     204
     205        TupleAssignSpotter::Matcher::Matcher( /*TupleAssignSpotter &spot,*/ Expression *_lhs, Expression *_rhs ) /*: own_spotter(spot) */{
     206                init(_lhs,_rhs);
     207        }
     208
     209        TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( Expression *_lhs, Expression *_rhs )/* : own_spotter(spot) */{
     210                init(_lhs,_rhs);
     211
     212                if ( TupleExpr *tuple = dynamic_cast<TupleExpr *>(_rhs) )
     213                        std::copy( tuple->get_exprs().begin(), tuple->get_exprs().end(), back_inserter(rhs) );
     214        }
     215
     216        UntypedExpr *TupleAssignSpotter::Matcher::createAssgn( Expression *left, Expression *right ) {
     217                if ( left && right ) {
     218                        std::list< Expression * > args;
     219                        args.push_back(new AddressExpr(left->clone()));  args.push_back(right->clone());
     220                        return new UntypedExpr(new NameExpr("?=?"), args);
     221                } else
     222                        throw 0; // xxx - diagnose the problem
     223        }
     224
     225        bool TupleAssignSpotter::MassAssignMatcher::match( std::list< Expression * > &out ) {
     226                if ( lhs.empty() || (rhs.size() != 1) ) return false;
     227
     228                for ( std::list< Expression * >::iterator l = lhs.begin(); l != lhs.end(); l++ ) {
     229                        std::list< Expression * > args;
     230                        args.push_back( new AddressExpr(*l) );
     231                        args.push_back( rhs.front() );
     232                        out.push_back( new UntypedExpr(new NameExpr("?=?"), args) );
     233                }
     234
     235                return true;
     236        }
     237
     238        bool TupleAssignSpotter::MassAssignMatcher::solve( std::list< Expression * > &assigns ) {
     239                /*
     240                  std::list< Expression * > solved_assigns;
     241                  ResolvExpr::AltList solved_alts;
     242                  assert( currentFinder != 0 );
     243
     244                  ResolvExpr::AltList current;
     245                  if ( optMass.empty() ) {
     246                  for ( std::list< Expression * >::size_type i = 0; i != new_assigns.size(); ++i )
     247                  optMass.push_back( ResolvExpr::AltList() );
     248                  }
     249                  int cnt = 0;
     250                  for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i, cnt++ ) {
     251
     252                  ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
     253                  finder.findWithAdjustment(*i);
     254                  ResolvExpr::AltList alts = finder.get_alternatives();
     255                  assert( alts.size() == 1 );
     256                  assert(alts.front().expr != 0 );
     257                  current.push_back( finder.get_alternatives().front() );
     258                  optMass[cnt].push_back( finder.get_alternatives().front() );
     259                  solved_assigns.push_back( alts.front().expr->clone() );
     260                  }
     261                */
     262                return true;
     263        }
     264
     265        bool TupleAssignSpotter::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
     266                // need more complicated matching
     267                if ( lhs.size() == rhs.size() ) {
     268                        zipWith( lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), back_inserter(out), TupleAssignSpotter::Matcher::createAssgn );
     269                        return true;
     270                } //else
     271                //std::cerr << "The length of (left, right) is: (" << lhs.size() << "," << rhs.size() << ")" << std::endl;*/
     272                return false;
     273        }
     274
     275        bool TupleAssignSpotter::MultipleAssignMatcher::solve( std::list< Expression * > &assigns ) {
     276                /*
     277                  std::list< Expression * > solved_assigns;
     278                  ResolvExpr::AltList solved_alts;
     279                  assert( currentFinder != 0 );
     280
     281                  ResolvExpr::AltList current;
     282                  for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
     283                  //try {
     284                  ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
     285                  finder.findWithAdjustment(*i);
     286                  // prune expressions that don't coincide with
     287                  ResolvExpr::AltList alts = finder.get_alternatives();
     288                  assert( alts.size() == 1 );
     289                  assert(alts.front().expr != 0 );
     290                  current.push_back( finder.get_alternatives().front() );
     291                  solved_assigns.push_back( alts.front().expr->clone() );
     292                  //solved_assigns.back()->print(std::cerr);
     293                  //} catch( ... ) {
     294                  //continue; // no reasonable alternative found
     295                  //}
     296                  }
     297                  options.add_option( current );
     298                */
     299
     300                return true;
     301        }
     302
     303        void TupleAssignSpotter::Options::add_option( ResolvExpr::AltList &opt ) {
     304                using namespace std;
     305
     306                options.push_back( opt );
     307                /*
     308                  vector< Cost > costs;
     309                  costs.reserve( opt.size() );
     310                  transform( opt.begin(), opt.end(), back_inserter(costs), ptr_fun(extract_cost) );
     311                */
     312                // transpose matrix
     313                if ( costMatrix.empty() )
     314                        for ( unsigned int i = 0; i< opt.size(); ++i)
     315                                costMatrix.push_back( vector<ResolvExpr::Cost>() );
     316
     317                int cnt = 0;
     318                for ( ResolvExpr::AltList::iterator i = opt.begin(); i != opt.end(); ++i, cnt++ )
     319                        costMatrix[cnt].push_back( i->cost );
     320
     321                return;
     322        }
     323
     324        std::list< ResolvExpr::AltList > TupleAssignSpotter::Options::get_best() {
     325                using namespace std;
     326                using namespace ResolvExpr;
     327                list< ResolvExpr::AltList > ret;
     328                list< multiset<int> > solns;
     329                for ( vector< vector<Cost> >::iterator i = costMatrix.begin(); i != costMatrix.end(); ++i ) {
     330                        list<int> current;
     331                        findMinCost( i->begin(), i->end(), back_inserter(current) );
     332                        solns.push_back( multiset<int>(current.begin(), current.end()) );
     333                }
     334                // need to combine
     335                multiset<int> result;
     336                lift_intersection( solns.begin(), solns.end(), inserter( result, result.begin() ) );
     337                if ( result.size() != 1 )
     338                        throw SemanticError("Ambiguous tuple expression");
     339                ret.push_back(get_option( *(result.begin() )));
     340                return ret;
     341        }
     342
     343        void TupleAssignSpotter::Options::print( std::ostream &ostr ) {
     344                using namespace std;
     345
     346                for ( vector< vector < ResolvExpr::Cost > >::iterator i = costMatrix.begin(); i != costMatrix.end(); ++i ) {
     347                        for ( vector < ResolvExpr::Cost >::iterator j = i->begin(); j != i->end(); ++j )
     348                                ostr << *j << " " ;
     349                        ostr << std::endl;
     350                } // for
     351                return;
     352        }
     353
     354        ResolvExpr::Cost extract_cost( ResolvExpr::Alternative &alt ) {
     355                return alt.cost;
     356        }
     357
     358        template< typename InputIterator, typename OutputIterator >
     359        void TupleAssignSpotter::Options::findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
     360                using namespace ResolvExpr;
     361                std::list<int> alternatives;
     362
     363                // select the alternatives that have the minimum parameter cost
     364                Cost minCost = Cost::infinity;
     365                unsigned int index = 0;
     366                for ( InputIterator i = begin; i != end; ++i, index++ ) {
     367                        if ( *i < minCost ) {
     368                                minCost = *i;
     369                                alternatives.clear();
     370                                alternatives.push_back( index );
     371                        } else if ( *i == minCost ) {
     372                                alternatives.push_back( index );
    148373                        }
    149                         // prune expressions that don't coincide with
    150                         ResolvExpr::AltList alts = finder.get_alternatives();
    151                         assert( alts.size() == 1 );
    152                         assert( alts.front().expr != 0 );
    153                         current.push_back( alts.front() );
    154                 }
    155 
    156                 // extract expressions from the assignment alternatives to produce a list of assignments that
    157                 // together form a single alternative
    158                 std::list< Expression *> solved_assigns;
    159                 for ( ResolvExpr::Alternative & alt : current ) {
    160                         solved_assigns.push_back( alt.expr->clone() );
    161                 }
    162                 // xxx - need to do this??
    163                 ResolvExpr::TypeEnvironment compositeEnv;
    164                 simpleCombineEnvironments( current.begin(), current.end(), compositeEnv );
    165                 currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), compositeEnv, ResolvExpr::sumCost( current ) ) );
    166         }
    167 
    168         TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList &alts ) : spotter(spotter) {
    169                 assert( ! alts.empty() );
    170                 ResolvExpr::Alternative lhsAlt = alts.front();
    171                 // peel off the cast that exists on ctor/dtor expressions
    172                 bool isCast = false;
    173                 if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( lhsAlt.expr ) ) {
    174                         lhsAlt.expr = castExpr->get_arg();
    175                         castExpr->set_arg( nullptr );
    176                         delete castExpr;
    177                         isCast = true;
    178                 }
    179 
    180                 // explode the lhs so that each field of the tuple-valued-expr is assigned.
    181                 explode( lhsAlt, back_inserter(lhs) );
    182                 // and finally, re-add the cast to each lhs expr, so that qualified tuple fields can be constructed
    183                 if ( isCast ) {
    184                         for ( ResolvExpr::Alternative & alt : lhs ) {
    185                                 Expression *& expr = alt.expr;
    186                                 Type * castType = expr->get_result()->clone();
    187                                 Type * type = InitTweak::getPointerBase( castType );
    188                                 assert( type );
    189                                 type->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
    190                                 type->set_isLvalue( true ); // xxx - might not need this
    191                                 expr = new CastExpr( expr, castType );
    192                         }
    193                 }
    194                 // }
    195         }
    196 
    197         TupleAssignSpotter::MassAssignMatcher::MassAssignMatcher( TupleAssignSpotter &spotter,const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
    198                 assert( alts.size() == 1 || alts.size() == 2 );
    199                 if ( alts.size() == 2 ) {
    200                         rhs.push_back( alts.back() );
    201                 }
    202         }
    203 
    204         TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
    205                 // explode the rhs so that each field of the tuple-valued-expr is assigned.
    206                 explode( std::next(alts.begin(), 1), alts.end(), back_inserter(rhs) );
    207         }
    208 
    209         UntypedExpr * createFunc( const std::string &fname, ObjectDecl *left, ObjectDecl *right ) {
    210                 assert( left );
    211                 std::list< Expression * > args;
    212                 args.push_back( new AddressExpr( new UntypedExpr( new NameExpr("*?"), std::list< Expression * >{ new VariableExpr( left ) } ) ) );
    213                 // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
    214                 if ( right ) args.push_back( new VariableExpr( right ) );
    215                 return new UntypedExpr( new NameExpr( fname ), args );
    216         }
    217 
    218         ObjectDecl * newObject( UniqueName & namer, Expression * expr ) {
    219                 assert( expr->has_result() && ! expr->get_result()->isVoid() );
    220                 return new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
    221         }
    222 
    223         void TupleAssignSpotter::MassAssignMatcher::match( std::list< Expression * > &out ) {
    224                 static UniqueName lhsNamer( "__massassign_L" );
    225                 static UniqueName rhsNamer( "__massassign_R" );
    226                 assert ( ! lhs.empty() && rhs.size() <= 1);
    227 
    228                 ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
    229                 for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
    230                         ObjectDecl * ltmp = newObject( lhsNamer, lhsAlt.expr );
    231                         out.push_back( createFunc( spotter.fname, ltmp, rtmp ) );
    232                         tmpDecls.push_back( ltmp );
    233                 }
    234                 if ( rtmp ) tmpDecls.push_back( rtmp );
    235         }
    236 
    237         void TupleAssignSpotter::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
    238                 static UniqueName lhsNamer( "__multassign_L" );
    239                 static UniqueName rhsNamer( "__multassign_R" );
    240                 // xxx - need more complicated matching?
    241                 if ( lhs.size() == rhs.size() ) {
    242                         std::list< ObjectDecl * > ltmp;
    243                         std::list< ObjectDecl * > rtmp;
    244                         std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), []( ResolvExpr::Alternative & alt ){
    245                                 return newObject( lhsNamer, alt.expr );
    246                         });
    247                         std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), []( ResolvExpr::Alternative & alt ){
    248                                 return newObject( rhsNamer, alt.expr );
    249                         });
    250                         zipWith( ltmp.begin(), ltmp.end(), rtmp.begin(), rtmp.end(), back_inserter(out), [&](ObjectDecl * obj1, ObjectDecl * obj2 ) { return createFunc(spotter.fname, obj1, obj2); } );
    251                         tmpDecls.splice( tmpDecls.end(), ltmp );
    252                         tmpDecls.splice( tmpDecls.end(), rtmp );
    253                 }
     374                }
     375                std::copy( alternatives.begin(), alternatives.end(), out );
     376        }
     377
     378        template< class InputIterator, class OutputIterator >
     379        void TupleAssignSpotter::Options::lift_intersection( InputIterator begin, InputIterator end, OutputIterator out ) {
     380                if ( begin == end ) return;
     381                InputIterator test = begin;
     382
     383                if (++test == end)
     384                        { copy(begin->begin(), begin->end(), out); return; }
     385
     386
     387                std::multiset<int> cur; // InputIterator::value_type::value_type
     388                copy( begin->begin(), begin->end(), inserter( cur, cur.begin() ) );
     389
     390                while ( test != end ) {
     391                        std::multiset<int> temp;
     392                        set_intersection( cur.begin(), cur.end(), test->begin(), test->end(), inserter(temp,temp.begin()) );
     393                        cur.clear();
     394                        copy( temp.begin(), temp.end(), inserter(cur,cur.begin()));
     395                        ++test;
     396                }
     397
     398                copy( cur.begin(), cur.end(), out );
     399                return;
     400        }
     401
     402        ResolvExpr::AltList TupleAssignSpotter::Options::get_option( std::list< ResolvExpr::AltList >::size_type index ) {
     403                if ( index >= options.size() )
     404                        throw 0; // XXX
     405                std::list< ResolvExpr::AltList >::iterator it = options.begin();
     406                for ( std::list< ResolvExpr::AltList >::size_type i = 0; i < index; ++i, ++it );
     407                return *it;
    254408        }
    255409} // namespace Tuples

  • src/Tuples/module.mk

    ra1e67dd rfe7b281  
    66## file "LICENCE" distributed with Cforall.
    77##
    8 ## module.mk --
     8## module.mk -- 
    99##
    1010## Author           : Richard C. Bilson
    … …  
    1616
    1717SRC +=  Tuples/TupleAssignment.cc \
    18         Tuples/TupleExpansion.cc
     18        Tuples/NameMatcher.cc

  • src/main.cc

    ra1e67dd rfe7b281  
    4242#include "Common/UnimplementedError.h"
    4343#include "../config.h"
    44 #include "Tuples/Tuples.h"
    4544
    4645using namespace std;
    … …  
    232231                OPTPRINT( "tweakInit" )
    233232                InitTweak::genInit( translationUnit );
    234                 OPTPRINT( "expandMemberTuples" );
    235                 Tuples::expandMemberTuples( translationUnit );
     233
    236234                if ( libcfap ) {
    237235                        // generate the bodies of cfa library functions
    … …  
    250248                        return 0;
    251249                } // if
    252 
    253                 OPTPRINT( "expandUniqueExpr" ); // xxx - is this the right place for this? want to expand ASAP so that subsequent passes don't need to worry about double-visiting a unique expr
    254                 Tuples::expandUniqueExpr( translationUnit );
    255250
    256251                // fix ObjectDecl - replaces ConstructorInit nodes
    … …  
    277272                OPTPRINT( "box" )
    278273                GenPoly::box( translationUnit );
    279                 OPTPRINT( "expandTuples" ); // xxx - is this the right place for this?
    280                 Tuples::expandTuples( translationUnit );
    281274
    282275                // print tree right before code generation
Note: See TracChangeset for help on using the changeset viewer.