Changes in / [3f0c6a5:47a8d17]


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

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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)
    … …  
    364365        ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
    365366        ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
    366         ControlStruct/ForExprMutator.cc GenPoly/Box.cc \
     367        ControlStruct/ForExprMutator.cc \
     368        ControlStruct/LabelTypeChecker.cc GenPoly/Box.cc \
    367369        GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
    368370        GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
    … …  
    404406        SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \
    405407        SynTree/Attribute.cc Tuples/TupleAssignment.cc \
    406         Tuples/TupleExpansion.cc
     408        Tuples/NameMatcher.cc
    407409MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
    408410        ${cfa_cpplib_PROGRAMS}}
    … …  
    539541        ControlStruct/$(DEPDIR)/$(am__dirstamp)
    540542ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT):  \
     543        ControlStruct/$(am__dirstamp) \
     544        ControlStruct/$(DEPDIR)/$(am__dirstamp)
     545ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT):  \
    541546        ControlStruct/$(am__dirstamp) \
    542547        ControlStruct/$(DEPDIR)/$(am__dirstamp)
    … …  
    772777Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT):  \
    773778        Tuples/$(am__dirstamp) Tuples/$(DEPDIR)/$(am__dirstamp)
    774 Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT): \
    775         Tuples/$(am__dirstamp) Tuples/$(DEPDIR)/$(am__dirstamp)
     779Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT): Tuples/$(am__dirstamp) \
     780        Tuples/$(DEPDIR)/$(am__dirstamp)
    776781driver/$(am__dirstamp):
    777782        @$(MKDIR_P) driver
    … …  
    795800        -rm -f ControlStruct/driver_cfa_cpp-LabelFixer.$(OBJEXT)
    796801        -rm -f ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT)
     802        -rm -f ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT)
    797803        -rm -f ControlStruct/driver_cfa_cpp-MLEMutator.$(OBJEXT)
    798804        -rm -f ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT)
    … …  
    881887        -rm -f SynTree/driver_cfa_cpp-VoidType.$(OBJEXT)
    882888        -rm -f SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT)
     889        -rm -f Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT)
    883890        -rm -f Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT)
    884         -rm -f Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT)
    885891
    886892distclean-compile:
    … …  
    901907@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelFixer.Po@am__quote@
    902908@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelGenerator.Po@am__quote@
     909@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po@am__quote@
    903910@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-MLEMutator.Po@am__quote@
    904911@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-Mutate.Po@am__quote@
    … …  
    987994@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
    988995@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
     996@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po@am__quote@
    989997@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Po@am__quote@
    990 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po@am__quote@
    991998
    992999.cc.o:
    … …  
    12301237@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`
    12311238
     1239ControlStruct/driver_cfa_cpp-LabelTypeChecker.o: ControlStruct/LabelTypeChecker.cc
     1240@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
     1241@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po
     1242@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/LabelTypeChecker.cc' object='ControlStruct/driver_cfa_cpp-LabelTypeChecker.o' libtool=no @AMDEPBACKSLASH@
     1243@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1244@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
     1245
     1246ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj: ControlStruct/LabelTypeChecker.cc
     1247@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`
     1248@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po
     1249@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/LabelTypeChecker.cc' object='ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj' libtool=no @AMDEPBACKSLASH@
     1250@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     1251@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`
     1252
    12321253GenPoly/driver_cfa_cpp-Box.o: GenPoly/Box.cc
    12331254@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
    … …  
    24202441@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`
    24212442
    2422 Tuples/driver_cfa_cpp-TupleExpansion.o: Tuples/TupleExpansion.cc
    2423 @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
    2424 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po
    2425 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/TupleExpansion.cc' object='Tuples/driver_cfa_cpp-TupleExpansion.o' libtool=no @AMDEPBACKSLASH@
    2426 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    2427 @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
    2428 
    2429 Tuples/driver_cfa_cpp-TupleExpansion.obj: Tuples/TupleExpansion.cc
    2430 @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`
    2431 @am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po
    2432 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/TupleExpansion.cc' object='Tuples/driver_cfa_cpp-TupleExpansion.obj' libtool=no @AMDEPBACKSLASH@
    2433 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
    2434 @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`
     2443Tuples/driver_cfa_cpp-NameMatcher.o: Tuples/NameMatcher.cc
     2444@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
     2445@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po
     2446@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/NameMatcher.cc' object='Tuples/driver_cfa_cpp-NameMatcher.o' libtool=no @AMDEPBACKSLASH@
     2447@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2448@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
     2449
     2450Tuples/driver_cfa_cpp-NameMatcher.obj: Tuples/NameMatcher.cc
     2451@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`
     2452@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po
     2453@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/NameMatcher.cc' object='Tuples/driver_cfa_cpp-NameMatcher.obj' libtool=no @AMDEPBACKSLASH@
     2454@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
     2455@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`
    24352456
    24362457.ll.cc:

  • src/Parser/ExpressionNode.cc

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    10261026static const yytype_uint16 yyrline[] =
    10271027{
    1028        0,   305,   305,   309,   316,   317,   318,   319,   320,   324,
    1029      325,   326,   330,   331,   335,   336,   340,   341,   345,   349,
    1030      350,   361,   363,   365,   366,   368,   373,   374,   380,   382,
    1031      384,   386,   388,   390,   392,   394,   396,   398,   407,   408,
    1032      414,   415,   419,   420,   424,   425,   427,   429,   431,   433,
    1033      435,   440,   442,   444,   448,   450,   454,   457,   459,   461,
    1034      466,   479,   481,   483,   485,   487,   489,   491,   493,   495,
    1035      497,   499,   506,   507,   513,   514,   515,   516,   520,   521,
    1036      528,   529,   531,   533,   538,   539,   541,   546,   547,   549,
    1037      554,   555,   557,   559,   561,   566,   567,   569,   574,   575,
    1038      580,   581,   586,   587,   592,   593,   598,   599,   604,   605,
    1039      608,   615,   620,   621,   629,   630,   634,   635,   636,   637,
    1040      638,   639,   640,   641,   642,   643,   644,   645,   655,   657,
    1041      662,   663,   668,   669,   675,   676,   682,   683,   684,   685,
    1042      686,   687,   688,   689,   690,   700,   707,   709,   719,   720,
    1043      725,   727,   733,   735,   739,   740,   745,   750,   753,   755,
    1044      757,   767,   769,   780,   781,   783,   787,   789,   793,   794,
    1045      799,   800,   804,   809,   810,   814,   816,   822,   823,   827,
    1046      829,   831,   833,   839,   840,   844,   846,   851,   853,   855,
    1047      860,   862,   867,   869,   873,   876,   880,   883,   887,   889,
    1048      891,   893,   898,   900,   902,   907,   909,   911,   913,   915,
    1049      920,   922,   924,   926,   931,   943,   944,   949,   951,   956,
    1050      960,   962,   964,   966,   968,   974,   975,   981,   982,   986,
    1051      987,   992,   994,  1000,  1001,  1003,  1008,  1013,  1023,  1025,
    1052     1029,  1030,  1035,  1037,  1041,  1042,  1046,  1048,  1052,  1053,
    1053     1057,  1058,  1062,  1063,  1078,  1079,  1080,  1081,  1082,  1086,
    1054     1091,  1098,  1108,  1113,  1118,  1126,  1131,  1136,  1141,  1146,
    1055     1176,  1181,  1188,  1190,  1197,  1202,  1207,  1218,  1223,  1228,
    1056     1233,  1238,  1247,  1252,  1260,  1261,  1262,  1263,  1269,  1274,
    1057     1282,  1283,  1284,  1285,  1289,  1290,  1291,  1292,  1297,  1298,
    1058     1307,  1308,  1313,  1314,  1319,  1321,  1323,  1325,  1327,  1330,
    1059     1329,  1341,  1342,  1344,  1354,  1355,  1360,  1362,  1364,  1366,
    1060     1368,  1371,  1373,  1376,  1381,  1383,  1385,  1387,  1389,  1391,
    1061     1393,  1395,  1397,  1399,  1401,  1403,  1405,  1411,  1412,  1414,
    1062     1416,  1418,  1423,  1424,  1430,  1431,  1433,  1435,  1440,  1442,
    1063     1444,  1446,  1451,  1452,  1454,  1456,  1461,  1462,  1464,  1469,
    1064     1470,  1472,  1474,  1479,  1481,  1483,  1488,  1489,  1493,  1495,
    1065     1501,  1500,  1504,  1506,  1511,  1513,  1519,  1520,  1525,  1526,
    1066     1528,  1529,  1538,  1539,  1541,  1543,  1548,  1550,  1556,  1557,
    1067     1559,  1562,  1565,  1570,  1571,  1576,  1581,  1585,  1587,  1593,
    1068     1592,  1599,  1601,  1607,  1608,  1616,  1617,  1621,  1622,  1623,
    1069     1625,  1627,  1634,  1635,  1637,  1639,  1644,  1645,  1651,  1652,
    1070     1656,  1657,  1662,  1663,  1664,  1666,  1674,  1675,  1677,  1680,
    1071     1682,  1686,  1687,  1688,  1690,  1692,  1696,  1701,  1709,  1710,
    1072     1719,  1721,  1726,  1727,  1728,  1732,  1733,  1734,  1738,  1739,
    1073     1740,  1744,  1745,  1746,  1751,  1752,  1753,  1754,  1760,  1761,
    1074     1763,  1768,  1769,  1774,  1775,  1776,  1777,  1778,  1793,  1794,
    1075     1799,  1800,  1806,  1808,  1811,  1813,  1815,  1838,  1839,  1841,
    1076     1843,  1848,  1849,  1851,  1856,  1861,  1862,  1868,  1867,  1871,
    1077     1875,  1877,  1879,  1885,  1886,  1891,  1896,  1898,  1903,  1905,
    1078     1906,  1908,  1913,  1915,  1917,  1922,  1924,  1929,  1934,  1942,
    1079     1948,  1947,  1961,  1962,  1967,  1968,  1972,  1977,  1982,  1990,
    1080     1995,  2006,  2007,  2012,  2013,  2019,  2020,  2024,  2025,  2026,
    1081     2029,  2028,  2039,  2048,  2054,  2060,  2069,  2075,  2081,  2087,
    1082     2093,  2101,  2107,  2115,  2121,  2130,  2131,  2132,  2136,  2140,
    1083     2142,  2147,  2148,  2152,  2153,  2158,  2164,  2165,  2168,  2170,
    1084     2171,  2175,  2176,  2177,  2178,  2212,  2214,  2215,  2217,  2222,
    1085     2227,  2232,  2234,  2236,  2241,  2243,  2245,  2247,  2252,  2254,
    1086     2263,  2265,  2266,  2271,  2273,  2275,  2280,  2282,  2284,  2289,
    1087     2291,  2293,  2302,  2303,  2304,  2308,  2310,  2312,  2317,  2319,
    1088     2321,  2326,  2328,  2330,  2345,  2347,  2348,  2350,  2355,  2356,
    1089     2361,  2363,  2365,  2370,  2372,  2374,  2376,  2381,  2383,  2385,
    1090     2395,  2397,  2398,  2400,  2405,  2407,  2409,  2414,  2416,  2418,
    1091     2420,  2425,  2427,  2429,  2460,  2462,  2463,  2465,  2470,  2475,
    1092     2483,  2485,  2487,  2492,  2494,  2499,  2501,  2515,  2516,  2518,
    1093     2523,  2525,  2527,  2529,  2531,  2536,  2537,  2539,  2541,  2546,
    1094     2548,  2550,  2556,  2558,  2560,  2564,  2566,  2568,  2570,  2584,
    1095     2585,  2587,  2592,  2594,  2596,  2598,  2600,  2605,  2606,  2608,
    1096     2610,  2615,  2617,  2619,  2625,  2626,  2628,  2637,  2640,  2642,
    1097     2645,  2647,  2649,  2662,  2663,  2665,  2670,  2672,  2674,  2676,
    1098     2678,  2683,  2684,  2686,  2688,  2693,  2695,  2703,  2704,  2705,
    1099     2710,  2711,  2715,  2717,  2719,  2721,  2723,  2725,  2732,  2734,
    1100     2736,  2738,  2740,  2743,  2745,  2747,  2749,  2751,  2756,  2758,
    1101     2760,  2765,  2791,  2792,  2794,  2798,  2799,  2803,  2805,  2807,
    1102     2809,  2811,  2813,  2820,  2822,  2824,  2826,  2828,  2830,  2835,
    1103     2842,  2844,  2862,  2864,  2869,  2870
     1028       0,   306,   306,   310,   317,   318,   319,   320,   321,   325,
     1029     326,   327,   331,   332,   336,   337,   341,   342,   346,   350,
     1030     351,   362,   364,   366,   367,   369,   374,   375,   381,   383,
     1031     385,   386,   387,   389,   390,   392,   394,   396,   405,   406,
     1032     412,   413,   417,   418,   422,   424,   426,   428,   430,   432,
     1033     434,   439,   441,   443,   447,   449,   453,   456,   458,   460,
     1034     465,   478,   480,   482,   484,   486,   488,   490,   492,   494,
     1035     496,   498,   505,   506,   512,   513,   514,   515,   519,   520,
     1036     527,   528,   530,   532,   537,   538,   540,   545,   546,   548,
     1037     553,   554,   556,   558,   560,   565,   566,   568,   573,   574,
     1038     579,   580,   585,   586,   591,   592,   597,   598,   603,   604,
     1039     607,   614,   619,   620,   628,   629,   633,   634,   635,   636,
     1040     637,   638,   639,   640,   641,   642,   643,   644,   654,   656,
     1041     661,   662,   667,   668,   674,   675,   681,   682,   683,   684,
     1042     685,   686,   687,   688,   689,   699,   706,   708,   718,   719,
     1043     724,   726,   732,   734,   738,   739,   744,   749,   752,   754,
     1044     756,   766,   768,   779,   780,   782,   786,   788,   792,   793,
     1045     798,   799,   803,   808,   809,   813,   815,   821,   822,   826,
     1046     828,   830,   832,   838,   839,   843,   845,   850,   852,   854,
     1047     859,   861,   866,   868,   872,   875,   879,   882,   886,   888,
     1048     890,   892,   897,   899,   901,   906,   908,   910,   912,   914,
     1049     919,   921,   923,   925,   930,   942,   943,   948,   950,   955,
     1050     959,   961,   963,   965,   967,   973,   974,   980,   981,   985,
     1051     986,   991,   993,   999,  1000,  1002,  1007,  1012,  1022,  1024,
     1052    1028,  1029,  1034,  1036,  1040,  1041,  1045,  1047,  1051,  1052,
     1053    1056,  1057,  1061,  1062,  1077,  1078,  1079,  1080,  1081,  1085,
     1054    1090,  1097,  1107,  1112,  1117,  1125,  1130,  1135,  1140,  1145,
     1055    1175,  1180,  1187,  1189,  1196,  1201,  1206,  1217,  1222,  1227,
     1056    1232,  1237,  1246,  1251,  1259,  1260,  1261,  1262,  1268,  1273,
     1057    1281,  1282,  1283,  1284,  1288,  1289,  1290,  1291,  1296,  1297,
     1058    1306,  1307,  1312,  1313,  1318,  1320,  1322,  1324,  1326,  1329,
     1059    1328,  1340,  1341,  1343,  1353,  1354,  1359,  1361,  1363,  1365,
     1060    1367,  1370,  1372,  1375,  1380,  1382,  1384,  1386,  1388,  1390,
     1061    1392,  1394,  1396,  1398,  1400,  1402,  1404,  1410,  1411,  1413,
     1062    1415,  1417,  1422,  1423,  1429,  1430,  1432,  1434,  1439,  1441,
     1063    1443,  1445,  1450,  1451,  1453,  1455,  1460,  1461,  1463,  1468,
     1064    1469,  1471,  1473,  1478,  1480,  1482,  1487,  1488,  1492,  1494,
     1065    1500,  1499,  1503,  1505,  1510,  1512,  1518,  1519,  1524,  1525,
     1066    1527,  1528,  1537,  1538,  1540,  1542,  1547,  1549,  1555,  1556,
     1067    1558,  1561,  1564,  1569,  1570,  1575,  1580,  1584,  1586,  1592,
     1068    1591,  1598,  1600,  1606,  1607,  1615,  1616,  1620,  1621,  1622,
     1069    1624,  1626,  1633,  1634,  1636,  1638,  1643,  1644,  1650,  1651,
     1070    1655,  1656,  1661,  1662,  1663,  1665,  1673,  1674,  1676,  1679,
     1071    1681,  1685,  1686,  1687,  1689,  1691,  1695,  1700,  1708,  1709,
     1072    1718,  1720,  1725,  1726,  1727,  1731,  1732,  1733,  1737,  1738,
     1073    1739,  1743,  1744,  1745,  1750,  1751,  1752,  1753,  1759,  1760,
     1074    1762,  1767,  1768,  1773,  1774,  1775,  1776,  1777,  1792,  1793,
     1075    1798,  1799,  1805,  1807,  1810,  1812,  1814,  1837,  1838,  1840,
     1076    1842,  1847,  1848,  1850,  1855,  1860,  1861,  1867,  1866,  1870,
     1077    1874,  1876,  1878,  1884,  1885,  1890,  1895,  1897,  1902,  1904,
     1078    1905,  1907,  1912,  1914,  1916,  1921,  1923,  1928,  1933,  1941,
     1079    1947,  1946,  1960,  1961,  1966,  1967,  1971,  1976,  1981,  1989,
     1080    1994,  2005,  2006,  2011,  2012,  2018,  2019,  2023,  2024,  2025,
     1081    2028,  2027,  2038,  2047,  2053,  2059,  2068,  2074,  2080,  2086,
     1082    2092,  2100,  2106,  2114,  2120,  2129,  2130,  2131,  2135,  2139,
     1083    2141,  2146,  2147,  2151,  2152,  2157,  2163,  2164,  2167,  2169,
     1084    2170,  2174,  2175,  2176,  2177,  2211,  2213,  2214,  2216,  2221,
     1085    2226,  2231,  2233,  2235,  2240,  2242,  2244,  2246,  2251,  2253,
     1086    2262,  2264,  2265,  2270,  2272,  2274,  2279,  2281,  2283,  2288,
     1087    2290,  2292,  2301,  2302,  2303,  2307,  2309,  2311,  2316,  2318,
     1088    2320,  2325,  2327,  2329,  2344,  2346,  2347,  2349,  2354,  2355,
     1089    2360,  2362,  2364,  2369,  2371,  2373,  2375,  2380,  2382,  2384,
     1090    2394,  2396,  2397,  2399,  2404,  2406,  2408,  2413,  2415,  2417,
     1091    2419,  2424,  2426,  2428,  2459,  2461,  2462,  2464,  2469,  2474,
     1092    2482,  2484,  2486,  2491,  2493,  2498,  2500,  2514,  2515,  2517,
     1093    2522,  2524,  2526,  2528,  2530,  2535,  2536,  2538,  2540,  2545,
     1094    2547,  2549,  2555,  2557,  2559,  2563,  2565,  2567,  2569,  2583,
     1095    2584,  2586,  2591,  2593,  2595,  2597,  2599,  2604,  2605,  2607,
     1096    2609,  2614,  2616,  2618,  2624,  2625,  2627,  2636,  2639,  2641,
     1097    2644,  2646,  2648,  2661,  2662,  2664,  2669,  2671,  2673,  2675,
     1098    2677,  2682,  2683,  2685,  2687,  2692,  2694,  2702,  2703,  2704,
     1099    2709,  2710,  2714,  2716,  2718,  2720,  2722,  2724,  2731,  2733,
     1100    2735,  2737,  2739,  2742,  2744,  2746,  2748,  2750,  2755,  2757,
     1101    2759,  2764,  2790,  2791,  2793,  2797,  2798,  2802,  2804,  2806,
     1102    2808,  2810,  2812,  2819,  2821,  2823,  2825,  2827,  2829,  2834,
     1103    2841,  2843,  2861,  2863,  2868,  2869
    11041104};
    11051105#endif
    … …  
    48514851
    48524852/* Line 1806 of yacc.c  */
    4853 #line 305 "parser.yy"
     4853#line 306 "parser.yy"
    48544854    { typedefTable.enterScope(); }
    48554855    break;
    … …  
    48584858
    48594859/* Line 1806 of yacc.c  */
    4860 #line 309 "parser.yy"
     4860#line 310 "parser.yy"
    48614861    { typedefTable.leaveScope(); }
    48624862    break;
    … …  
    48654865
    48664866/* Line 1806 of yacc.c  */
    4867 #line 316 "parser.yy"
     4867#line 317 "parser.yy"
    48684868    { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
    48694869    break;
    48704870
    48714871  case 5:
    4872 
    4873 /* Line 1806 of yacc.c  */
    4874 #line 317 "parser.yy"
    4875     { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
    4876     break;
    4877 
    4878   case 6:
    48794872
    48804873/* Line 1806 of yacc.c  */
    … …  
    48834876    break;
    48844877
    4885   case 7:
     4878  case 6:
    48864879
    48874880/* Line 1806 of yacc.c  */
    … …  
    48904883    break;
    48914884
     4885  case 7:
     4886
     4887/* Line 1806 of yacc.c  */
     4888#line 320 "parser.yy"
     4889    { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
     4890    break;
     4891
    48924892  case 8:
    48934893
    48944894/* Line 1806 of yacc.c  */
    4895 #line 320 "parser.yy"
     4895#line 321 "parser.yy"
    48964896    { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); }
    48974897    break;
    … …  
    49004900
    49014901/* Line 1806 of yacc.c  */
    4902 #line 345 "parser.yy"
     4902#line 346 "parser.yy"
    49034903    { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].str) ); }
    49044904    break;
    … …  
    49074907
    49084908/* Line 1806 of yacc.c  */
    4909 #line 349 "parser.yy"
     4909#line 350 "parser.yy"
    49104910    { (yyval.str) = (yyvsp[(1) - (1)].tok); }
    49114911    break;
    … …  
    49144914
    49154915/* Line 1806 of yacc.c  */
    4916 #line 351 "parser.yy"
     4916#line 352 "parser.yy"
    49174917    {
    49184918                        appendStr( (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].tok) );                                            // append 2nd juxtaposed string to 1st
    … …  
    49254925
    49264926/* Line 1806 of yacc.c  */
    4927 #line 362 "parser.yy"
     4927#line 363 "parser.yy"
    49284928    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    49294929    break;
    … …  
    49324932
    49334933/* Line 1806 of yacc.c  */
    4934 #line 364 "parser.yy"
     4934#line 365 "parser.yy"
    49354935    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
    49364936    break;
    … …  
    49394939
    49404940/* Line 1806 of yacc.c  */
    4941 #line 367 "parser.yy"
     4941#line 368 "parser.yy"
    49424942    { (yyval.en) = (yyvsp[(2) - (3)].en); }
    49434943    break;
    … …  
    49464946
    49474947/* Line 1806 of yacc.c  */
    4948 #line 369 "parser.yy"
     4948#line 370 "parser.yy"
    49494949    { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); }
    49504950    break;
    … …  
    49534953
    49544954/* Line 1806 of yacc.c  */
    4955 #line 379 "parser.yy"
     4955#line 380 "parser.yy"
    49564956    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
    49574957    break;
    … …  
    49604960
    49614961/* Line 1806 of yacc.c  */
    4962 #line 381 "parser.yy"
     4962#line 382 "parser.yy"
    49634963    { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
    49644964    break;
    … …  
    49674967
    49684968/* Line 1806 of yacc.c  */
    4969 #line 383 "parser.yy"
     4969#line 384 "parser.yy"
    49704970    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
    49714971    break;
    49724972
    4973   case 30:
    4974 
    4975 /* Line 1806 of yacc.c  */
    4976 #line 385 "parser.yy"
    4977     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
    4978     break;
    4979 
    4980   case 31:
    4981 
    4982 /* Line 1806 of yacc.c  */
    4983 #line 387 "parser.yy"
    4984     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (2)].en), build_constantInteger( *(yyvsp[(2) - (2)].tok) ) ) ); }
    4985     break;
    4986 
    49874973  case 32:
    49884974
    49894975/* Line 1806 of yacc.c  */
    4990 #line 389 "parser.yy"
     4976#line 388 "parser.yy"
    49914977    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
    49924978    break;
    49934979
    4994   case 33:
     4980  case 34:
    49954981
    49964982/* Line 1806 of yacc.c  */
    49974983#line 391 "parser.yy"
    4998     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
    4999     break;
    5000 
    5001   case 34:
     4984    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
     4985    break;
     4986
     4987  case 35:
    50024988
    50034989/* Line 1806 of yacc.c  */
    50044990#line 393 "parser.yy"
    5005     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
    5006     break;
    5007 
    5008   case 35:
     4991    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
     4992    break;
     4993
     4994  case 36:
    50094995
    50104996/* Line 1806 of yacc.c  */
    50114997#line 395 "parser.yy"
    5012     { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
    5013     break;
    5014 
    5015   case 36:
     4998    { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
     4999    break;
     5000
     5001  case 37:
    50165002
    50175003/* Line 1806 of yacc.c  */
    50185004#line 397 "parser.yy"
    5019     { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
    5020     break;
    5021 
    5022   case 37:
    5023 
    5024 /* Line 1806 of yacc.c  */
    5025 #line 399 "parser.yy"
    50265005    {
    50275006                        Token fn;
    … …  
    50345013
    50355014/* Line 1806 of yacc.c  */
    5036 #line 409 "parser.yy"
     5015#line 407 "parser.yy"
    50375016    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
    50385017    break;
    … …  
    50415020
    50425021/* Line 1806 of yacc.c  */
    5043 #line 414 "parser.yy"
     5022#line 412 "parser.yy"
    50445023    { (yyval.en) = 0; }
    50455024    break;
    … …  
    50485027
    50495028/* Line 1806 of yacc.c  */
    5050 #line 420 "parser.yy"
     5029#line 418 "parser.yy"
    50515030    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    50525031    break;
    50535032
     5033  case 44:
     5034
     5035/* Line 1806 of yacc.c  */
     5036#line 423 "parser.yy"
     5037    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     5038    break;
     5039
    50545040  case 45:
    50555041
    50565042/* Line 1806 of yacc.c  */
    5057 #line 426 "parser.yy"
    5058     { (yyval.en) = new ExpressionNode( build_fieldSel( new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (2)].tok) ) ), maybeMoveBuild<Expression>( (yyvsp[(2) - (2)].en) ) ) ); }
     5043#line 425 "parser.yy"
     5044    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(2) - (2)].en), build_varref( (yyvsp[(1) - (2)].tok) ) ) ); }
    50595045    break;
    50605046
    … …  
    50625048
    50635049/* Line 1806 of yacc.c  */
    5064 #line 428 "parser.yy"
    5065     { (yyval.en) = new ExpressionNode( build_fieldSel( new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (6)].tok) ) ), build_tuple( (yyvsp[(4) - (6)].en) ) ) ); }
     5050#line 427 "parser.yy"
     5051    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(4) - (6)].en), build_varref( (yyvsp[(1) - (6)].tok) ) ) ); }
    50665052    break;
    50675053
    … …  
    50695055
    50705056/* Line 1806 of yacc.c  */
    5071 #line 430 "parser.yy"
    5072     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), maybeMoveBuild<Expression>( (yyvsp[(3) - (3)].en) ) ) ); }
     5057#line 429 "parser.yy"
     5058    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
    50735059    break;
    50745060
    … …  
    50765062
    50775063/* Line 1806 of yacc.c  */
    5078 #line 432 "parser.yy"
    5079     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
     5064#line 431 "parser.yy"
     5065    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
    50805066    break;
    50815067
    … …  
    50835069
    50845070/* Line 1806 of yacc.c  */
    5085 #line 434 "parser.yy"
    5086     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), maybeMoveBuild<Expression>( (yyvsp[(3) - (3)].en) ) ) ); }
     5071#line 433 "parser.yy"
     5072    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
    50875073    break;
    50885074
    … …  
    50905076
    50915077/* Line 1806 of yacc.c  */
    5092 #line 436 "parser.yy"
    5093     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
     5078#line 435 "parser.yy"
     5079    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
    50945080    break;
    50955081
    … …  
    50975083
    50985084/* Line 1806 of yacc.c  */
    5099 #line 441 "parser.yy"
    5100     { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (2)].tok) ) ); }
     5085#line 440 "parser.yy"
     5086    { (yyval.tok) = (yyvsp[(1) - (2)].tok); }
    51015087    break;
    51025088
    … …  
    51045090
    51055091/* Line 1806 of yacc.c  */
    5106 #line 443 "parser.yy"
    5107     { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (2)].tok) ) ); }
     5092#line 442 "parser.yy"
     5093    { (yyval.tok) = (yyvsp[(1) - (2)].tok); }
    51085094    break;
    51095095
    … …  
    51115097
    51125098/* Line 1806 of yacc.c  */
    5113 #line 445 "parser.yy"
    5114     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
     5099#line 444 "parser.yy"
     5100    { (yyval.tok) = (yyvsp[(1) - (2)].tok); }
    51155101    break;
    51165102
    … …  
    51185104
    51195105/* Line 1806 of yacc.c  */
    5120 #line 458 "parser.yy"
     5106#line 457 "parser.yy"
    51215107    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    51225108    break;
    … …  
    51255111
    51265112/* Line 1806 of yacc.c  */
    5127 #line 460 "parser.yy"
     5113#line 459 "parser.yy"
    51285114    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    51295115    break;
    … …  
    51325118
    51335119/* Line 1806 of yacc.c  */
    5134 #line 462 "parser.yy"
     5120#line 461 "parser.yy"
    51355121    { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
    51365122    break;
    … …  
    51395125
    51405126/* Line 1806 of yacc.c  */
    5141 #line 467 "parser.yy"
     5127#line 466 "parser.yy"
    51425128    {
    51435129                        switch ( (yyvsp[(1) - (2)].op) ) {
    … …  
    51575143
    51585144/* Line 1806 of yacc.c  */
    5159 #line 480 "parser.yy"
     5145#line 479 "parser.yy"
    51605146    { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
    51615147    break;
    … …  
    51645150
    51655151/* Line 1806 of yacc.c  */
    5166 #line 482 "parser.yy"
     5152#line 481 "parser.yy"
    51675153    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
    51685154    break;
    … …  
    51715157
    51725158/* Line 1806 of yacc.c  */
    5173 #line 484 "parser.yy"
     5159#line 483 "parser.yy"
    51745160    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
    51755161    break;
    … …  
    51785164
    51795165/* Line 1806 of yacc.c  */
    5180 #line 486 "parser.yy"
     5166#line 485 "parser.yy"
    51815167    { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    51825168    break;
    … …  
    51855171
    51865172/* Line 1806 of yacc.c  */
    5187 #line 488 "parser.yy"
     5173#line 487 "parser.yy"
    51885174    { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
    51895175    break;
    … …  
    51925178
    51935179/* Line 1806 of yacc.c  */
    5194 #line 490 "parser.yy"
     5180#line 489 "parser.yy"
    51955181    { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
    51965182    break;
    … …  
    51995185
    52005186/* Line 1806 of yacc.c  */
    5201 #line 492 "parser.yy"
     5187#line 491 "parser.yy"
    52025188    { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
    52035189    break;
    … …  
    52065192
    52075193/* Line 1806 of yacc.c  */
    5208 #line 494 "parser.yy"
     5194#line 493 "parser.yy"
    52095195    { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
    52105196    break;
    … …  
    52135199
    52145200/* Line 1806 of yacc.c  */
    5215 #line 496 "parser.yy"
     5201#line 495 "parser.yy"
    52165202    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
    52175203    break;
    … …  
    52205206
    52215207/* Line 1806 of yacc.c  */
    5222 #line 498 "parser.yy"
     5208#line 497 "parser.yy"
    52235209    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
    52245210    break;
    … …  
    52275213
    52285214/* Line 1806 of yacc.c  */
    5229 #line 500 "parser.yy"
     5215#line 499 "parser.yy"
    52305216    { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
    52315217    break;
    … …  
    52345220
    52355221/* Line 1806 of yacc.c  */
     5222#line 505 "parser.yy"
     5223    { (yyval.op) = OperKinds::PointTo; }
     5224    break;
     5225
     5226  case 73:
     5227
     5228/* Line 1806 of yacc.c  */
    52365229#line 506 "parser.yy"
    5237     { (yyval.op) = OperKinds::PointTo; }
    5238     break;
    5239 
    5240   case 73:
    5241 
    5242 /* Line 1806 of yacc.c  */
    5243 #line 507 "parser.yy"
    52445230    { (yyval.op) = OperKinds::AddressOf; }
    52455231    break;
    … …  
    52485234
    52495235/* Line 1806 of yacc.c  */
     5236#line 512 "parser.yy"
     5237    { (yyval.op) = OperKinds::UnPlus; }
     5238    break;
     5239
     5240  case 75:
     5241
     5242/* Line 1806 of yacc.c  */
    52505243#line 513 "parser.yy"
    5251     { (yyval.op) = OperKinds::UnPlus; }
    5252     break;
    5253 
    5254   case 75:
     5244    { (yyval.op) = OperKinds::UnMinus; }
     5245    break;
     5246
     5247  case 76:
    52555248
    52565249/* Line 1806 of yacc.c  */
    52575250#line 514 "parser.yy"
    5258     { (yyval.op) = OperKinds::UnMinus; }
    5259     break;
    5260 
    5261   case 76:
     5251    { (yyval.op) = OperKinds::Neg; }
     5252    break;
     5253
     5254  case 77:
    52625255
    52635256/* Line 1806 of yacc.c  */
    52645257#line 515 "parser.yy"
    5265     { (yyval.op) = OperKinds::Neg; }
    5266     break;
    5267 
    5268   case 77:
    5269 
    5270 /* Line 1806 of yacc.c  */
    5271 #line 516 "parser.yy"
    52725258    { (yyval.op) = OperKinds::BitNeg; }
    52735259    break;
    … …  
    52765262
    52775263/* Line 1806 of yacc.c  */
    5278 #line 522 "parser.yy"
     5264#line 521 "parser.yy"
    52795265    { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
    52805266    break;
    … …  
    52835269
    52845270/* Line 1806 of yacc.c  */
    5285 #line 530 "parser.yy"
     5271#line 529 "parser.yy"
    52865272    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    52875273    break;
    … …  
    52905276
    52915277/* Line 1806 of yacc.c  */
    5292 #line 532 "parser.yy"
     5278#line 531 "parser.yy"
    52935279    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    52945280    break;
    … …  
    52975283
    52985284/* Line 1806 of yacc.c  */
    5299 #line 534 "parser.yy"
     5285#line 533 "parser.yy"
    53005286    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53015287    break;
    … …  
    53045290
    53055291/* Line 1806 of yacc.c  */
    5306 #line 540 "parser.yy"
     5292#line 539 "parser.yy"
    53075293    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53085294    break;
    … …  
    53115297
    53125298/* Line 1806 of yacc.c  */
    5313 #line 542 "parser.yy"
     5299#line 541 "parser.yy"
    53145300    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53155301    break;
    … …  
    53185304
    53195305/* Line 1806 of yacc.c  */
    5320 #line 548 "parser.yy"
     5306#line 547 "parser.yy"
    53215307    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53225308    break;
    … …  
    53255311
    53265312/* Line 1806 of yacc.c  */
    5327 #line 550 "parser.yy"
     5313#line 549 "parser.yy"
    53285314    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53295315    break;
    … …  
    53325318
    53335319/* Line 1806 of yacc.c  */
    5334 #line 556 "parser.yy"
     5320#line 555 "parser.yy"
    53355321    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53365322    break;
    … …  
    53395325
    53405326/* Line 1806 of yacc.c  */
    5341 #line 558 "parser.yy"
     5327#line 557 "parser.yy"
    53425328    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53435329    break;
    … …  
    53465332
    53475333/* Line 1806 of yacc.c  */
    5348 #line 560 "parser.yy"
     5334#line 559 "parser.yy"
    53495335    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53505336    break;
    … …  
    53535339
    53545340/* Line 1806 of yacc.c  */
    5355 #line 562 "parser.yy"
     5341#line 561 "parser.yy"
    53565342    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53575343    break;
    … …  
    53605346
    53615347/* Line 1806 of yacc.c  */
    5362 #line 568 "parser.yy"
     5348#line 567 "parser.yy"
    53635349    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53645350    break;
    … …  
    53675353
    53685354/* Line 1806 of yacc.c  */
    5369 #line 570 "parser.yy"
     5355#line 569 "parser.yy"
    53705356    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53715357    break;
    … …  
    53745360
    53755361/* Line 1806 of yacc.c  */
    5376 #line 576 "parser.yy"
     5362#line 575 "parser.yy"
    53775363    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53785364    break;
    … …  
    53815367
    53825368/* Line 1806 of yacc.c  */
    5383 #line 582 "parser.yy"
     5369#line 581 "parser.yy"
    53845370    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53855371    break;
    … …  
    53885374
    53895375/* Line 1806 of yacc.c  */
    5390 #line 588 "parser.yy"
     5376#line 587 "parser.yy"
    53915377    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    53925378    break;
    … …  
    53955381
    53965382/* Line 1806 of yacc.c  */
    5397 #line 594 "parser.yy"
     5383#line 593 "parser.yy"
    53985384    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
    53995385    break;
    … …  
    54025388
    54035389/* Line 1806 of yacc.c  */
    5404 #line 600 "parser.yy"
     5390#line 599 "parser.yy"
    54055391    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
    54065392    break;
    … …  
    54095395
    54105396/* Line 1806 of yacc.c  */
    5411 #line 606 "parser.yy"
     5397#line 605 "parser.yy"
    54125398    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
    54135399    break;
    … …  
    54165402
    54175403/* Line 1806 of yacc.c  */
    5418 #line 609 "parser.yy"
     5404#line 608 "parser.yy"
    54195405    { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
    54205406    break;
    … …  
    54235409
    54245410/* Line 1806 of yacc.c  */
    5425 #line 622 "parser.yy"
     5411#line 621 "parser.yy"
    54265412    { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    54275413    break;
    … …  
    54305416
    54315417/* Line 1806 of yacc.c  */
    5432 #line 629 "parser.yy"
     5418#line 628 "parser.yy"
    54335419    { (yyval.en) = nullptr; }
    54345420    break;
    … …  
    54375423
    54385424/* Line 1806 of yacc.c  */
     5425#line 633 "parser.yy"
     5426    { (yyval.op) = OperKinds::Assign; }
     5427    break;
     5428
     5429  case 117:
     5430
     5431/* Line 1806 of yacc.c  */
    54395432#line 634 "parser.yy"
    5440     { (yyval.op) = OperKinds::Assign; }
    5441     break;
    5442 
    5443   case 117:
     5433    { (yyval.op) = OperKinds::AtAssn; }
     5434    break;
     5435
     5436  case 118:
    54445437
    54455438/* Line 1806 of yacc.c  */
    54465439#line 635 "parser.yy"
    5447     { (yyval.op) = OperKinds::AtAssn; }
    5448     break;
    5449 
    5450   case 118:
     5440    { (yyval.op) = OperKinds::MulAssn; }
     5441    break;
     5442
     5443  case 119:
    54515444
    54525445/* Line 1806 of yacc.c  */
    54535446#line 636 "parser.yy"
    5454     { (yyval.op) = OperKinds::MulAssn; }
    5455     break;
    5456 
    5457   case 119:
     5447    { (yyval.op) = OperKinds::DivAssn; }
     5448    break;
     5449
     5450  case 120:
    54585451
    54595452/* Line 1806 of yacc.c  */
    54605453#line 637 "parser.yy"
    5461     { (yyval.op) = OperKinds::DivAssn; }
    5462     break;
    5463 
    5464   case 120:
     5454    { (yyval.op) = OperKinds::ModAssn; }
     5455    break;
     5456
     5457  case 121:
    54655458
    54665459/* Line 1806 of yacc.c  */
    54675460#line 638 "parser.yy"
    5468     { (yyval.op) = OperKinds::ModAssn; }
    5469     break;
    5470 
    5471   case 121:
     5461    { (yyval.op) = OperKinds::PlusAssn; }
     5462    break;
     5463
     5464  case 122:
    54725465
    54735466/* Line 1806 of yacc.c  */
    54745467#line 639 "parser.yy"
    5475     { (yyval.op) = OperKinds::PlusAssn; }
    5476     break;
    5477 
    5478   case 122:
     5468    { (yyval.op) = OperKinds::MinusAssn; }
     5469    break;
     5470
     5471  case 123:
    54795472
    54805473/* Line 1806 of yacc.c  */
    54815474#line 640 "parser.yy"
    5482     { (yyval.op) = OperKinds::MinusAssn; }
    5483     break;
    5484 
    5485   case 123:
     5475    { (yyval.op) = OperKinds::LSAssn; }
     5476    break;
     5477
     5478  case 124:
    54865479
    54875480/* Line 1806 of yacc.c  */
    54885481#line 641 "parser.yy"
    5489     { (yyval.op) = OperKinds::LSAssn; }
    5490     break;
    5491 
    5492   case 124:
     5482    { (yyval.op) = OperKinds::RSAssn; }
     5483    break;
     5484
     5485  case 125:
    54935486
    54945487/* Line 1806 of yacc.c  */
    54955488#line 642 "parser.yy"
    5496     { (yyval.op) = OperKinds::RSAssn; }
    5497     break;
    5498 
    5499   case 125:
     5489    { (yyval.op) = OperKinds::AndAssn; }
     5490    break;
     5491
     5492  case 126:
    55005493
    55015494/* Line 1806 of yacc.c  */
    55025495#line 643 "parser.yy"
    5503     { (yyval.op) = OperKinds::AndAssn; }
    5504     break;
    5505 
    5506   case 126:
     5496    { (yyval.op) = OperKinds::ERAssn; }
     5497    break;
     5498
     5499  case 127:
    55075500
    55085501/* Line 1806 of yacc.c  */
    55095502#line 644 "parser.yy"
    5510     { (yyval.op) = OperKinds::ERAssn; }
    5511     break;
    5512 
    5513   case 127:
    5514 
    5515 /* Line 1806 of yacc.c  */
    5516 #line 645 "parser.yy"
    55175503    { (yyval.op) = OperKinds::OrAssn; }
    55185504    break;
    … …  
    55215507
    55225508/* Line 1806 of yacc.c  */
    5523 #line 656 "parser.yy"
     5509#line 655 "parser.yy"
    55245510    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); }
    55255511    break;
    … …  
    55285514
    55295515/* Line 1806 of yacc.c  */
    5530 #line 658 "parser.yy"
     5516#line 657 "parser.yy"
    55315517    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
    55325518    break;
    … …  
    55355521
    55365522/* Line 1806 of yacc.c  */
    5537 #line 664 "parser.yy"
     5523#line 663 "parser.yy"
    55385524    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    55395525    break;
    … …  
    55425528
    55435529/* Line 1806 of yacc.c  */
    5544 #line 670 "parser.yy"
     5530#line 669 "parser.yy"
    55455531    { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    55465532    break;
    … …  
    55495535
    55505536/* Line 1806 of yacc.c  */
    5551 #line 675 "parser.yy"
     5537#line 674 "parser.yy"
    55525538    { (yyval.en) = 0; }
    55535539    break;
    … …  
    55565542
    55575543/* Line 1806 of yacc.c  */
    5558 #line 684 "parser.yy"
     5544#line 683 "parser.yy"
    55595545    { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
    55605546    break;
    … …  
    55635549
    55645550/* Line 1806 of yacc.c  */
    5565 #line 691 "parser.yy"
     5551#line 690 "parser.yy"
    55665552    {
    55675553                        Token fn;
    … …  
    55745560
    55755561/* Line 1806 of yacc.c  */
    5576 #line 701 "parser.yy"
     5562#line 700 "parser.yy"
    55775563    {
    55785564                        (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
    … …  
    55835569
    55845570/* Line 1806 of yacc.c  */
    5585 #line 708 "parser.yy"
     5571#line 707 "parser.yy"
    55865572    { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); }
    55875573    break;
    … …  
    55905576
    55915577/* Line 1806 of yacc.c  */
    5592 #line 715 "parser.yy"
     5578#line 714 "parser.yy"
    55935579    { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); }
    55945580    break;
    … …  
    55975583
    55985584/* Line 1806 of yacc.c  */
    5599 #line 721 "parser.yy"
     5585#line 720 "parser.yy"
    56005586    { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
    56015587    break;
    … …  
    56045590
    56055591/* Line 1806 of yacc.c  */
    5606 #line 726 "parser.yy"
     5592#line 725 "parser.yy"
    56075593    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    56085594    break;
    … …  
    56115597
    56125598/* Line 1806 of yacc.c  */
    5613 #line 728 "parser.yy"
     5599#line 727 "parser.yy"
    56145600    {   // mark all fields in list
    56155601                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
    … …  
    56225608
    56235609/* Line 1806 of yacc.c  */
    5624 #line 734 "parser.yy"
     5610#line 733 "parser.yy"
    56255611    { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
    56265612    break;
    … …  
    56295615
    56305616/* Line 1806 of yacc.c  */
    5631 #line 741 "parser.yy"
     5617#line 740 "parser.yy"
    56325618    { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
    56335619    break;
    … …  
    56365622
    56375623/* Line 1806 of yacc.c  */
    5638 #line 746 "parser.yy"
     5624#line 745 "parser.yy"
    56395625    { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); }
    56405626    break;
    … …  
    56435629
    56445630/* Line 1806 of yacc.c  */
    5645 #line 752 "parser.yy"
     5631#line 751 "parser.yy"
    56465632    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
    56475633    break;
    … …  
    56505636
    56515637/* Line 1806 of yacc.c  */
    5652 #line 754 "parser.yy"
     5638#line 753 "parser.yy"
    56535639    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
    56545640    break;
    … …  
    56575643
    56585644/* Line 1806 of yacc.c  */
    5659 #line 756 "parser.yy"
     5645#line 755 "parser.yy"
    56605646    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    56615647    break;
    … …  
    56645650
    56655651/* Line 1806 of yacc.c  */
    5666 #line 758 "parser.yy"
     5652#line 757 "parser.yy"
    56675653    {
    56685654                        StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
    … …  
    56795665
    56805666/* Line 1806 of yacc.c  */
    5681 #line 768 "parser.yy"
     5667#line 767 "parser.yy"
    56825668    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    56835669    break;
    … …  
    56865672
    56875673/* Line 1806 of yacc.c  */
    5688 #line 770 "parser.yy"
     5674#line 769 "parser.yy"
    56895675    {
    56905676                        StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
    … …  
    56965682
    56975683/* Line 1806 of yacc.c  */
    5698 #line 780 "parser.yy"
     5684#line 779 "parser.yy"
    56995685    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    57005686    break;
    … …  
    57035689
    57045690/* Line 1806 of yacc.c  */
    5705 #line 782 "parser.yy"
     5691#line 781 "parser.yy"
    57065692    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    57075693    break;
    … …  
    57105696
    57115697/* Line 1806 of yacc.c  */
    5712 #line 787 "parser.yy"
     5698#line 786 "parser.yy"
    57135699    { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
    57145700    break;
    … …  
    57175703
    57185704/* Line 1806 of yacc.c  */
    5719 #line 789 "parser.yy"
     5705#line 788 "parser.yy"
    57205706    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
    57215707    break;
    … …  
    57245710
    57255711/* Line 1806 of yacc.c  */
     5712#line 792 "parser.yy"
     5713    { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
     5714    break;
     5715
     5716  case 169:
     5717
     5718/* Line 1806 of yacc.c  */
    57265719#line 793 "parser.yy"
    5727     { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
    5728     break;
    5729 
    5730   case 169:
    5731 
    5732 /* Line 1806 of yacc.c  */
    5733 #line 794 "parser.yy"
    57345720    { (yyval.sn) = new StatementNode( build_default() ); }
    57355721    break;
    … …  
    57385724
    57395725/* Line 1806 of yacc.c  */
    5740 #line 800 "parser.yy"
     5726#line 799 "parser.yy"
    57415727    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); }
    57425728    break;
    … …  
    57455731
    57465732/* Line 1806 of yacc.c  */
    5747 #line 804 "parser.yy"
     5733#line 803 "parser.yy"
    57485734    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
    57495735    break;
    … …  
    57525738
    57535739/* Line 1806 of yacc.c  */
    5754 #line 809 "parser.yy"
     5740#line 808 "parser.yy"
    57555741    { (yyval.sn) = 0; }
    57565742    break;
    … …  
    57595745
    57605746/* Line 1806 of yacc.c  */
    5761 #line 815 "parser.yy"
     5747#line 814 "parser.yy"
    57625748    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
    57635749    break;
    … …  
    57665752
    57675753/* Line 1806 of yacc.c  */
    5768 #line 817 "parser.yy"
     5754#line 816 "parser.yy"
    57695755    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); }
    57705756    break;
    … …  
    57735759
    57745760/* Line 1806 of yacc.c  */
    5775 #line 822 "parser.yy"
     5761#line 821 "parser.yy"
    57765762    { (yyval.sn) = 0; }
    57775763    break;
    … …  
    57805766
    57815767/* Line 1806 of yacc.c  */
    5782 #line 828 "parser.yy"
     5768#line 827 "parser.yy"
    57835769    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
    57845770    break;
    … …  
    57875773
    57885774/* Line 1806 of yacc.c  */
    5789 #line 830 "parser.yy"
     5775#line 829 "parser.yy"
    57905776    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); }
    57915777    break;
    … …  
    57945780
    57955781/* Line 1806 of yacc.c  */
    5796 #line 832 "parser.yy"
     5782#line 831 "parser.yy"
    57975783    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
    57985784    break;
    … …  
    58015787
    58025788/* Line 1806 of yacc.c  */
    5803 #line 834 "parser.yy"
     5789#line 833 "parser.yy"
    58045790    { (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) ) ) ) ) ) ); }
    58055791    break;
    … …  
    58085794
    58095795/* Line 1806 of yacc.c  */
    5810 #line 839 "parser.yy"
     5796#line 838 "parser.yy"
    58115797    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
    58125798    break;
    … …  
    58155801
    58165802/* Line 1806 of yacc.c  */
    5817 #line 845 "parser.yy"
     5803#line 844 "parser.yy"
    58185804    { (yyval.sn) = 0; }
    58195805    break;
    … …  
    58225808
    58235809/* Line 1806 of yacc.c  */
    5824 #line 847 "parser.yy"
     5810#line 846 "parser.yy"
    58255811    { (yyval.sn) = 0; }
    58265812    break;
    … …  
    58295815
    58305816/* Line 1806 of yacc.c  */
    5831 #line 852 "parser.yy"
     5817#line 851 "parser.yy"
    58325818    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
    58335819    break;
    … …  
    58365822
    58375823/* Line 1806 of yacc.c  */
    5838 #line 854 "parser.yy"
     5824#line 853 "parser.yy"
    58395825    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); }
    58405826    break;
    … …  
    58435829
    58445830/* Line 1806 of yacc.c  */
    5845 #line 856 "parser.yy"
     5831#line 855 "parser.yy"
    58465832    { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
    58475833    break;
    … …  
    58505836
    58515837/* Line 1806 of yacc.c  */
    5852 #line 861 "parser.yy"
     5838#line 860 "parser.yy"
    58535839    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
    58545840    break;
    … …  
    58575843
    58585844/* Line 1806 of yacc.c  */
    5859 #line 863 "parser.yy"
     5845#line 862 "parser.yy"
    58605846    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
    58615847    break;
    … …  
    58645850
    58655851/* Line 1806 of yacc.c  */
    5866 #line 868 "parser.yy"
     5852#line 867 "parser.yy"
    58675853    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
    58685854    break;
    … …  
    58715857
    58725858/* Line 1806 of yacc.c  */
    5873 #line 872 "parser.yy"
     5859#line 871 "parser.yy"
    58745860    { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
    58755861    break;
    … …  
    58785864
    58795865/* Line 1806 of yacc.c  */
    5880 #line 875 "parser.yy"
     5866#line 874 "parser.yy"
    58815867    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
    58825868    break;
    … …  
    58855871
    58865872/* Line 1806 of yacc.c  */
    5887 #line 879 "parser.yy"
     5873#line 878 "parser.yy"
    58885874    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
    58895875    break;
    … …  
    58925878
    58935879/* Line 1806 of yacc.c  */
    5894 #line 882 "parser.yy"
     5880#line 881 "parser.yy"
    58955881    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
    58965882    break;
    … …  
    58995885
    59005886/* Line 1806 of yacc.c  */
    5901 #line 886 "parser.yy"
     5887#line 885 "parser.yy"
    59025888    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); }
    59035889    break;
    … …  
    59065892
    59075893/* Line 1806 of yacc.c  */
    5908 #line 888 "parser.yy"
     5894#line 887 "parser.yy"
    59095895    { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
    59105896    break;
    … …  
    59135899
    59145900/* Line 1806 of yacc.c  */
    5915 #line 890 "parser.yy"
     5901#line 889 "parser.yy"
    59165902    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    59175903    break;
    … …  
    59205906
    59215907/* Line 1806 of yacc.c  */
    5922 #line 892 "parser.yy"
     5908#line 891 "parser.yy"
    59235909    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
    59245910    break;
    … …  
    59275913
    59285914/* Line 1806 of yacc.c  */
    5929 #line 894 "parser.yy"
     5915#line 893 "parser.yy"
    59305916    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); }
    59315917    break;
    … …  
    59345920
    59355921/* Line 1806 of yacc.c  */
    5936 #line 899 "parser.yy"
     5922#line 898 "parser.yy"
    59375923    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); }
    59385924    break;
    … …  
    59415927
    59425928/* Line 1806 of yacc.c  */
    5943 #line 901 "parser.yy"
     5929#line 900 "parser.yy"
    59445930    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); }
    59455931    break;
    … …  
    59485934
    59495935/* Line 1806 of yacc.c  */
    5950 #line 903 "parser.yy"
     5936#line 902 "parser.yy"
    59515937    { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); }
    59525938    break;
    … …  
    59555941
    59565942/* Line 1806 of yacc.c  */
    5957 #line 910 "parser.yy"
     5943#line 909 "parser.yy"
    59585944    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
    59595945    break;
    … …  
    59625948
    59635949/* Line 1806 of yacc.c  */
    5964 #line 912 "parser.yy"
     5950#line 911 "parser.yy"
    59655951    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
    59665952    break;
    … …  
    59695955
    59705956/* Line 1806 of yacc.c  */
    5971 #line 914 "parser.yy"
     5957#line 913 "parser.yy"
    59725958    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
    59735959    break;
    … …  
    59765962
    59775963/* Line 1806 of yacc.c  */
    5978 #line 916 "parser.yy"
     5964#line 915 "parser.yy"
    59795965    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
    59805966    break;
    … …  
    59835969
    59845970/* Line 1806 of yacc.c  */
    5985 #line 921 "parser.yy"
     5971#line 920 "parser.yy"
    59865972    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
    59875973    break;
    … …  
    59905976
    59915977/* Line 1806 of yacc.c  */
    5992 #line 923 "parser.yy"
     5978#line 922 "parser.yy"
    59935979    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
    59945980    break;
    … …  
    59975983
    59985984/* Line 1806 of yacc.c  */
    5999 #line 925 "parser.yy"
     5985#line 924 "parser.yy"
    60005986    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
    60015987    break;
    … …  
    60045990
    60055991/* Line 1806 of yacc.c  */
    6006 #line 927 "parser.yy"
     5992#line 926 "parser.yy"
    60075993    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
    60085994    break;
    … …  
    60115997
    60125998/* Line 1806 of yacc.c  */
    6013 #line 932 "parser.yy"
     5999#line 931 "parser.yy"
    60146000    {
    60156001                        (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) );
    … …  
    60206006
    60216007/* Line 1806 of yacc.c  */
    6022 #line 945 "parser.yy"
     6008#line 944 "parser.yy"
    60236009    {
    60246010                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    60306016
    60316017/* Line 1806 of yacc.c  */
    6032 #line 950 "parser.yy"
     6018#line 949 "parser.yy"
    60336019    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    60346020    break;
    … …  
    60376023
    60386024/* Line 1806 of yacc.c  */
    6039 #line 952 "parser.yy"
     6025#line 951 "parser.yy"
    60406026    {
    60416027                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    60476033
    60486034/* Line 1806 of yacc.c  */
    6049 #line 961 "parser.yy"
     6035#line 960 "parser.yy"
    60506036    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); }
    60516037    break;
    … …  
    60546040
    60556041/* Line 1806 of yacc.c  */
    6056 #line 963 "parser.yy"
     6042#line 962 "parser.yy"
    60576043    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); }
    60586044    break;
    … …  
    60616047
    60626048/* Line 1806 of yacc.c  */
    6063 #line 965 "parser.yy"
     6049#line 964 "parser.yy"
    60646050    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); }
    60656051    break;
    … …  
    60686054
    60696055/* Line 1806 of yacc.c  */
    6070 #line 967 "parser.yy"
     6056#line 966 "parser.yy"
    60716057    { (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) ) ); }
    60726058    break;
    … …  
    60756061
    60766062/* Line 1806 of yacc.c  */
    6077 #line 969 "parser.yy"
     6063#line 968 "parser.yy"
    60786064    { (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) ) ); }
    60796065    break;
    … …  
    60826068
    60836069/* Line 1806 of yacc.c  */
    6084 #line 974 "parser.yy"
     6070#line 973 "parser.yy"
    60856071    { (yyval.flag) = false; }
    60866072    break;
    … …  
    60896075
    60906076/* Line 1806 of yacc.c  */
    6091 #line 976 "parser.yy"
     6077#line 975 "parser.yy"
    60926078    { (yyval.flag) = true; }
    60936079    break;
    … …  
    60966082
    60976083/* Line 1806 of yacc.c  */
    6098 #line 981 "parser.yy"
     6084#line 980 "parser.yy"
    60996085    { (yyval.en) = 0; }
    61006086    break;
    … …  
    61036089
    61046090/* Line 1806 of yacc.c  */
    6105 #line 988 "parser.yy"
     6091#line 987 "parser.yy"
    61066092    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
    61076093    break;
    … …  
    61106096
    61116097/* Line 1806 of yacc.c  */
    6112 #line 993 "parser.yy"
     6098#line 992 "parser.yy"
    61136099    { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
    61146100    break;
    … …  
    61176103
    61186104/* Line 1806 of yacc.c  */
    6119 #line 995 "parser.yy"
     6105#line 994 "parser.yy"
    61206106    { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
    61216107    break;
    … …  
    61246110
    61256111/* Line 1806 of yacc.c  */
    6126 #line 1000 "parser.yy"
     6112#line 999 "parser.yy"
    61276113    { (yyval.en) = 0; }
    61286114    break;
    … …  
    61316117
    61326118/* Line 1806 of yacc.c  */
    6133 #line 1002 "parser.yy"
     6119#line 1001 "parser.yy"
    61346120    { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
    61356121    break;
    … …  
    61386124
    61396125/* Line 1806 of yacc.c  */
    6140 #line 1004 "parser.yy"
     6126#line 1003 "parser.yy"
    61416127    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
    61426128    break;
    … …  
    61456131
    61466132/* Line 1806 of yacc.c  */
    6147 #line 1009 "parser.yy"
     6133#line 1008 "parser.yy"
    61486134    {
    61496135                        (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) );
    … …  
    61556141
    61566142/* Line 1806 of yacc.c  */
    6157 #line 1014 "parser.yy"
     6143#line 1013 "parser.yy"
    61586144    {
    61596145                        (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) );
    … …  
    61656151
    61666152/* Line 1806 of yacc.c  */
    6167 #line 1024 "parser.yy"
     6153#line 1023 "parser.yy"
    61686154    { (yyval.decl) = 0; }
    61696155    break;
    … …  
    61726158
    61736159/* Line 1806 of yacc.c  */
    6174 #line 1031 "parser.yy"
     6160#line 1030 "parser.yy"
    61756161    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    61766162    break;
    … …  
    61796165
    61806166/* Line 1806 of yacc.c  */
    6181 #line 1036 "parser.yy"
     6167#line 1035 "parser.yy"
    61826168    { (yyval.decl) = 0; }
    61836169    break;
    … …  
    61866172
    61876173/* Line 1806 of yacc.c  */
    6188 #line 1043 "parser.yy"
     6174#line 1042 "parser.yy"
    61896175    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    61906176    break;
    61916177
    61926178  case 250:
     6179
     6180/* Line 1806 of yacc.c  */
     6181#line 1056 "parser.yy"
     6182    {}
     6183    break;
     6184
     6185  case 251:
    61936186
    61946187/* Line 1806 of yacc.c  */
    … …  
    61976190    break;
    61986191
    6199   case 251:
    6200 
    6201 /* Line 1806 of yacc.c  */
    6202 #line 1058 "parser.yy"
    6203     {}
    6204     break;
    6205 
    62066192  case 259:
    62076193
    62086194/* Line 1806 of yacc.c  */
    6209 #line 1087 "parser.yy"
     6195#line 1086 "parser.yy"
    62106196    {
    62116197                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    62176203
    62186204/* Line 1806 of yacc.c  */
    6219 #line 1094 "parser.yy"
     6205#line 1093 "parser.yy"
    62206206    {
    62216207                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    62276213
    62286214/* Line 1806 of yacc.c  */
    6229 #line 1099 "parser.yy"
     6215#line 1098 "parser.yy"
    62306216    {
    62316217                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
    … …  
    62376223
    62386224/* Line 1806 of yacc.c  */
    6239 #line 1109 "parser.yy"
     6225#line 1108 "parser.yy"
    62406226    {
    62416227                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
    … …  
    62476233
    62486234/* Line 1806 of yacc.c  */
    6249 #line 1114 "parser.yy"
     6235#line 1113 "parser.yy"
    62506236    {
    62516237                        typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
    … …  
    62576243
    62586244/* Line 1806 of yacc.c  */
    6259 #line 1119 "parser.yy"
     6245#line 1118 "parser.yy"
    62606246    {
    62616247                        typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
    … …  
    62676253
    62686254/* Line 1806 of yacc.c  */
    6269 #line 1127 "parser.yy"
     6255#line 1126 "parser.yy"
    62706256    {
    62716257                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    62776263
    62786264/* Line 1806 of yacc.c  */
    6279 #line 1132 "parser.yy"
     6265#line 1131 "parser.yy"
    62806266    {
    62816267                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    62876273
    62886274/* Line 1806 of yacc.c  */
    6289 #line 1137 "parser.yy"
     6275#line 1136 "parser.yy"
    62906276    {
    62916277                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    62976283
    62986284/* Line 1806 of yacc.c  */
    6299 #line 1142 "parser.yy"
     6285#line 1141 "parser.yy"
    63006286    {
    63016287                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    63076293
    63086294/* Line 1806 of yacc.c  */
    6309 #line 1147 "parser.yy"
     6295#line 1146 "parser.yy"
    63106296    {
    63116297                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
    … …  
    63176303
    63186304/* Line 1806 of yacc.c  */
    6319 #line 1178 "parser.yy"
     6305#line 1177 "parser.yy"
    63206306    {
    63216307                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
    … …  
    63266312
    63276313/* Line 1806 of yacc.c  */
    6328 #line 1182 "parser.yy"
     6314#line 1181 "parser.yy"
    63296315    {
    63306316                        (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
    … …  
    63356321
    63366322/* Line 1806 of yacc.c  */
    6337 #line 1189 "parser.yy"
     6323#line 1188 "parser.yy"
    63386324    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    63396325    break;
    … …  
    63426328
    63436329/* Line 1806 of yacc.c  */
    6344 #line 1193 "parser.yy"
     6330#line 1192 "parser.yy"
    63456331    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
    63466332    break;
    … …  
    63496335
    63506336/* Line 1806 of yacc.c  */
    6351 #line 1198 "parser.yy"
     6337#line 1197 "parser.yy"
    63526338    {
    63536339                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    63596345
    63606346/* Line 1806 of yacc.c  */
    6361 #line 1203 "parser.yy"
     6347#line 1202 "parser.yy"
    63626348    {
    63636349                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    63696355
    63706356/* Line 1806 of yacc.c  */
    6371 #line 1208 "parser.yy"
     6357#line 1207 "parser.yy"
    63726358    {
    63736359                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
    … …  
    63796365
    63806366/* Line 1806 of yacc.c  */
    6381 #line 1219 "parser.yy"
     6367#line 1218 "parser.yy"
    63826368    {
    63836369                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    63896375
    63906376/* Line 1806 of yacc.c  */
    6391 #line 1224 "parser.yy"
     6377#line 1223 "parser.yy"
    63926378    {
    63936379                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    63996385
    64006386/* Line 1806 of yacc.c  */
    6401 #line 1229 "parser.yy"
     6387#line 1228 "parser.yy"
    64026388    {
    64036389                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    64096395
    64106396/* Line 1806 of yacc.c  */
    6411 #line 1234 "parser.yy"
     6397#line 1233 "parser.yy"
    64126398    {
    64136399                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    64196405
    64206406/* Line 1806 of yacc.c  */
    6421 #line 1239 "parser.yy"
     6407#line 1238 "parser.yy"
    64226408    {
    64236409                        typedefTable.addToEnclosingScope( TypedefTable::TD );
    … …  
    64296415
    64306416/* Line 1806 of yacc.c  */
    6431 #line 1248 "parser.yy"
     6417#line 1247 "parser.yy"
    64326418    {
    64336419                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
    … …  
    64396425
    64406426/* Line 1806 of yacc.c  */
    6441 #line 1253 "parser.yy"
     6427#line 1252 "parser.yy"
    64426428    {
    64436429                        typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
    … …  
    64496435
    64506436/* Line 1806 of yacc.c  */
    6451 #line 1270 "parser.yy"
     6437#line 1269 "parser.yy"
    64526438    {
    64536439                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    64596445
    64606446/* Line 1806 of yacc.c  */
    6461 #line 1275 "parser.yy"
     6447#line 1274 "parser.yy"
    64626448    {
    64636449                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    64696455
    64706456/* Line 1806 of yacc.c  */
    6471 #line 1297 "parser.yy"
     6457#line 1296 "parser.yy"
    64726458    { (yyval.decl) = 0; }
    64736459    break;
    … …  
    64766462
    64776463/* Line 1806 of yacc.c  */
    6478 #line 1309 "parser.yy"
     6464#line 1308 "parser.yy"
    64796465    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    64806466    break;
    … …  
    64836469
    64846470/* Line 1806 of yacc.c  */
    6485 #line 1320 "parser.yy"
     6471#line 1319 "parser.yy"
    64866472    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
    64876473    break;
    … …  
    64906476
    64916477/* Line 1806 of yacc.c  */
    6492 #line 1322 "parser.yy"
     6478#line 1321 "parser.yy"
    64936479    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
    64946480    break;
    … …  
    64976483
    64986484/* Line 1806 of yacc.c  */
    6499 #line 1324 "parser.yy"
     6485#line 1323 "parser.yy"
    65006486    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
    65016487    break;
    … …  
    65046490
    65056491/* Line 1806 of yacc.c  */
    6506 #line 1326 "parser.yy"
     6492#line 1325 "parser.yy"
    65076493    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
    65086494    break;
    … …  
    65116497
    65126498/* Line 1806 of yacc.c  */
    6513 #line 1328 "parser.yy"
     6499#line 1327 "parser.yy"
    65146500    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
    65156501    break;
    … …  
    65186504
    65196505/* Line 1806 of yacc.c  */
    6520 #line 1330 "parser.yy"
     6506#line 1329 "parser.yy"
    65216507    {
    65226508                        typedefTable.enterScope();
    … …  
    65276513
    65286514/* Line 1806 of yacc.c  */
    6529 #line 1334 "parser.yy"
     6515#line 1333 "parser.yy"
    65306516    {
    65316517                        typedefTable.leaveScope();
    … …  
    65376523
    65386524/* Line 1806 of yacc.c  */
    6539 #line 1343 "parser.yy"
     6525#line 1342 "parser.yy"
    65406526    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    65416527    break;
    … …  
    65446530
    65456531/* Line 1806 of yacc.c  */
    6546 #line 1345 "parser.yy"
     6532#line 1344 "parser.yy"
    65476533    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    65486534    break;
    … …  
    65516537
    65526538/* Line 1806 of yacc.c  */
    6553 #line 1356 "parser.yy"
     6539#line 1355 "parser.yy"
    65546540    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    65556541    break;
    … …  
    65586544
    65596545/* Line 1806 of yacc.c  */
    6560 #line 1361 "parser.yy"
     6546#line 1360 "parser.yy"
    65616547    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
    65626548    break;
    … …  
    65656551
    65666552/* Line 1806 of yacc.c  */
    6567 #line 1363 "parser.yy"
     6553#line 1362 "parser.yy"
    65686554    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
    65696555    break;
    … …  
    65726558
    65736559/* Line 1806 of yacc.c  */
    6574 #line 1365 "parser.yy"
     6560#line 1364 "parser.yy"
    65756561    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
    65766562    break;
    … …  
    65796565
    65806566/* Line 1806 of yacc.c  */
    6581 #line 1367 "parser.yy"
     6567#line 1366 "parser.yy"
    65826568    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
    65836569    break;
    … …  
    65866572
    65876573/* Line 1806 of yacc.c  */
    6588 #line 1370 "parser.yy"
     6574#line 1369 "parser.yy"
    65896575    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; }
    65906576    break;
    … …  
    65936579
    65946580/* Line 1806 of yacc.c  */
    6595 #line 1372 "parser.yy"
     6581#line 1371 "parser.yy"
    65966582    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
    65976583    break;
    … …  
    66006586
    66016587/* Line 1806 of yacc.c  */
    6602 #line 1375 "parser.yy"
     6588#line 1374 "parser.yy"
    66036589    { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; }
    66046590    break;
    … …  
    66076593
    66086594/* Line 1806 of yacc.c  */
    6609 #line 1377 "parser.yy"
     6595#line 1376 "parser.yy"
    66106596    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
    66116597    break;
    … …  
    66146600
    66156601/* Line 1806 of yacc.c  */
    6616 #line 1382 "parser.yy"
     6602#line 1381 "parser.yy"
    66176603    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
    66186604    break;
    … …  
    66216607
    66226608/* Line 1806 of yacc.c  */
    6623 #line 1384 "parser.yy"
     6609#line 1383 "parser.yy"
    66246610    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
    66256611    break;
    … …  
    66286614
    66296615/* Line 1806 of yacc.c  */
    6630 #line 1386 "parser.yy"
     6616#line 1385 "parser.yy"
    66316617    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
    66326618    break;
    … …  
    66356621
    66366622/* Line 1806 of yacc.c  */
    6637 #line 1388 "parser.yy"
     6623#line 1387 "parser.yy"
    66386624    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
    66396625    break;
    … …  
    66426628
    66436629/* Line 1806 of yacc.c  */
    6644 #line 1390 "parser.yy"
     6630#line 1389 "parser.yy"
    66456631    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
    66466632    break;
    … …  
    66496635
    66506636/* Line 1806 of yacc.c  */
    6651 #line 1392 "parser.yy"
     6637#line 1391 "parser.yy"
    66526638    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
    66536639    break;
    … …  
    66566642
    66576643/* Line 1806 of yacc.c  */
    6658 #line 1394 "parser.yy"
     6644#line 1393 "parser.yy"
    66596645    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
    66606646    break;
    … …  
    66636649
    66646650/* Line 1806 of yacc.c  */
    6665 #line 1396 "parser.yy"
     6651#line 1395 "parser.yy"
    66666652    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
    66676653    break;
    … …  
    66706656
    66716657/* Line 1806 of yacc.c  */
    6672 #line 1398 "parser.yy"
     6658#line 1397 "parser.yy"
    66736659    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
    66746660    break;
    … …  
    66776663
    66786664/* Line 1806 of yacc.c  */
    6679 #line 1400 "parser.yy"
     6665#line 1399 "parser.yy"
    66806666    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
    66816667    break;
    … …  
    66846670
    66856671/* Line 1806 of yacc.c  */
    6686 #line 1402 "parser.yy"
     6672#line 1401 "parser.yy"
    66876673    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
    66886674    break;
    … …  
    66916677
    66926678/* Line 1806 of yacc.c  */
    6693 #line 1404 "parser.yy"
     6679#line 1403 "parser.yy"
    66946680    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
    66956681    break;
    … …  
    66986684
    66996685/* Line 1806 of yacc.c  */
    6700 #line 1406 "parser.yy"
     6686#line 1405 "parser.yy"
    67016687    { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
    67026688    break;
    … …  
    67056691
    67066692/* Line 1806 of yacc.c  */
    6707 #line 1413 "parser.yy"
     6693#line 1412 "parser.yy"
    67086694    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    67096695    break;
    … …  
    67126698
    67136699/* Line 1806 of yacc.c  */
    6714 #line 1415 "parser.yy"
     6700#line 1414 "parser.yy"
    67156701    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    67166702    break;
    … …  
    67196705
    67206706/* Line 1806 of yacc.c  */
    6721 #line 1417 "parser.yy"
     6707#line 1416 "parser.yy"
    67226708    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    67236709    break;
    … …  
    67266712
    67276713/* Line 1806 of yacc.c  */
    6728 #line 1419 "parser.yy"
     6714#line 1418 "parser.yy"
    67296715    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
    67306716    break;
    … …  
    67336719
    67346720/* Line 1806 of yacc.c  */
    6735 #line 1425 "parser.yy"
     6721#line 1424 "parser.yy"
    67366722    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    67376723    break;
    … …  
    67406726
    67416727/* Line 1806 of yacc.c  */
    6742 #line 1432 "parser.yy"
     6728#line 1431 "parser.yy"
    67436729    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    67446730    break;
    … …  
    67476733
    67486734/* Line 1806 of yacc.c  */
    6749 #line 1434 "parser.yy"
     6735#line 1433 "parser.yy"
    67506736    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    67516737    break;
    … …  
    67546740
    67556741/* Line 1806 of yacc.c  */
    6756 #line 1436 "parser.yy"
     6742#line 1435 "parser.yy"
    67576743    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
    67586744    break;
    … …  
    67616747
    67626748/* Line 1806 of yacc.c  */
    6763 #line 1441 "parser.yy"
     6749#line 1440 "parser.yy"
    67646750    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
    67656751    break;
    … …  
    67686754
    67696755/* Line 1806 of yacc.c  */
    6770 #line 1443 "parser.yy"
     6756#line 1442 "parser.yy"
    67716757    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
    67726758    break;
    … …  
    67756761
    67766762/* Line 1806 of yacc.c  */
    6777 #line 1445 "parser.yy"
     6763#line 1444 "parser.yy"
    67786764    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
    67796765    break;
    … …  
    67826768
    67836769/* Line 1806 of yacc.c  */
    6784 #line 1447 "parser.yy"
     6770#line 1446 "parser.yy"
    67856771    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    67866772    break;
    … …  
    67896775
    67906776/* Line 1806 of yacc.c  */
    6791 #line 1453 "parser.yy"
     6777#line 1452 "parser.yy"
    67926778    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    67936779    break;
    … …  
    67966782
    67976783/* Line 1806 of yacc.c  */
    6798 #line 1455 "parser.yy"
     6784#line 1454 "parser.yy"
    67996785    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68006786    break;
    … …  
    68036789
    68046790/* Line 1806 of yacc.c  */
    6805 #line 1457 "parser.yy"
     6791#line 1456 "parser.yy"
    68066792    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68076793    break;
    … …  
    68106796
    68116797/* Line 1806 of yacc.c  */
    6812 #line 1463 "parser.yy"
     6798#line 1462 "parser.yy"
    68136799    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68146800    break;
    … …  
    68176803
    68186804/* Line 1806 of yacc.c  */
    6819 #line 1465 "parser.yy"
     6805#line 1464 "parser.yy"
    68206806    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68216807    break;
    … …  
    68246810
    68256811/* Line 1806 of yacc.c  */
    6826 #line 1471 "parser.yy"
     6812#line 1470 "parser.yy"
    68276813    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68286814    break;
    … …  
    68316817
    68326818/* Line 1806 of yacc.c  */
    6833 #line 1473 "parser.yy"
     6819#line 1472 "parser.yy"
    68346820    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68356821    break;
    … …  
    68386824
    68396825/* Line 1806 of yacc.c  */
    6840 #line 1475 "parser.yy"
     6826#line 1474 "parser.yy"
    68416827    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    68426828    break;
    … …  
    68456831
    68466832/* Line 1806 of yacc.c  */
    6847 #line 1480 "parser.yy"
     6833#line 1479 "parser.yy"
    68486834    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
    68496835    break;
    … …  
    68526838
    68536839/* Line 1806 of yacc.c  */
    6854 #line 1482 "parser.yy"
     6840#line 1481 "parser.yy"
    68556841    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    68566842    break;
    … …  
    68596845
    68606846/* Line 1806 of yacc.c  */
    6861 #line 1484 "parser.yy"
     6847#line 1483 "parser.yy"
    68626848    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    68636849    break;
    … …  
    68666852
    68676853/* Line 1806 of yacc.c  */
    6868 #line 1494 "parser.yy"
     6854#line 1493 "parser.yy"
    68696855    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), nullptr, nullptr, (yyvsp[(3) - (4)].decl), true ); }
    68706856    break;
    … …  
    68736859
    68746860/* Line 1806 of yacc.c  */
    6875 #line 1496 "parser.yy"
     6861#line 1495 "parser.yy"
    68766862    {
    68776863                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
    … …  
    68836869
    68846870/* Line 1806 of yacc.c  */
    6885 #line 1501 "parser.yy"
     6871#line 1500 "parser.yy"
    68866872    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    68876873    break;
    … …  
    68906876
    68916877/* Line 1806 of yacc.c  */
    6892 #line 1503 "parser.yy"
     6878#line 1502 "parser.yy"
    68936879    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); }
    68946880    break;
    … …  
    68976883
    68986884/* Line 1806 of yacc.c  */
    6899 #line 1505 "parser.yy"
     6885#line 1504 "parser.yy"
    69006886    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
    69016887    break;
    … …  
    69046890
    69056891/* Line 1806 of yacc.c  */
    6906 #line 1507 "parser.yy"
     6892#line 1506 "parser.yy"
    69076893    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    69086894    break;
    … …  
    69116897
    69126898/* Line 1806 of yacc.c  */
    6913 #line 1512 "parser.yy"
     6899#line 1511 "parser.yy"
    69146900    { (yyval.aggKey) = DeclarationNode::Struct; }
    69156901    break;
    … …  
    69186904
    69196905/* Line 1806 of yacc.c  */
    6920 #line 1514 "parser.yy"
     6906#line 1513 "parser.yy"
    69216907    { (yyval.aggKey) = DeclarationNode::Union; }
    69226908    break;
    … …  
    69256911
    69266912/* Line 1806 of yacc.c  */
    6927 #line 1519 "parser.yy"
     6913#line 1518 "parser.yy"
    69286914    { (yyval.decl) = 0; }
    69296915    break;
    … …  
    69326918
    69336919/* Line 1806 of yacc.c  */
    6934 #line 1521 "parser.yy"
     6920#line 1520 "parser.yy"
    69356921    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    69366922    break;
    … …  
    69396925
    69406926/* Line 1806 of yacc.c  */
    6941 #line 1527 "parser.yy"
     6927#line 1526 "parser.yy"
    69426928    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
    69436929    break;
    … …  
    69466932
    69476933/* Line 1806 of yacc.c  */
    6948 #line 1530 "parser.yy"
     6934#line 1529 "parser.yy"
    69496935    {   // mark all fields in list
    69506936                        for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
    … …  
    69576943
    69586944/* Line 1806 of yacc.c  */
    6959 #line 1540 "parser.yy"
     6945#line 1539 "parser.yy"
    69606946    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
    69616947    break;
    … …  
    69646950
    69656951/* Line 1806 of yacc.c  */
    6966 #line 1542 "parser.yy"
     6952#line 1541 "parser.yy"
    69676953    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
    69686954    break;
    … …  
    69716957
    69726958/* Line 1806 of yacc.c  */
    6973 #line 1544 "parser.yy"
     6959#line 1543 "parser.yy"
    69746960    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
    69756961    break;
    … …  
    69786964
    69796965/* Line 1806 of yacc.c  */
    6980 #line 1549 "parser.yy"
     6966#line 1548 "parser.yy"
    69816967    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    69826968    break;
    … …  
    69856971
    69866972/* Line 1806 of yacc.c  */
    6987 #line 1551 "parser.yy"
     6973#line 1550 "parser.yy"
    69886974    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
    69896975    break;
    … …  
    69926978
    69936979/* Line 1806 of yacc.c  */
    6994 #line 1556 "parser.yy"
     6980#line 1555 "parser.yy"
    69956981    { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
    69966982    break;
    … …  
    69996985
    70006986/* Line 1806 of yacc.c  */
    7001 #line 1558 "parser.yy"
     6987#line 1557 "parser.yy"
    70026988    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
    70036989    break;
    … …  
    70066992
    70076993/* Line 1806 of yacc.c  */
    7008 #line 1561 "parser.yy"
     6994#line 1560 "parser.yy"
    70096995    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    70106996    break;
    … …  
    70136999
    70147000/* Line 1806 of yacc.c  */
    7015 #line 1564 "parser.yy"
     7001#line 1563 "parser.yy"
    70167002    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
    70177003    break;
    … …  
    70207006
    70217007/* Line 1806 of yacc.c  */
    7022 #line 1570 "parser.yy"
     7008#line 1569 "parser.yy"
    70237009    { (yyval.en) = 0; }
    70247010    break;
    … …  
    70277013
    70287014/* Line 1806 of yacc.c  */
    7029 #line 1572 "parser.yy"
     7015#line 1571 "parser.yy"
    70307016    { (yyval.en) = (yyvsp[(1) - (1)].en); }
    70317017    break;
    … …  
    70347020
    70357021/* Line 1806 of yacc.c  */
    7036 #line 1577 "parser.yy"
     7022#line 1576 "parser.yy"
    70377023    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    70387024    break;
    … …  
    70417027
    70427028/* Line 1806 of yacc.c  */
    7043 #line 1586 "parser.yy"
     7029#line 1585 "parser.yy"
    70447030    { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(3) - (5)].decl) ); }
    70457031    break;
    … …  
    70487034
    70497035/* Line 1806 of yacc.c  */
    7050 #line 1588 "parser.yy"
     7036#line 1587 "parser.yy"
    70517037    {
    70527038                        typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
    … …  
    70587044
    70597045/* Line 1806 of yacc.c  */
    7060 #line 1593 "parser.yy"
     7046#line 1592 "parser.yy"
    70617047    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
    70627048    break;
    … …  
    70657051
    70667052/* Line 1806 of yacc.c  */
    7067 #line 1595 "parser.yy"
     7053#line 1594 "parser.yy"
    70687054    { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
    70697055    break;
    … …  
    70727058
    70737059/* Line 1806 of yacc.c  */
    7074 #line 1600 "parser.yy"
     7060#line 1599 "parser.yy"
    70757061    { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
    70767062    break;
    … …  
    70797065
    70807066/* Line 1806 of yacc.c  */
    7081 #line 1602 "parser.yy"
     7067#line 1601 "parser.yy"
    70827068    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
    70837069    break;
    … …  
    70867072
    70877073/* Line 1806 of yacc.c  */
    7088 #line 1607 "parser.yy"
     7074#line 1606 "parser.yy"
    70897075    { (yyval.en) = 0; }
    70907076    break;
    … …  
    70937079
    70947080/* Line 1806 of yacc.c  */
    7095 #line 1609 "parser.yy"
     7081#line 1608 "parser.yy"
    70967082    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    70977083    break;
    … …  
    71007086
    71017087/* Line 1806 of yacc.c  */
    7102 #line 1616 "parser.yy"
     7088#line 1615 "parser.yy"
    71037089    { (yyval.decl) = 0; }
    71047090    break;
    … …  
    71077093
    71087094/* Line 1806 of yacc.c  */
    7109 #line 1624 "parser.yy"
     7095#line 1623 "parser.yy"
    71107096    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    71117097    break;
    … …  
    71147100
    71157101/* Line 1806 of yacc.c  */
    7116 #line 1626 "parser.yy"
     7102#line 1625 "parser.yy"
    71177103    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    71187104    break;
    … …  
    71217107
    71227108/* Line 1806 of yacc.c  */
    7123 #line 1628 "parser.yy"
     7109#line 1627 "parser.yy"
    71247110    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    71257111    break;
    … …  
    71287114
    71297115/* Line 1806 of yacc.c  */
    7130 #line 1636 "parser.yy"
     7116#line 1635 "parser.yy"
    71317117    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    71327118    break;
    … …  
    71357121
    71367122/* Line 1806 of yacc.c  */
    7137 #line 1638 "parser.yy"
     7123#line 1637 "parser.yy"
    71387124    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    71397125    break;
    … …  
    71427128
    71437129/* Line 1806 of yacc.c  */
    7144 #line 1640 "parser.yy"
     7130#line 1639 "parser.yy"
    71457131    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
    71467132    break;
    … …  
    71497135
    71507136/* Line 1806 of yacc.c  */
    7151 #line 1646 "parser.yy"
     7137#line 1645 "parser.yy"
    71527138    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    71537139    break;
    … …  
    71567142
    71577143/* Line 1806 of yacc.c  */
    7158 #line 1651 "parser.yy"
     7144#line 1650 "parser.yy"
    71597145    { (yyval.decl) = 0; }
    71607146    break;
    … …  
    71637149
    71647150/* Line 1806 of yacc.c  */
    7165 #line 1658 "parser.yy"
     7151#line 1657 "parser.yy"
    71667152    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
    71677153    break;
    … …  
    71707156
    71717157/* Line 1806 of yacc.c  */
    7172 #line 1665 "parser.yy"
     7158#line 1664 "parser.yy"
    71737159    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    71747160    break;
    … …  
    71777163
    71787164/* Line 1806 of yacc.c  */
    7179 #line 1667 "parser.yy"
     7165#line 1666 "parser.yy"
    71807166    { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
    71817167    break;
    … …  
    71847170
    71857171/* Line 1806 of yacc.c  */
    7186 #line 1676 "parser.yy"
     7172#line 1675 "parser.yy"
    71877173    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    71887174    break;
    … …  
    71917177
    71927178/* Line 1806 of yacc.c  */
    7193 #line 1679 "parser.yy"
     7179#line 1678 "parser.yy"
    71947180    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
    71957181    break;
    … …  
    71987184
    71997185/* Line 1806 of yacc.c  */
    7200 #line 1681 "parser.yy"
     7186#line 1680 "parser.yy"
    72017187    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
    72027188    break;
    … …  
    72057191
    72067192/* Line 1806 of yacc.c  */
    7207 #line 1691 "parser.yy"
     7193#line 1690 "parser.yy"
    72087194    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    72097195    break;
    … …  
    72127198
    72137199/* Line 1806 of yacc.c  */
    7214 #line 1697 "parser.yy"
     7200#line 1696 "parser.yy"
    72157201    {
    72167202                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    72227208
    72237209/* Line 1806 of yacc.c  */
    7224 #line 1702 "parser.yy"
     7210#line 1701 "parser.yy"
    72257211    {
    72267212                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    72327218
    72337219/* Line 1806 of yacc.c  */
    7234 #line 1711 "parser.yy"
     7220#line 1710 "parser.yy"
    72357221    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    72367222    break;
    … …  
    72397225
    72407226/* Line 1806 of yacc.c  */
    7241 #line 1720 "parser.yy"
     7227#line 1719 "parser.yy"
    72427228    { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
    72437229    break;
    … …  
    72467232
    72477233/* Line 1806 of yacc.c  */
    7248 #line 1722 "parser.yy"
     7234#line 1721 "parser.yy"
    72497235    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
    72507236    break;
    … …  
    72537239
    72547240/* Line 1806 of yacc.c  */
    7255 #line 1747 "parser.yy"
     7241#line 1746 "parser.yy"
    72567242    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    72577243    break;
    … …  
    72607246
    72617247/* Line 1806 of yacc.c  */
    7262 #line 1755 "parser.yy"
     7248#line 1754 "parser.yy"
    72637249    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
    72647250    break;
    … …  
    72677253
    72687254/* Line 1806 of yacc.c  */
    7269 #line 1760 "parser.yy"
     7255#line 1759 "parser.yy"
    72707256    { (yyval.in) = 0; }
    72717257    break;
    … …  
    72747260
    72757261/* Line 1806 of yacc.c  */
    7276 #line 1762 "parser.yy"
     7262#line 1761 "parser.yy"
    72777263    { (yyval.in) = (yyvsp[(2) - (2)].in); }
    72787264    break;
    … …  
    72817267
    72827268/* Line 1806 of yacc.c  */
    7283 #line 1764 "parser.yy"
     7269#line 1763 "parser.yy"
    72847270    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
    72857271    break;
    … …  
    72887274
    72897275/* Line 1806 of yacc.c  */
     7276#line 1767 "parser.yy"
     7277    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
     7278    break;
     7279
     7280  case 462:
     7281
     7282/* Line 1806 of yacc.c  */
    72907283#line 1768 "parser.yy"
    7291     { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
    7292     break;
    7293 
    7294   case 462:
    7295 
    7296 /* Line 1806 of yacc.c  */
    7297 #line 1769 "parser.yy"
    72987284    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
    72997285    break;
    … …  
    73027288
    73037289/* Line 1806 of yacc.c  */
    7304 #line 1774 "parser.yy"
     7290#line 1773 "parser.yy"
    73057291    { (yyval.in) = 0; }
    73067292    break;
    … …  
    73097295
    73107296/* Line 1806 of yacc.c  */
     7297#line 1775 "parser.yy"
     7298    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
     7299    break;
     7300
     7301  case 466:
     7302
     7303/* Line 1806 of yacc.c  */
    73117304#line 1776 "parser.yy"
    7312     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
    7313     break;
    7314 
    7315   case 466:
    7316 
    7317 /* Line 1806 of yacc.c  */
    7318 #line 1777 "parser.yy"
    73197305    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
    73207306    break;
    … …  
    73237309
    73247310/* Line 1806 of yacc.c  */
    7325 #line 1779 "parser.yy"
     7311#line 1778 "parser.yy"
    73267312    { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
    73277313    break;
    … …  
    73307316
    73317317/* Line 1806 of yacc.c  */
    7332 #line 1795 "parser.yy"
     7318#line 1794 "parser.yy"
    73337319    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
    73347320    break;
    … …  
    73377323
    73387324/* Line 1806 of yacc.c  */
    7339 #line 1801 "parser.yy"
     7325#line 1800 "parser.yy"
    73407326    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
    73417327    break;
    … …  
    73447330
    73457331/* Line 1806 of yacc.c  */
    7346 #line 1807 "parser.yy"
     7332#line 1806 "parser.yy"
    73477333    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
    73487334    break;
    … …  
    73517337
    73527338/* Line 1806 of yacc.c  */
    7353 #line 1810 "parser.yy"
     7339#line 1809 "parser.yy"
    73547340    { (yyval.en) = (yyvsp[(3) - (5)].en); }
    73557341    break;
    … …  
    73587344
    73597345/* Line 1806 of yacc.c  */
    7360 #line 1812 "parser.yy"
     7346#line 1811 "parser.yy"
    73617347    { (yyval.en) = (yyvsp[(3) - (5)].en); }
    73627348    break;
    … …  
    73657351
    73667352/* Line 1806 of yacc.c  */
    7367 #line 1814 "parser.yy"
     7353#line 1813 "parser.yy"
    73687354    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
    73697355    break;
    … …  
    73727358
    73737359/* Line 1806 of yacc.c  */
    7374 #line 1816 "parser.yy"
     7360#line 1815 "parser.yy"
    73757361    { (yyval.en) = (yyvsp[(4) - (6)].en); }
    73767362    break;
    … …  
    73797365
    73807366/* Line 1806 of yacc.c  */
    7381 #line 1840 "parser.yy"
     7367#line 1839 "parser.yy"
    73827368    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    73837369    break;
    … …  
    73867372
    73877373/* Line 1806 of yacc.c  */
    7388 #line 1842 "parser.yy"
     7374#line 1841 "parser.yy"
    73897375    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    73907376    break;
    … …  
    73937379
    73947380/* Line 1806 of yacc.c  */
    7395 #line 1844 "parser.yy"
     7381#line 1843 "parser.yy"
    73967382    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
    73977383    break;
    … …  
    74007386
    74017387/* Line 1806 of yacc.c  */
    7402 #line 1850 "parser.yy"
     7388#line 1849 "parser.yy"
    74037389    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    74047390    break;
    … …  
    74077393
    74087394/* Line 1806 of yacc.c  */
    7409 #line 1852 "parser.yy"
     7395#line 1851 "parser.yy"
    74107396    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    74117397    break;
    … …  
    74147400
    74157401/* Line 1806 of yacc.c  */
    7416 #line 1857 "parser.yy"
     7402#line 1856 "parser.yy"
    74177403    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
    74187404    break;
    … …  
    74217407
    74227408/* Line 1806 of yacc.c  */
    7423 #line 1863 "parser.yy"
     7409#line 1862 "parser.yy"
    74247410    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
    74257411    break;
    … …  
    74287414
    74297415/* Line 1806 of yacc.c  */
    7430 #line 1868 "parser.yy"
     7416#line 1867 "parser.yy"
    74317417    { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
    74327418    break;
    … …  
    74357421
    74367422/* Line 1806 of yacc.c  */
    7437 #line 1870 "parser.yy"
     7423#line 1869 "parser.yy"
    74387424    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
    74397425    break;
    … …  
    74427428
    74437429/* Line 1806 of yacc.c  */
    7444 #line 1876 "parser.yy"
     7430#line 1875 "parser.yy"
    74457431    { (yyval.tclass) = DeclarationNode::Otype; }
    74467432    break;
    … …  
    74497435
    74507436/* Line 1806 of yacc.c  */
    7451 #line 1878 "parser.yy"
     7437#line 1877 "parser.yy"
    74527438    { (yyval.tclass) = DeclarationNode::Ftype; }
    74537439    break;
    … …  
    74567442
    74577443/* Line 1806 of yacc.c  */
    7458 #line 1880 "parser.yy"
     7444#line 1879 "parser.yy"
    74597445    { (yyval.tclass) = DeclarationNode::Dtype; }
    74607446    break;
    … …  
    74637449
    74647450/* Line 1806 of yacc.c  */
    7465 #line 1885 "parser.yy"
     7451#line 1884 "parser.yy"
    74667452    { (yyval.decl) = 0; }
    74677453    break;
    … …  
    74707456
    74717457/* Line 1806 of yacc.c  */
    7472 #line 1887 "parser.yy"
     7458#line 1886 "parser.yy"
    74737459    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
    74747460    break;
    … …  
    74777463
    74787464/* Line 1806 of yacc.c  */
    7479 #line 1892 "parser.yy"
     7465#line 1891 "parser.yy"
    74807466    {
    74817467                        typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
    … …  
    74877473
    74887474/* Line 1806 of yacc.c  */
    7489 #line 1897 "parser.yy"
     7475#line 1896 "parser.yy"
    74907476    { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
    74917477    break;
    … …  
    74947480
    74957481/* Line 1806 of yacc.c  */
    7496 #line 1899 "parser.yy"
     7482#line 1898 "parser.yy"
    74977483    { (yyval.decl) = 0; }
    74987484    break;
    … …  
    75017487
    75027488/* Line 1806 of yacc.c  */
    7503 #line 1904 "parser.yy"
     7489#line 1903 "parser.yy"
    75047490    { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
    75057491    break;
    … …  
    75087494
    75097495/* Line 1806 of yacc.c  */
    7510 #line 1907 "parser.yy"
     7496#line 1906 "parser.yy"
    75117497    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
    75127498    break;
    … …  
    75157501
    75167502/* Line 1806 of yacc.c  */
    7517 #line 1909 "parser.yy"
     7503#line 1908 "parser.yy"
    75187504    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
    75197505    break;
    … …  
    75227508
    75237509/* Line 1806 of yacc.c  */
    7524 #line 1914 "parser.yy"
     7510#line 1913 "parser.yy"
    75257511    { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
    75267512    break;
    … …  
    75297515
    75307516/* Line 1806 of yacc.c  */
    7531 #line 1916 "parser.yy"
     7517#line 1915 "parser.yy"
    75327518    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
    75337519    break;
    … …  
    75367522
    75377523/* Line 1806 of yacc.c  */
    7538 #line 1918 "parser.yy"
     7524#line 1917 "parser.yy"
    75397525    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
    75407526    break;
    … …  
    75437529
    75447530/* Line 1806 of yacc.c  */
    7545 #line 1923 "parser.yy"
     7531#line 1922 "parser.yy"
    75467532    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
    75477533    break;
    … …  
    75507536
    75517537/* Line 1806 of yacc.c  */
    7552 #line 1925 "parser.yy"
     7538#line 1924 "parser.yy"
    75537539    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
    75547540    break;
    … …  
    75577543
    75587544/* Line 1806 of yacc.c  */
    7559 #line 1930 "parser.yy"
     7545#line 1929 "parser.yy"
    75607546    {
    75617547                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
    … …  
    75677553
    75687554/* Line 1806 of yacc.c  */
    7569 #line 1935 "parser.yy"
     7555#line 1934 "parser.yy"
    75707556    {
    75717557                        typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
    … …  
    75777563
    75787564/* Line 1806 of yacc.c  */
    7579 #line 1943 "parser.yy"
     7565#line 1942 "parser.yy"
    75807566    {
    75817567                        typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
    … …  
    75877573
    75887574/* Line 1806 of yacc.c  */
    7589 #line 1948 "parser.yy"
     7575#line 1947 "parser.yy"
    75907576    {
    75917577                        typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
    … …  
    75977583
    75987584/* Line 1806 of yacc.c  */
    7599 #line 1953 "parser.yy"
     7585#line 1952 "parser.yy"
    76007586    {
    76017587                        typedefTable.leaveTrait();
    … …  
    76087594
    76097595/* Line 1806 of yacc.c  */
    7610 #line 1963 "parser.yy"
     7596#line 1962 "parser.yy"
    76117597    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
    76127598    break;
    … …  
    76157601
    76167602/* Line 1806 of yacc.c  */
    7617 #line 1973 "parser.yy"
     7603#line 1972 "parser.yy"
    76187604    {
    76197605                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    76257611
    76267612/* Line 1806 of yacc.c  */
    7627 #line 1978 "parser.yy"
     7613#line 1977 "parser.yy"
    76287614    {
    76297615                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    76357621
    76367622/* Line 1806 of yacc.c  */
    7637 #line 1983 "parser.yy"
     7623#line 1982 "parser.yy"
    76387624    {
    76397625                        typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
    … …  
    76457631
    76467632/* Line 1806 of yacc.c  */
    7647 #line 1991 "parser.yy"
     7633#line 1990 "parser.yy"
    76487634    {
    76497635                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    76557641
    76567642/* Line 1806 of yacc.c  */
    7657 #line 1996 "parser.yy"
     7643#line 1995 "parser.yy"
    76587644    {
    76597645                        typedefTable.addToEnclosingScope2( TypedefTable::ID );
    … …  
    76657651
    76667652/* Line 1806 of yacc.c  */
    7667 #line 2006 "parser.yy"
     7653#line 2005 "parser.yy"
    76687654    {}
    76697655    break;
    … …  
    76727658
    76737659/* Line 1806 of yacc.c  */
    7674 #line 2008 "parser.yy"
     7660#line 2007 "parser.yy"
    76757661    { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl);    }
    76767662    break;
    … …  
    76797665
    76807666/* Line 1806 of yacc.c  */
    7681 #line 2014 "parser.yy"
     7667#line 2013 "parser.yy"
    76827668    { (yyval.decl) = (yyvsp[(1) - (3)].decl) != nullptr ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
    76837669    break;
    … …  
    76867672
    76877673/* Line 1806 of yacc.c  */
    7688 #line 2019 "parser.yy"
     7674#line 2018 "parser.yy"
    76897675    { (yyval.decl) = 0; }
    76907676    break;
    … …  
    76937679
    76947680/* Line 1806 of yacc.c  */
    7695 #line 2027 "parser.yy"
     7681#line 2026 "parser.yy"
    76967682    {}
    76977683    break;
    … …  
    77007686
    77017687/* Line 1806 of yacc.c  */
    7702 #line 2029 "parser.yy"
     7688#line 2028 "parser.yy"
    77037689    {
    77047690                        linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
    … …  
    77107696
    77117697/* Line 1806 of yacc.c  */
    7712 #line 2034 "parser.yy"
     7698#line 2033 "parser.yy"
    77137699    {
    77147700                        linkage = linkageStack.top();
    … …  
    77217707
    77227708/* Line 1806 of yacc.c  */
    7723 #line 2040 "parser.yy"
     7709#line 2039 "parser.yy"
    77247710    {   // mark all fields in list
    77257711                        for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
    … …  
    77327718
    77337719/* Line 1806 of yacc.c  */
    7734 #line 2055 "parser.yy"
     7720#line 2054 "parser.yy"
    77357721    {
    77367722                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    77437729
    77447730/* Line 1806 of yacc.c  */
    7745 #line 2061 "parser.yy"
     7731#line 2060 "parser.yy"
    77467732    {
    77477733                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    77547740
    77557741/* Line 1806 of yacc.c  */
    7756 #line 2070 "parser.yy"
     7742#line 2069 "parser.yy"
    77577743    {
    77587744                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    77657751
    77667752/* Line 1806 of yacc.c  */
    7767 #line 2076 "parser.yy"
     7753#line 2075 "parser.yy"
    77687754    {
    77697755                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    77767762
    77777763/* Line 1806 of yacc.c  */
    7778 #line 2082 "parser.yy"
     7764#line 2081 "parser.yy"
    77797765    {
    77807766                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    77877773
    77887774/* Line 1806 of yacc.c  */
    7789 #line 2088 "parser.yy"
     7775#line 2087 "parser.yy"
    77907776    {
    77917777                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    77987784
    77997785/* Line 1806 of yacc.c  */
    7800 #line 2094 "parser.yy"
     7786#line 2093 "parser.yy"
    78017787    {
    78027788                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    78097795
    78107796/* Line 1806 of yacc.c  */
    7811 #line 2102 "parser.yy"
     7797#line 2101 "parser.yy"
    78127798    {
    78137799                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    78207806
    78217807/* Line 1806 of yacc.c  */
    7822 #line 2108 "parser.yy"
     7808#line 2107 "parser.yy"
    78237809    {
    78247810                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    78317817
    78327818/* Line 1806 of yacc.c  */
    7833 #line 2116 "parser.yy"
     7819#line 2115 "parser.yy"
    78347820    {
    78357821                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    78427828
    78437829/* Line 1806 of yacc.c  */
    7844 #line 2122 "parser.yy"
     7830#line 2121 "parser.yy"
    78457831    {
    78467832                        typedefTable.addToEnclosingScope( TypedefTable::ID );
    … …  
    78537839
    78547840/* Line 1806 of yacc.c  */
    7855 #line 2137 "parser.yy"
     7841#line 2136 "parser.yy"
    78567842    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
    78577843    break;
    … …  
    78607846
    78617847/* Line 1806 of yacc.c  */
    7862 #line 2142 "parser.yy"
     7848#line 2141 "parser.yy"
    78637849    { delete (yyvsp[(3) - (5)].str); }
    78647850    break;
    … …  
    78677853
    78687854/* Line 1806 of yacc.c  */
    7869 #line 2147 "parser.yy"
     7855#line 2146 "parser.yy"
    78707856    { (yyval.decl) = 0; }
    78717857    break;
    … …  
    78747860
    78757861/* Line 1806 of yacc.c  */
    7876 #line 2154 "parser.yy"
     7862#line 2153 "parser.yy"
    78777863    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    78787864    break;
    … …  
    78817867
    78827868/* Line 1806 of yacc.c  */
    7883 #line 2160 "parser.yy"
     7869#line 2159 "parser.yy"
    78847870    { (yyval.decl) = 0; }
    78857871    break;
    … …  
    78887874
    78897875/* Line 1806 of yacc.c  */
    7890 #line 2171 "parser.yy"
     7876#line 2170 "parser.yy"
    78917877    { delete (yyvsp[(3) - (4)].en); }
    78927878    break;
    … …  
    78957881
    78967882/* Line 1806 of yacc.c  */
     7883#line 2174 "parser.yy"
     7884    { delete (yyvsp[(1) - (1)].tok); }
     7885    break;
     7886
     7887  case 562:
     7888
     7889/* Line 1806 of yacc.c  */
    78977890#line 2175 "parser.yy"
    7898     { delete (yyvsp[(1) - (1)].tok); }
    7899     break;
    7900 
    7901   case 562:
     7891    { delete (yyvsp[(1) - (1)].decl); }
     7892    break;
     7893
     7894  case 563:
    79027895
    79037896/* Line 1806 of yacc.c  */
    … …  
    79067899    break;
    79077900
    7908   case 563:
     7901  case 564:
    79097902
    79107903/* Line 1806 of yacc.c  */
    … …  
    79137906    break;
    79147907
    7915   case 564:
    7916 
    7917 /* Line 1806 of yacc.c  */
    7918 #line 2178 "parser.yy"
    7919     { delete (yyvsp[(1) - (1)].decl); }
    7920     break;
    7921 
    79227908  case 565:
    79237909
    79247910/* Line 1806 of yacc.c  */
    7925 #line 2213 "parser.yy"
     7911#line 2212 "parser.yy"
    79267912    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    79277913    break;
    … …  
    79307916
    79317917/* Line 1806 of yacc.c  */
    7932 #line 2216 "parser.yy"
     7918#line 2215 "parser.yy"
    79337919    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    79347920    break;
    … …  
    79377923
    79387924/* Line 1806 of yacc.c  */
    7939 #line 2218 "parser.yy"
     7925#line 2217 "parser.yy"
    79407926    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    79417927    break;
    … …  
    79447930
    79457931/* Line 1806 of yacc.c  */
    7946 #line 2223 "parser.yy"
     7932#line 2222 "parser.yy"
    79477933    {
    79487934                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    79547940
    79557941/* Line 1806 of yacc.c  */
    7956 #line 2228 "parser.yy"
     7942#line 2227 "parser.yy"
    79577943    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    79587944    break;
    … …  
    79617947
    79627948/* Line 1806 of yacc.c  */
    7963 #line 2233 "parser.yy"
     7949#line 2232 "parser.yy"
    79647950    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    79657951    break;
    … …  
    79687954
    79697955/* Line 1806 of yacc.c  */
    7970 #line 2235 "parser.yy"
     7956#line 2234 "parser.yy"
    79717957    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    79727958    break;
    … …  
    79757961
    79767962/* Line 1806 of yacc.c  */
    7977 #line 2237 "parser.yy"
     7963#line 2236 "parser.yy"
    79787964    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    79797965    break;
    … …  
    79827968
    79837969/* Line 1806 of yacc.c  */
    7984 #line 2242 "parser.yy"
     7970#line 2241 "parser.yy"
    79857971    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    79867972    break;
    … …  
    79897975
    79907976/* Line 1806 of yacc.c  */
    7991 #line 2244 "parser.yy"
     7977#line 2243 "parser.yy"
    79927978    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    79937979    break;
    … …  
    79967982
    79977983/* Line 1806 of yacc.c  */
    7998 #line 2246 "parser.yy"
     7984#line 2245 "parser.yy"
    79997985    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    80007986    break;
    … …  
    80037989
    80047990/* Line 1806 of yacc.c  */
    8005 #line 2248 "parser.yy"
     7991#line 2247 "parser.yy"
    80067992    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80077993    break;
    … …  
    80107996
    80117997/* Line 1806 of yacc.c  */
    8012 #line 2253 "parser.yy"
     7998#line 2252 "parser.yy"
    80137999    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    80148000    break;
    … …  
    80178003
    80188004/* Line 1806 of yacc.c  */
    8019 #line 2255 "parser.yy"
     8005#line 2254 "parser.yy"
    80208006    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80218007    break;
    … …  
    80248010
    80258011/* Line 1806 of yacc.c  */
    8026 #line 2264 "parser.yy"
     8012#line 2263 "parser.yy"
    80278013    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80288014    break;
    … …  
    80318017
    80328018/* Line 1806 of yacc.c  */
    8033 #line 2267 "parser.yy"
     8019#line 2266 "parser.yy"
    80348020    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    80358021    break;
    … …  
    80388024
    80398025/* Line 1806 of yacc.c  */
    8040 #line 2272 "parser.yy"
     8026#line 2271 "parser.yy"
    80418027    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    80428028    break;
    … …  
    80458031
    80468032/* Line 1806 of yacc.c  */
    8047 #line 2274 "parser.yy"
     8033#line 2273 "parser.yy"
    80488034    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    80498035    break;
    … …  
    80528038
    80538039/* Line 1806 of yacc.c  */
    8054 #line 2276 "parser.yy"
     8040#line 2275 "parser.yy"
    80558041    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80568042    break;
    … …  
    80598045
    80608046/* Line 1806 of yacc.c  */
    8061 #line 2281 "parser.yy"
     8047#line 2280 "parser.yy"
    80628048    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    80638049    break;
    … …  
    80668052
    80678053/* Line 1806 of yacc.c  */
    8068 #line 2283 "parser.yy"
     8054#line 2282 "parser.yy"
    80698055    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    80708056    break;
    … …  
    80738059
    80748060/* Line 1806 of yacc.c  */
    8075 #line 2285 "parser.yy"
     8061#line 2284 "parser.yy"
    80768062    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80778063    break;
    … …  
    80808066
    80818067/* Line 1806 of yacc.c  */
    8082 #line 2290 "parser.yy"
     8068#line 2289 "parser.yy"
    80838069    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    80848070    break;
    … …  
    80878073
    80888074/* Line 1806 of yacc.c  */
    8089 #line 2292 "parser.yy"
     8075#line 2291 "parser.yy"
    80908076    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    80918077    break;
    … …  
    80948080
    80958081/* Line 1806 of yacc.c  */
    8096 #line 2294 "parser.yy"
     8082#line 2293 "parser.yy"
    80978083    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    80988084    break;
    … …  
    81018087
    81028088/* Line 1806 of yacc.c  */
    8103 #line 2309 "parser.yy"
     8089#line 2308 "parser.yy"
    81048090    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
    81058091    break;
    … …  
    81088094
    81098095/* Line 1806 of yacc.c  */
    8110 #line 2311 "parser.yy"
     8096#line 2310 "parser.yy"
    81118097    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
    81128098    break;
    … …  
    81158101
    81168102/* Line 1806 of yacc.c  */
    8117 #line 2313 "parser.yy"
     8103#line 2312 "parser.yy"
    81188104    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81198105    break;
    … …  
    81228108
    81238109/* Line 1806 of yacc.c  */
    8124 #line 2318 "parser.yy"
     8110#line 2317 "parser.yy"
    81258111    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    81268112    break;
    … …  
    81298115
    81308116/* Line 1806 of yacc.c  */
    8131 #line 2320 "parser.yy"
     8117#line 2319 "parser.yy"
    81328118    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    81338119    break;
    … …  
    81368122
    81378123/* Line 1806 of yacc.c  */
    8138 #line 2322 "parser.yy"
     8124#line 2321 "parser.yy"
    81398125    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81408126    break;
    … …  
    81438129
    81448130/* Line 1806 of yacc.c  */
    8145 #line 2327 "parser.yy"
     8131#line 2326 "parser.yy"
    81468132    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81478133    break;
    … …  
    81508136
    81518137/* Line 1806 of yacc.c  */
    8152 #line 2329 "parser.yy"
     8138#line 2328 "parser.yy"
    81538139    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    81548140    break;
    … …  
    81578143
    81588144/* Line 1806 of yacc.c  */
    8159 #line 2331 "parser.yy"
     8145#line 2330 "parser.yy"
    81608146    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81618147    break;
    … …  
    81648150
    81658151/* Line 1806 of yacc.c  */
    8166 #line 2346 "parser.yy"
     8152#line 2345 "parser.yy"
    81678153    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81688154    break;
    … …  
    81718157
    81728158/* Line 1806 of yacc.c  */
    8173 #line 2349 "parser.yy"
     8159#line 2348 "parser.yy"
    81748160    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81758161    break;
    … …  
    81788164
    81798165/* Line 1806 of yacc.c  */
    8180 #line 2351 "parser.yy"
     8166#line 2350 "parser.yy"
    81818167    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    81828168    break;
    … …  
    81858171
    81868172/* Line 1806 of yacc.c  */
    8187 #line 2357 "parser.yy"
     8173#line 2356 "parser.yy"
    81888174    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    81898175    break;
    … …  
    81928178
    81938179/* Line 1806 of yacc.c  */
    8194 #line 2362 "parser.yy"
     8180#line 2361 "parser.yy"
    81958181    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    81968182    break;
    … …  
    81998185
    82008186/* Line 1806 of yacc.c  */
    8201 #line 2364 "parser.yy"
     8187#line 2363 "parser.yy"
    82028188    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    82038189    break;
    … …  
    82068192
    82078193/* Line 1806 of yacc.c  */
    8208 #line 2366 "parser.yy"
     8194#line 2365 "parser.yy"
    82098195    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82108196    break;
    … …  
    82138199
    82148200/* Line 1806 of yacc.c  */
    8215 #line 2371 "parser.yy"
     8201#line 2370 "parser.yy"
    82168202    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    82178203    break;
    … …  
    82208206
    82218207/* Line 1806 of yacc.c  */
    8222 #line 2373 "parser.yy"
     8208#line 2372 "parser.yy"
    82238209    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82248210    break;
    … …  
    82278213
    82288214/* Line 1806 of yacc.c  */
    8229 #line 2375 "parser.yy"
     8215#line 2374 "parser.yy"
    82308216    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    82318217    break;
    … …  
    82348220
    82358221/* Line 1806 of yacc.c  */
    8236 #line 2377 "parser.yy"
     8222#line 2376 "parser.yy"
    82378223    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82388224    break;
    … …  
    82418227
    82428228/* Line 1806 of yacc.c  */
    8243 #line 2382 "parser.yy"
     8229#line 2381 "parser.yy"
    82448230    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    82458231    break;
    … …  
    82488234
    82498235/* Line 1806 of yacc.c  */
    8250 #line 2384 "parser.yy"
     8236#line 2383 "parser.yy"
    82518237    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    82528238    break;
    … …  
    82558241
    82568242/* Line 1806 of yacc.c  */
    8257 #line 2386 "parser.yy"
     8243#line 2385 "parser.yy"
    82588244    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    82598245    break;
    … …  
    82628248
    82638249/* Line 1806 of yacc.c  */
    8264 #line 2396 "parser.yy"
     8250#line 2395 "parser.yy"
    82658251    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82668252    break;
    … …  
    82698255
    82708256/* Line 1806 of yacc.c  */
    8271 #line 2399 "parser.yy"
     8257#line 2398 "parser.yy"
    82728258    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82738259    break;
    … …  
    82768262
    82778263/* Line 1806 of yacc.c  */
    8278 #line 2401 "parser.yy"
     8264#line 2400 "parser.yy"
    82798265    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    82808266    break;
    … …  
    82838269
    82848270/* Line 1806 of yacc.c  */
    8285 #line 2406 "parser.yy"
     8271#line 2405 "parser.yy"
    82868272    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    82878273    break;
    … …  
    82908276
    82918277/* Line 1806 of yacc.c  */
    8292 #line 2408 "parser.yy"
     8278#line 2407 "parser.yy"
    82938279    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    82948280    break;
    … …  
    82978283
    82988284/* Line 1806 of yacc.c  */
    8299 #line 2410 "parser.yy"
     8285#line 2409 "parser.yy"
    83008286    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83018287    break;
    … …  
    83048290
    83058291/* Line 1806 of yacc.c  */
    8306 #line 2415 "parser.yy"
     8292#line 2414 "parser.yy"
    83078293    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    83088294    break;
    … …  
    83118297
    83128298/* Line 1806 of yacc.c  */
    8313 #line 2417 "parser.yy"
     8299#line 2416 "parser.yy"
    83148300    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83158301    break;
    … …  
    83188304
    83198305/* Line 1806 of yacc.c  */
    8320 #line 2419 "parser.yy"
     8306#line 2418 "parser.yy"
    83218307    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    83228308    break;
    … …  
    83258311
    83268312/* Line 1806 of yacc.c  */
    8327 #line 2421 "parser.yy"
     8313#line 2420 "parser.yy"
    83288314    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83298315    break;
    … …  
    83328318
    83338319/* Line 1806 of yacc.c  */
    8334 #line 2426 "parser.yy"
     8320#line 2425 "parser.yy"
    83358321    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    83368322    break;
    … …  
    83398325
    83408326/* Line 1806 of yacc.c  */
    8341 #line 2428 "parser.yy"
     8327#line 2427 "parser.yy"
    83428328    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    83438329    break;
    … …  
    83468332
    83478333/* Line 1806 of yacc.c  */
    8348 #line 2430 "parser.yy"
     8334#line 2429 "parser.yy"
    83498335    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    83508336    break;
    … …  
    83538339
    83548340/* Line 1806 of yacc.c  */
    8355 #line 2461 "parser.yy"
     8341#line 2460 "parser.yy"
    83568342    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83578343    break;
    … …  
    83608346
    83618347/* Line 1806 of yacc.c  */
    8362 #line 2464 "parser.yy"
     8348#line 2463 "parser.yy"
    83638349    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83648350    break;
    … …  
    83678353
    83688354/* Line 1806 of yacc.c  */
    8369 #line 2466 "parser.yy"
     8355#line 2465 "parser.yy"
    83708356    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    83718357    break;
    … …  
    83748360
    83758361/* Line 1806 of yacc.c  */
    8376 #line 2471 "parser.yy"
     8362#line 2470 "parser.yy"
    83778363    {
    83788364                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    83848370
    83858371/* Line 1806 of yacc.c  */
    8386 #line 2476 "parser.yy"
     8372#line 2475 "parser.yy"
    83878373    {
    83888374                        typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
    … …  
    83948380
    83958381/* Line 1806 of yacc.c  */
    8396 #line 2484 "parser.yy"
     8382#line 2483 "parser.yy"
    83978383    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    83988384    break;
    … …  
    84018387
    84028388/* Line 1806 of yacc.c  */
    8403 #line 2486 "parser.yy"
     8389#line 2485 "parser.yy"
    84048390    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84058391    break;
    … …  
    84088394
    84098395/* Line 1806 of yacc.c  */
    8410 #line 2488 "parser.yy"
     8396#line 2487 "parser.yy"
    84118397    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84128398    break;
    … …  
    84158401
    84168402/* Line 1806 of yacc.c  */
    8417 #line 2493 "parser.yy"
     8403#line 2492 "parser.yy"
    84188404    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    84198405    break;
    … …  
    84228408
    84238409/* Line 1806 of yacc.c  */
    8424 #line 2495 "parser.yy"
     8410#line 2494 "parser.yy"
    84258411    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84268412    break;
    … …  
    84298415
    84308416/* Line 1806 of yacc.c  */
    8431 #line 2500 "parser.yy"
     8417#line 2499 "parser.yy"
    84328418    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
    84338419    break;
    … …  
    84368422
    84378423/* Line 1806 of yacc.c  */
    8438 #line 2502 "parser.yy"
     8424#line 2501 "parser.yy"
    84398425    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    84408426    break;
    … …  
    84438429
    84448430/* Line 1806 of yacc.c  */
    8445 #line 2517 "parser.yy"
     8431#line 2516 "parser.yy"
    84468432    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84478433    break;
    … …  
    84508436
    84518437/* Line 1806 of yacc.c  */
    8452 #line 2519 "parser.yy"
     8438#line 2518 "parser.yy"
    84538439    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    84548440    break;
    … …  
    84578443
    84588444/* Line 1806 of yacc.c  */
    8459 #line 2524 "parser.yy"
     8445#line 2523 "parser.yy"
    84608446    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    84618447    break;
    … …  
    84648450
    84658451/* Line 1806 of yacc.c  */
    8466 #line 2526 "parser.yy"
     8452#line 2525 "parser.yy"
    84678453    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    84688454    break;
    … …  
    84718457
    84728458/* Line 1806 of yacc.c  */
    8473 #line 2528 "parser.yy"
     8459#line 2527 "parser.yy"
    84748460    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    84758461    break;
    … …  
    84788464
    84798465/* Line 1806 of yacc.c  */
    8480 #line 2530 "parser.yy"
     8466#line 2529 "parser.yy"
    84818467    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    84828468    break;
    … …  
    84858471
    84868472/* Line 1806 of yacc.c  */
    8487 #line 2532 "parser.yy"
     8473#line 2531 "parser.yy"
    84888474    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    84898475    break;
    … …  
    84928478
    84938479/* Line 1806 of yacc.c  */
    8494 #line 2538 "parser.yy"
     8480#line 2537 "parser.yy"
    84958481    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    84968482    break;
    … …  
    84998485
    85008486/* Line 1806 of yacc.c  */
    8501 #line 2540 "parser.yy"
     8487#line 2539 "parser.yy"
    85028488    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    85038489    break;
    … …  
    85068492
    85078493/* Line 1806 of yacc.c  */
    8508 #line 2542 "parser.yy"
     8494#line 2541 "parser.yy"
    85098495    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85108496    break;
    … …  
    85138499
    85148500/* Line 1806 of yacc.c  */
    8515 #line 2547 "parser.yy"
     8501#line 2546 "parser.yy"
    85168502    { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
    85178503    break;
    … …  
    85208506
    85218507/* Line 1806 of yacc.c  */
    8522 #line 2549 "parser.yy"
     8508#line 2548 "parser.yy"
    85238509    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    85248510    break;
    … …  
    85278513
    85288514/* Line 1806 of yacc.c  */
    8529 #line 2551 "parser.yy"
     8515#line 2550 "parser.yy"
    85308516    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    85318517    break;
    … …  
    85348520
    85358521/* Line 1806 of yacc.c  */
    8536 #line 2557 "parser.yy"
     8522#line 2556 "parser.yy"
    85378523    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    85388524    break;
    … …  
    85418527
    85428528/* Line 1806 of yacc.c  */
    8543 #line 2559 "parser.yy"
     8529#line 2558 "parser.yy"
    85448530    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
    85458531    break;
    … …  
    85488534
    85498535/* Line 1806 of yacc.c  */
    8550 #line 2565 "parser.yy"
     8536#line 2564 "parser.yy"
    85518537    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
    85528538    break;
    … …  
    85558541
    85568542/* Line 1806 of yacc.c  */
    8557 #line 2567 "parser.yy"
     8543#line 2566 "parser.yy"
    85588544    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
    85598545    break;
    … …  
    85628548
    85638549/* Line 1806 of yacc.c  */
    8564 #line 2569 "parser.yy"
     8550#line 2568 "parser.yy"
    85658551    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
    85668552    break;
    … …  
    85698555
    85708556/* Line 1806 of yacc.c  */
    8571 #line 2571 "parser.yy"
     8557#line 2570 "parser.yy"
    85728558    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
    85738559    break;
    … …  
    85768562
    85778563/* Line 1806 of yacc.c  */
    8578 #line 2586 "parser.yy"
     8564#line 2585 "parser.yy"
    85798565    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85808566    break;
    … …  
    85838569
    85848570/* Line 1806 of yacc.c  */
    8585 #line 2588 "parser.yy"
     8571#line 2587 "parser.yy"
    85868572    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    85878573    break;
    … …  
    85908576
    85918577/* Line 1806 of yacc.c  */
    8592 #line 2593 "parser.yy"
     8578#line 2592 "parser.yy"
    85938579    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    85948580    break;
    … …  
    85978583
    85988584/* Line 1806 of yacc.c  */
    8599 #line 2595 "parser.yy"
     8585#line 2594 "parser.yy"
    86008586    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    86018587    break;
    … …  
    86048590
    86058591/* Line 1806 of yacc.c  */
    8606 #line 2597 "parser.yy"
     8592#line 2596 "parser.yy"
    86078593    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    86088594    break;
    … …  
    86118597
    86128598/* Line 1806 of yacc.c  */
    8613 #line 2599 "parser.yy"
     8599#line 2598 "parser.yy"
    86148600    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    86158601    break;
    … …  
    86188604
    86198605/* Line 1806 of yacc.c  */
    8620 #line 2601 "parser.yy"
     8606#line 2600 "parser.yy"
    86218607    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86228608    break;
    … …  
    86258611
    86268612/* Line 1806 of yacc.c  */
    8627 #line 2607 "parser.yy"
     8613#line 2606 "parser.yy"
    86288614    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86298615    break;
    … …  
    86328618
    86338619/* Line 1806 of yacc.c  */
    8634 #line 2609 "parser.yy"
     8620#line 2608 "parser.yy"
    86358621    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    86368622    break;
    … …  
    86398625
    86408626/* Line 1806 of yacc.c  */
    8641 #line 2611 "parser.yy"
     8627#line 2610 "parser.yy"
    86428628    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86438629    break;
    … …  
    86468632
    86478633/* Line 1806 of yacc.c  */
    8648 #line 2616 "parser.yy"
     8634#line 2615 "parser.yy"
    86498635    { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
    86508636    break;
    … …  
    86538639
    86548640/* Line 1806 of yacc.c  */
    8655 #line 2618 "parser.yy"
     8641#line 2617 "parser.yy"
    86568642    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    86578643    break;
    … …  
    86608646
    86618647/* Line 1806 of yacc.c  */
    8662 #line 2620 "parser.yy"
     8648#line 2619 "parser.yy"
    86638649    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    86648650    break;
    … …  
    86678653
    86688654/* Line 1806 of yacc.c  */
    8669 #line 2627 "parser.yy"
     8655#line 2626 "parser.yy"
    86708656    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
    86718657    break;
    … …  
    86748660
    86758661/* Line 1806 of yacc.c  */
    8676 #line 2638 "parser.yy"
     8662#line 2637 "parser.yy"
    86778663    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
    86788664    break;
    … …  
    86818667
    86828668/* Line 1806 of yacc.c  */
    8683 #line 2641 "parser.yy"
     8669#line 2640 "parser.yy"
    86848670    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    86858671    break;
    … …  
    86888674
    86898675/* Line 1806 of yacc.c  */
    8690 #line 2643 "parser.yy"
     8676#line 2642 "parser.yy"
    86918677    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
    86928678    break;
    … …  
    86958681
    86968682/* Line 1806 of yacc.c  */
    8697 #line 2646 "parser.yy"
     8683#line 2645 "parser.yy"
    86988684    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    86998685    break;
    … …  
    87028688
    87038689/* Line 1806 of yacc.c  */
    8704 #line 2648 "parser.yy"
     8690#line 2647 "parser.yy"
    87058691    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
    87068692    break;
    … …  
    87098695
    87108696/* Line 1806 of yacc.c  */
    8711 #line 2650 "parser.yy"
     8697#line 2649 "parser.yy"
    87128698    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
    87138699    break;
    … …  
    87168702
    87178703/* Line 1806 of yacc.c  */
    8718 #line 2664 "parser.yy"
     8704#line 2663 "parser.yy"
    87198705    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87208706    break;
    … …  
    87238709
    87248710/* Line 1806 of yacc.c  */
    8725 #line 2666 "parser.yy"
     8711#line 2665 "parser.yy"
    87268712    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
    87278713    break;
    … …  
    87308716
    87318717/* Line 1806 of yacc.c  */
    8732 #line 2671 "parser.yy"
     8718#line 2670 "parser.yy"
    87338719    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
    87348720    break;
    … …  
    87378723
    87388724/* Line 1806 of yacc.c  */
    8739 #line 2673 "parser.yy"
     8725#line 2672 "parser.yy"
    87408726    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
    87418727    break;
    … …  
    87448730
    87458731/* Line 1806 of yacc.c  */
    8746 #line 2675 "parser.yy"
     8732#line 2674 "parser.yy"
    87478733    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
    87488734    break;
    … …  
    87518737
    87528738/* Line 1806 of yacc.c  */
    8753 #line 2677 "parser.yy"
     8739#line 2676 "parser.yy"
    87548740    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
    87558741    break;
    … …  
    87588744
    87598745/* Line 1806 of yacc.c  */
    8760 #line 2679 "parser.yy"
     8746#line 2678 "parser.yy"
    87618747    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87628748    break;
    … …  
    87658751
    87668752/* Line 1806 of yacc.c  */
    8767 #line 2685 "parser.yy"
     8753#line 2684 "parser.yy"
    87688754    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87698755    break;
    … …  
    87728758
    87738759/* Line 1806 of yacc.c  */
    8774 #line 2687 "parser.yy"
     8760#line 2686 "parser.yy"
    87758761    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
    87768762    break;
    … …  
    87798765
    87808766/* Line 1806 of yacc.c  */
    8781 #line 2689 "parser.yy"
     8767#line 2688 "parser.yy"
    87828768    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87838769    break;
    … …  
    87868772
    87878773/* Line 1806 of yacc.c  */
    8788 #line 2694 "parser.yy"
     8774#line 2693 "parser.yy"
    87898775    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
    87908776    break;
    … …  
    87938779
    87948780/* Line 1806 of yacc.c  */
    8795 #line 2696 "parser.yy"
     8781#line 2695 "parser.yy"
    87968782    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
    87978783    break;
    … …  
    88008786
    88018787/* Line 1806 of yacc.c  */
    8802 #line 2706 "parser.yy"
     8788#line 2705 "parser.yy"
    88038789    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    88048790    break;
    … …  
    88078793
    88088794/* Line 1806 of yacc.c  */
    8809 #line 2716 "parser.yy"
     8795#line 2715 "parser.yy"
    88108796    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    88118797    break;
    … …  
    88148800
    88158801/* Line 1806 of yacc.c  */
    8816 #line 2718 "parser.yy"
     8802#line 2717 "parser.yy"
    88178803    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    88188804    break;
    … …  
    88218807
    88228808/* Line 1806 of yacc.c  */
    8823 #line 2720 "parser.yy"
     8809#line 2719 "parser.yy"
    88248810    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    88258811    break;
    … …  
    88288814
    88298815/* Line 1806 of yacc.c  */
    8830 #line 2722 "parser.yy"
     8816#line 2721 "parser.yy"
    88318817    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    88328818    break;
    … …  
    88358821
    88368822/* Line 1806 of yacc.c  */
    8837 #line 2724 "parser.yy"
     8823#line 2723 "parser.yy"
    88388824    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    88398825    break;
    … …  
    88428828
    88438829/* Line 1806 of yacc.c  */
    8844 #line 2726 "parser.yy"
     8830#line 2725 "parser.yy"
    88458831    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    88468832    break;
    … …  
    88498835
    88508836/* Line 1806 of yacc.c  */
    8851 #line 2733 "parser.yy"
     8837#line 2732 "parser.yy"
    88528838    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    88538839    break;
    … …  
    88568842
    88578843/* Line 1806 of yacc.c  */
    8858 #line 2735 "parser.yy"
     8844#line 2734 "parser.yy"
    88598845    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    88608846    break;
    … …  
    88638849
    88648850/* Line 1806 of yacc.c  */
    8865 #line 2737 "parser.yy"
     8851#line 2736 "parser.yy"
    88668852    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    88678853    break;
    … …  
    88708856
    88718857/* Line 1806 of yacc.c  */
    8872 #line 2739 "parser.yy"
     8858#line 2738 "parser.yy"
    88738859    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    88748860    break;
    … …  
    88778863
    88788864/* Line 1806 of yacc.c  */
    8879 #line 2741 "parser.yy"
     8865#line 2740 "parser.yy"
    88808866    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    88818867    break;
    … …  
    88848870
    88858871/* Line 1806 of yacc.c  */
    8886 #line 2744 "parser.yy"
     8872#line 2743 "parser.yy"
    88878873    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    88888874    break;
    … …  
    88918877
    88928878/* Line 1806 of yacc.c  */
    8893 #line 2746 "parser.yy"
     8879#line 2745 "parser.yy"
    88948880    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    88958881    break;
    … …  
    88988884
    88998885/* Line 1806 of yacc.c  */
    8900 #line 2748 "parser.yy"
     8886#line 2747 "parser.yy"
    89018887    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
    89028888    break;
    … …  
    89058891
    89068892/* Line 1806 of yacc.c  */
    8907 #line 2750 "parser.yy"
     8893#line 2749 "parser.yy"
    89088894    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
    89098895    break;
    … …  
    89128898
    89138899/* Line 1806 of yacc.c  */
    8914 #line 2752 "parser.yy"
     8900#line 2751 "parser.yy"
    89158901    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    89168902    break;
    … …  
    89198905
    89208906/* Line 1806 of yacc.c  */
    8921 #line 2757 "parser.yy"
     8907#line 2756 "parser.yy"
    89228908    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
    89238909    break;
    … …  
    89268912
    89278913/* Line 1806 of yacc.c  */
    8928 #line 2759 "parser.yy"
     8914#line 2758 "parser.yy"
    89298915    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
    89308916    break;
    … …  
    89338919
    89348920/* Line 1806 of yacc.c  */
    8935 #line 2764 "parser.yy"
     8921#line 2763 "parser.yy"
    89368922    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
    89378923    break;
    … …  
    89408926
    89418927/* Line 1806 of yacc.c  */
    8942 #line 2766 "parser.yy"
     8928#line 2765 "parser.yy"
    89438929    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
    89448930    break;
    … …  
    89478933
    89488934/* Line 1806 of yacc.c  */
    8949 #line 2793 "parser.yy"
     8935#line 2792 "parser.yy"
    89508936    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
    89518937    break;
    … …  
    89548940
    89558941/* Line 1806 of yacc.c  */
    8956 #line 2804 "parser.yy"
     8942#line 2803 "parser.yy"
    89578943    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89588944    break;
    … …  
    89618947
    89628948/* Line 1806 of yacc.c  */
    8963 #line 2806 "parser.yy"
     8949#line 2805 "parser.yy"
    89648950    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89658951    break;
    … …  
    89688954
    89698955/* Line 1806 of yacc.c  */
    8970 #line 2808 "parser.yy"
     8956#line 2807 "parser.yy"
    89718957    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89728958    break;
    … …  
    89758961
    89768962/* Line 1806 of yacc.c  */
    8977 #line 2810 "parser.yy"
     8963#line 2809 "parser.yy"
    89788964    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89798965    break;
    … …  
    89828968
    89838969/* Line 1806 of yacc.c  */
    8984 #line 2812 "parser.yy"
     8970#line 2811 "parser.yy"
    89858971    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
    89868972    break;
    … …  
    89898975
    89908976/* Line 1806 of yacc.c  */
    8991 #line 2814 "parser.yy"
     8977#line 2813 "parser.yy"
    89928978    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
    89938979    break;
    … …  
    89968982
    89978983/* Line 1806 of yacc.c  */
    8998 #line 2821 "parser.yy"
     8984#line 2820 "parser.yy"
    89998985    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    90008986    break;
    … …  
    90038989
    90048990/* Line 1806 of yacc.c  */
    9005 #line 2823 "parser.yy"
     8991#line 2822 "parser.yy"
    90068992    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    90078993    break;
    … …  
    90108996
    90118997/* Line 1806 of yacc.c  */
    9012 #line 2825 "parser.yy"
     8998#line 2824 "parser.yy"
    90138999    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90149000    break;
    … …  
    90179003
    90189004/* Line 1806 of yacc.c  */
    9019 #line 2827 "parser.yy"
     9005#line 2826 "parser.yy"
    90209006    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    90219007    break;
    … …  
    90249010
    90259011/* Line 1806 of yacc.c  */
    9026 #line 2829 "parser.yy"
     9012#line 2828 "parser.yy"
    90279013    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
    90289014    break;
    … …  
    90319017
    90329018/* Line 1806 of yacc.c  */
    9033 #line 2831 "parser.yy"
     9019#line 2830 "parser.yy"
    90349020    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
    90359021    break;
    … …  
    90389024
    90399025/* Line 1806 of yacc.c  */
    9040 #line 2836 "parser.yy"
     9026#line 2835 "parser.yy"
    90419027    { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
    90429028    break;
    … …  
    90459031
    90469032/* Line 1806 of yacc.c  */
    9047 #line 2843 "parser.yy"
     9033#line 2842 "parser.yy"
    90489034    { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
    90499035    break;
    … …  
    90529038
    90539039/* Line 1806 of yacc.c  */
    9054 #line 2845 "parser.yy"
     9040#line 2844 "parser.yy"
    90559041    { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
    90569042    break;
    … …  
    90599045
    90609046/* Line 1806 of yacc.c  */
    9061 #line 2869 "parser.yy"
     9047#line 2868 "parser.yy"
    90629048    { (yyval.en) = 0; }
    90639049    break;
    … …  
    90669052
    90679053/* Line 1806 of yacc.c  */
    9068 #line 2871 "parser.yy"
     9054#line 2870 "parser.yy"
    90699055    { (yyval.en) = (yyvsp[(2) - (2)].en); }
    90709056    break;
    … …  
    90739059
    90749060/* Line 1806 of yacc.c  */
    9075 #line 9076 "Parser/parser.cc"
     9061#line 9062 "Parser/parser.cc"
    90769062      default: break;
    90779063    }
    … …  
    93049290
    93059291/* Line 2067 of yacc.c  */
    9306 #line 2874 "parser.yy"
     9292#line 2873 "parser.yy"
    93079293
    93089294// ----end of grammar----

  • src/Parser/parser.yy

    r3f0c6a5 r47a8d17  
    199199
    200200%type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
    201 %type<en> field field_list field_name
     201%type<en> field field_list
     202%type<tok> field_name
    202203
    203204%type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
    … …  
    383384                { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
    384385        | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
    385                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
    386386        | postfix_expression REALFRACTIONconstant                       // CFA, tuple index
    387                 { $$ = new ExpressionNode( build_fieldSel( $1, build_constantInteger( *$2 ) ) ); }
    388387        | postfix_expression ARROW no_attr_identifier
    389388                { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
    390389        | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
    391                         { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
    392390        | postfix_expression ICR
    393391                { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
    … …  
    423421field:                                                                                                  // CFA, tuple field selector
    424422        field_name
     423                { $$ = new ExpressionNode( build_varref( $1 ) ); }
    425424        | REALDECIMALconstant field
    426                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_constantInteger( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
     425                { $$ = new ExpressionNode( build_fieldSel( $2, build_varref( $1 ) ) ); }
    427426        | REALDECIMALconstant '[' push field_list pop ']'
    428                 { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_constantInteger( *$1 ) ), build_tuple( $4 ) ) ); }
     427                { $$ = new ExpressionNode( build_fieldSel( $4, build_varref( $1 ) ) ); }
    429428        | field_name '.' field
    430                 { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
     429                { $$ = new ExpressionNode( build_fieldSel( $3, build_varref( $1 ) ) ); }
    431430        | field_name '.' '[' push field_list pop ']'
    432                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
     431                { $$ = new ExpressionNode( build_fieldSel( $5, build_varref( $1 ) ) ); }
    433432        | field_name ARROW field
    434                 { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
     433                { $$ = new ExpressionNode( build_pfieldSel( $3, build_varref( $1 ) ) ); }
    435434        | field_name ARROW '[' push field_list pop ']'
    436                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
    437         ;
    438 
    439 field_name: // ... use $2
     435                { $$ = new ExpressionNode( build_pfieldSel( $5, build_varref( $1 ) ) ); }
     436        ;
     437
     438field_name:
    440439        INTEGERconstant fraction_constants
    441                 { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
     440                { $$ = $1; }
    442441        | FLOATINGconstant fraction_constants
    443                 { $$ = new ExpressionNode( build_constantInteger( *$1 ) ); }
     442                { $$ = $1; }
    444443        | no_attr_identifier fraction_constants
    445                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
     444                { $$ = $1; }
    446445        ;
    447446

  • src/ResolvExpr/Alternative.cc

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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"
    43 #include "InitTweak/GenInit.h"
    4444#include "ResolveTypeof.h"
    4545
    … …  
    6464        }
    6565
    66         Cost sumCost( const AltList &in ) {
    67                 Cost total;
    68                 for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
    69                         total += i->cost;
    70                 }
    71                 return total;
    72         }
    73 
    7466        namespace {
    7567                void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
    … …  
    8476                                out.push_back( i->expr->clone() );
    8577                        }
     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;
    8686                }
    8787
    … …  
    101101                                PruneStruct current( candidate );
    102102                                std::string mangleName;
    103                                 {
    104                                         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();
    105105                                        candidate->env.apply( newType );
    106                                         mangleName = SymTab::Mangler::mangle( newType );
     106                                        mangleName += SymTab::Mangler::mangle( newType );
    107107                                        delete newType;
    108108                                }
    … …  
    133133                                if ( ! target->second.isAmbiguous ) {
    134134                                        Alternative &alt = *target->second.candidate;
    135                                         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                                        }
    136138                                        *out++ = alt;
    137139                                }
    138140                        }
     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                        }
    139169                }
    140170
    141171                void renameTypes( Expression *expr ) {
    142                         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                        }
    143175                }
    144176        }
    … …  
    172204                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
    173205                        if ( adjust ) {
    174                                 adjustExprType( i->expr->get_result(), i->env, indexer );
     206                                adjustExprTypeList( i->expr->get_results().begin(), i->expr->get_results().end(), i->env, indexer );
    175207                        }
    176208                }
    … …  
    208240        }
    209241
    210         // std::unordered_map< Expression *, UniqueExpr * > ;
    211 
    212242        template< typename StructOrUnionType >
    213         void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
    214                 // by this point, member must be a name expr
    215                 NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member );
    216                 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 ) {
    217244                std::list< Declaration* > members;
    218245                aggInst->lookup( name, members );
    … …  
    227254        }
    228255
    229         void AlternativeFinder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
    230                 if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) {
    231                         // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning
    232                         // xxx - this should be improved by memoizing the value of constant exprs
    233                         // during parsing and reusing that information here.
    234                         std::stringstream ss( constantExpr->get_constant()->get_value() );
    235                         int val;
    236                         std::string tmp;
    237                         if ( ss >> val && ! (ss >> tmp) ) {
    238                                 if ( val >= 0 && (unsigned int)val < tupleType->size() ) {
    239                                         alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
    240                                 } // if
    241                         } // if
    242                 } // if
    243         }
    244 
    245256        void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) {
    246257                alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
    … …  
    248259
    249260        Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
    250                 ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
    251                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
    252                 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 );
    253267
    254268                Cost convCost( 0, 0, 0 );
    … …  
    256270                std::list< DeclarationWithType* >::iterator formal = formals.begin();
    257271                std::list< Expression* >& actuals = appExpr->get_args();
    258 
    259                 std::list< Type * > formalTypes;
    260                 std::list< Type * >::iterator formalType = formalTypes.end();
    261 
    262272                for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
    263 
    264273                        PRINT(
    265274                                std::cerr << "actual expression:" << std::endl;
    266275                                (*actualExpr)->print( std::cerr, 8 );
    267276                                std::cerr << "--- results are" << std::endl;
    268                                 (*actualExpr)->get_result()->print( std::cerr, 8 );
     277                                printAll( (*actualExpr)->get_results(), std::cerr, 8 );
    269278                        )
    270279                        std::list< DeclarationWithType* >::iterator startFormal = formal;
    271280                        Cost actualCost;
    272                         std::list< Type * > flatActualTypes;
    273                         flatten( (*actualExpr)->get_result(), back_inserter( flatActualTypes ) );
    274                         for ( std::list< Type* >::iterator actualType = flatActualTypes.begin(); actualType != flatActualTypes.end(); ++actualType ) {
    275 
    276 
    277                                 // tuple handling code
    278                                 if ( formalType == formalTypes.end() ) {
    279                                         // the type of the formal parameter may be a tuple type. To make this easier to work with,
    280                                         // flatten the tuple type and traverse the resulting list of types, incrementing the formal
    281                                         // iterator once its types have been extracted. Once a particular formal parameter's type has
    282                                         // been exhausted load the next formal parameter's type.
    283                                         if ( formal == formals.end() ) {
    284                                                 if ( function->get_isVarArgs() ) {
    285                                                         convCost += Cost( 1, 0, 0 );
    286                                                         break;
    287                                                 } else {
    288                                                         return Cost::infinity;
    289                                                 }
     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;
    290288                                        }
    291                                         formalTypes.clear();
    292                                         flatten( (*formal)->get_type(), back_inserter( formalTypes ) );
    293                                         formalType = formalTypes.begin();
    294                                         ++formal;
    295289                                }
    296 
    297290                                PRINT(
    298291                                        std::cerr << std::endl << "converting ";
    299                                         (*actualType)->print( std::cerr, 8 );
     292                                        (*actual)->print( std::cerr, 8 );
    300293                                        std::cerr << std::endl << " to ";
    301294                                        (*formal)->get_type()->print( std::cerr, 8 );
    302295                                )
    303                                 Cost newCost = conversionCost( *actualType, *formalType, indexer, alt.env );
     296                                Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
    304297                                PRINT(
    305298                                        std::cerr << std::endl << "cost is" << newCost << std::endl;
    … …  
    312305                                actualCost += newCost;
    313306
    314                                 convCost += Cost( 0, polyCost( *formalType, alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
    315 
    316                                 formalType++;
     307                                convCost += Cost( 0, polyCost( (*formal)->get_type(), alt.env, indexer ) + polyCost( *actual, alt.env, indexer ), 0 );
     308
     309                                formal++;
    317310                        }
    318311                        if ( actualCost != Cost( 0, 0, 0 ) ) {
    … …  
    363356        /// Adds type variables to the open variable set and marks their assertions
    364357        void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
    365                 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 ) {
    366359                        unifiableVars[ (*tyvar)->get_name() ] = (*tyvar)->get_kind();
    367360                        for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
    … …  
    372365        }
    373366
    374         /// instantiate a single argument by matching actuals from [actualIt, actualEnd) against formalType,
    375         /// producing expression(s) in out and their total cost in cost.
    376         template< typename AltIterator, typename OutputIterator >
    377         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 ) {
    378                 if ( TupleType * tupleType = dynamic_cast< TupleType * >( formalType ) ) {
    379                         // formalType is a TupleType - group actuals into a TupleExpr whose type unifies with the TupleType
    380                         TupleExpr * tupleExpr = new TupleExpr();
    381                         for ( Type * type : *tupleType ) {
    382                                 if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( tupleExpr->get_exprs() ) ) ) {
    383                                         delete tupleExpr;
    384                                         return false;
    385                                 }
    386                         }
    387                         tupleExpr->set_result( Tuples::makeTupleType( tupleExpr->get_exprs() ) );
    388                         *out++ = tupleExpr;
    389                 } else if ( actualIt != actualEnd ) {
    390                         // both actualType and formalType are atomic (non-tuple) types - if they unify
    391                         // then accept actual as an argument, otherwise return false (fail to instantiate argument)
    392                         Expression * actual = actualIt->expr;
    393                         Type * actualType = actual->get_result();
    394                         PRINT(
    395                                 std::cerr << "formal type is ";
    396                                 formalType->print( std::cerr );
    397                                 std::cerr << std::endl << "actual type is ";
    398                                 actualType->print( std::cerr );
    399                                 std::cerr << std::endl;
    400                         )
    401                         if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
    402                                 return false;
    403                         }
    404                         // move the expression from the alternative to the output iterator
    405                         *out++ = actual;
    406                         actualIt->expr = nullptr;
    407                         cost += actualIt->cost;
    408                         ++actualIt;
    409                 } else {
    410                         // End of actuals - Handle default values
    411                         if ( SingleInit *si = dynamic_cast<SingleInit *>( defaultValue )) {
    412                                 // so far, only constant expressions are accepted as default values
    413                                 if ( ConstantExpr *cnstexpr = dynamic_cast<ConstantExpr *>( si->get_value()) ) {
    414                                         if ( Constant *cnst = dynamic_cast<Constant *>( cnstexpr->get_constant() ) ) {
    415                                                 if ( unify( formalType, cnst->get_type(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
    416                                                         // xxx - Don't know if this is right
    417                                                         *out++ = cnstexpr->clone();
    418                                                         return true;
    419                                                 } // if
    420                                         } // if
    421                                 } // if
    422                         } // if
    423                         return false;
    424                 } // if
    425                 return true;
    426         }
    427 
    428         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 ) {
    429368                simpleCombineEnvironments( actuals.begin(), actuals.end(), resultEnv );
    430369                // make sure we don't widen any existing bindings
    … …  
    434373                resultEnv.extractOpenVars( openVars );
    435374
    436                 // flatten actuals so that each actual has an atomic (non-tuple) type
    437                 AltList exploded;
    438                 Tuples::explode( actuals, indexer, back_inserter( exploded ) );
    439 
    440                 AltList::iterator actualExpr = exploded.begin();
    441                 AltList::iterator actualEnd = exploded.end();
    442                 for ( DeclarationWithType * formal : formals ) {
    443                         // match flattened actuals with formal parameters - actuals will be grouped to match
    444                         // with formals as appropriate
    445                         Cost cost;
    446                         std::list< Expression * > newExprs;
    447                         ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
    448                         if ( ! instantiateArgument( obj->get_type(), obj->get_init(), actualExpr, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( newExprs ) ) ) {
    449                                 deleteAll( newExprs );
    450                                 return false;
    451                         }
    452                         // success - produce argument as a new alternative
    453                         assert( newExprs.size() == 1 );
    454                         out.push_back( Alternative( newExprs.front(), resultEnv, cost ) );
    455                 }
    456                 if ( actualExpr != actualEnd ) {
    457                         // there are still actuals remaining, but we've run out of formal parameters to match against
    458                         // this is okay only if the function is variadic
    459                         if ( ! isVarArgs ) {
    460                                 return false;
    461                         }
    462                         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;
    463416                }
    464417                return true;
    … …  
    547500                                //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
    548501                                Expression *varExpr = new VariableExpr( candDecl );
    549                                 delete varExpr->get_result();
    550                                 varExpr->set_result( adjType->clone() );
     502                                deleteAll( varExpr->get_results() );
     503                                varExpr->get_results().clear();
     504                                varExpr->get_results().push_front( adjType->clone() );
    551505                                PRINT(
    552506                                        std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
    … …  
    591545
    592546        template< typename OutputIterator >
    593         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 ) {
    594548                OpenVarSet openVars;
    595549                AssertionSet resultNeed, resultHave;
    596550                TypeEnvironment resultEnv;
    597551                makeUnifiableVars( funcType, openVars, resultNeed );
    598                 AltList instantiatedActuals; // filled by instantiate function
    599                 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 ) ) {
    600553                        ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
    601                         Alternative newAlt( appExpr, resultEnv, sumCost( instantiatedActuals ) );
    602                         makeExprList( instantiatedActuals, appExpr->get_args() );
     554                        Alternative newAlt( appExpr, resultEnv, sumCost( actualAlt ) );
     555                        makeExprList( actualAlt, appExpr->get_args() );
    603556                        PRINT(
    604557                                std::cerr << "need assertions:" << std::endl;
    … …  
    621574                                PointerType pt( Type::Qualifiers(), v.clone() );
    622575                                UntypedExpr *vexpr = untypedExpr->clone();
    623                                 vexpr->set_result( pt.clone() );
     576                                vexpr->get_results().push_front( pt.clone() );
    624577                                alternatives.push_back( Alternative( vexpr, env, Cost()) );
    625578                                return;
    … …  
    634587                combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
    635588
    636                 // take care of possible tuple assignments
    637                 // if not tuple assignment, assignment is taken care of as a normal function call
    638                 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 ...
    639594
    640595                AltList candidates;
    … …  
    649604                                // check if the type is pointer to function
    650605                                PointerType *pointer;
    651                                 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() ) ) ) {
    652607                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
    653608                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
    … …  
    685640                                                // check if the type is pointer to function
    686641                                                PointerType *pointer;
    687                                                 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() ) ) ) {
    688644                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
    689645                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
    … …  
    709665
    710666                        PRINT(
    711                                 ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( withFunc->expr );
    712                                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
    713                                 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 );
    714673                                std::cerr << "Case +++++++++++++" << std::endl;
    715674                                std::cerr << "formals are:" << std::endl;
    … …  
    733692
    734693        bool isLvalue( Expression *expr ) {
    735                 // xxx - recurse into tuples?
    736                 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;
    737698        }
    738699
    … …  
    748709
    749710        void AlternativeFinder::visit( CastExpr *castExpr ) {
    750                 Type *& toType = castExpr->get_result();
    751                 toType = resolveTypeof( toType, indexer );
    752                 SymTab::validateType( toType, &indexer );
    753                 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
    754716
    755717                AlternativeFinder finder( indexer, env );
    … …  
    765727                        // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
    766728                        // to.
    767                         int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
     729                        int discardedValues = (*i).expr->get_results().size() - castExpr->get_results().size();
    768730                        if ( discardedValues < 0 ) continue;
    769                         // 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() );
    770733                        // unification run for side-effects
    771                         unify( castExpr->get_result(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
    772                         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 );
    773740                        if ( thisCost != Cost::infinity ) {
    774741                                // count one safe conversion for each value that is thrown away
    … …  
    793760
    794761                for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
    795                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
    796                                 addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    797                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) {
    798                                 addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
    799                         } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( agg->expr->get_result() ) ) {
    800                                 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
    801768                        } // if
    802769                } // for
    … …  
    824791                        renameTypes( alternatives.back().expr );
    825792                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
    826                                 NameExpr nameExpr( "" );
    827                                 addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
     793                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
    828794                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
    829                                 NameExpr nameExpr( "" );
    830                                 addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
     795                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
    831796                        } // if
    832797                } // for
    … …  
    929894                        alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
    930895                        for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
    931                                 alternatives.back().expr->set_result( (*i)->get_type()->clone() );
     896                                alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
    932897                        } // for
    933898                } // if
    … …  
    952917                                                        finder.find( attrExpr->get_expr() );
    953918                                                        for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
    954                                                                 if ( choice->expr->get_result()->size() == 1 ) {
    955                                                                         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 );
    956921                                                                } // fi
    957922                                                        } // for
    … …  
    995960                                        AssertionSet needAssertions, haveAssertions;
    996961                                        Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );
    997                                         Type* commonType;
    998                                         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 ) ) {
    999964                                                ConditionalExpr *newExpr = new ConditionalExpr( first->expr->clone(), second->expr->clone(), third->expr->clone() );
    1000                                                 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
    1001974                                                newAlt.expr = newExpr;
    1002975                                                inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );
    … …  
    1026999                        TupleExpr *newExpr = new TupleExpr;
    10271000                        makeExprList( *i, newExpr->get_exprs() );
    1028                         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
    10291006
    10301007                        TypeEnvironment compositeEnv;
    … …  
    10471024                }
    10481025        }
    1049 
    1050         void AlternativeFinder::visit( TupleIndexExpr *tupleExpr ) {
    1051                 alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
    1052         }
    1053 
    1054         void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) {
    1055                 alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
    1056         }
    1057 
    1058         void AlternativeFinder::visit( UniqueExpr *unqExpr ) {
    1059                 // this won't work because the unqExprs wont share an expression anymore...
    1060                 AlternativeFinder finder( indexer, env );
    1061                 finder.findWithAdjustment( unqExpr->get_expr() );
    1062                 for ( Alternative & alt : finder.alternatives ) {
    1063                         // xxx - attach a resolved ConstructorInit node?
    1064                         // xxx - is it possible to make the objDecl's type const?
    1065                         static UniqueName tempNamer( "_unq_expr_" );
    1066                         ObjectDecl * objDecl = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, alt.expr->get_result()->clone(), nullptr );
    1067                         // must be done on two lines because genCtorInit accesses objDecl's fields
    1068                         objDecl->set_init( InitTweak::genCtorInit( objDecl ) );
    1069 
    1070                         UniqueExpr * newUnqExpr = new UniqueExpr( alt.expr->clone(), unqExpr->get_id() );
    1071                         newUnqExpr->set_object( objDecl );
    1072 
    1073                         resolveObject( indexer, objDecl );
    1074 
    1075                         alternatives.push_back( Alternative( newUnqExpr, env, Cost::zero ) );
    1076                 }
    1077         }
    1078 
    10791026} // namespace ResolvExpr
    10801027

  • src/ResolvExpr/AlternativeFinder.h

    r3f0c6a5 r47a8d17  
    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         void resolveObject( const SymTab::Indexer & indexer, ObjectDecl * objectDecl );
    98 
    99         template< typename InputIterator, typename OutputIterator >
    100         void findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
    101                 AltList alternatives;
    102 
    103                 // select the alternatives that have the minimum parameter cost
    104                 Cost minCost = Cost::infinity;
    105                 for ( InputIterator i = begin; i != end; ++i ) {
    106                         if ( i->cost < minCost ) {
    107                                 minCost = i->cost;
    108                                 i->cost = i->cvtCost;
    109                                 alternatives.clear();
    110                                 alternatives.push_back( *i );
    111                         } else if ( i->cost == minCost ) {
    112                                 i->cost = i->cvtCost;
    113                                 alternatives.push_back( *i );
    114                         }
    115                 }
    116                 std::copy( alternatives.begin(), alternatives.end(), out );
    117         }
    118 
    119         Cost sumCost( const AltList &in );
    120 
    121         template< typename InputIterator >
    122         void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
    123                 while ( begin != end ) {
    124                         result.simpleCombine( (*begin++).env );
    125                 }
    126         }
    12791} // namespace ResolvExpr
    12892

  • src/ResolvExpr/AlternativePrinter.cc

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    1919#include "RenameVars.h"
    2020#include "ResolveTypeof.h"
    21 #include "typeops.h"
    2221#include "SynTree/Statement.h"
    2322#include "SynTree/Type.h"
    … …  
    3534        class Resolver : public SymTab::Indexer {
    3635          public:
    37                 Resolver() : SymTab::Indexer( false ) {}
    38                 Resolver( const SymTab::Indexer & indexer ) : SymTab::Indexer( indexer ) {}
     36                Resolver() : SymTab::Indexer( false ), switchType( 0 ) {}
    3937
    4038                virtual void visit( FunctionDecl *functionDecl );
    41                 virtual void visit( ObjectDecl *objectDecl );
     39                virtual void visit( ObjectDecl *functionDecl );
    4240                virtual void visit( TypeDecl *typeDecl );
    4341                virtual void visit( EnumDecl * enumDecl );
    … …  
    6967          void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
    7068          void fallbackInit( ConstructorInit * ctorInit );
    71                 Type * functionReturn = nullptr;
    72                 Type *initContext = nullptr;
    73                 Type *switchType = nullptr;
     69                std::list< Type * > functionReturn;
     70                Type *initContext;
     71                Type *switchType;
    7472                bool inEnumDecl = false;
    7573        };
    … …  
    159157                        const TypeEnvironment *newEnv = 0;
    160158                        for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
    161                                 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() ) ) {
    162160                                        if ( newExpr ) {
    163161                                                throw SemanticError( "Too many interpretations for case control expression", untyped );
    … …  
    236234                Type *new_type = resolveTypeof( functionDecl->get_type(), *this );
    237235                functionDecl->set_type( new_type );
    238                 ValueGuard< Type * > oldFunctionReturn( functionReturn );
    239                 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
    240241                SymTab::Indexer::visit( functionDecl );
     242                functionReturn = oldFunctionReturn;
    241243        }
    242244
    … …  
    336338        void Resolver::visit( ReturnStmt *returnStmt ) {
    337339                if ( returnStmt->get_expr() ) {
    338                         CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
     340                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr() );
     341                        cloneAll( functionReturn, castExpr->get_results() );
    339342                        Expression *newExpr = findSingleExpression( castExpr, *this );
    340343                        delete castExpr;
    … …  
    381384                                if ( isCharType( at->get_base() ) ) {
    382385                                        // check if the resolved type is char *
    383                                         if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
     386                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_results().front() ) ) {
    384387                                                if ( isCharType( pt->get_base() ) ) {
    385388                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
    … …  
    443446                                (*iter)->accept( *this );
    444447                        } // for
    445                 } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) {
    446                         for ( Type * t : *tt ) {
    447                                 if ( iter == end ) break;
    448                                 initContext = t;
    449                                 (*iter++)->accept( *this );
    450                         }
    451448                } else if ( StructInstType * st = dynamic_cast< StructInstType * >( initContext ) ) {
    452449                        resolveAggrInit( st->get_baseStruct(), iter, end );
    … …  
    533530        }
    534531
    535         void resolveObject( const SymTab::Indexer & indexer, ObjectDecl * objectDecl ) {
    536                 Resolver resolver( indexer );
    537                 objectDecl->accept( resolver );
    538         }
    539 
    540532        void Resolver::visit( ConstructorInit *ctorInit ) {
    541533                // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit

  • src/ResolvExpr/TypeEnvironment.cc

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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* ), object( new ObjectDecl* ), 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         set_object( nullptr );
    592 }
    593 UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( other.expr ), object( other.object ), id( other.id ) {
    594 }
    595 UniqueExpr::~UniqueExpr() {
    596         if ( expr.unique() ) {
    597                 delete *expr;
    598         }
    599         if ( object.unique() ) {
    600                 delete *object;
    601         }
    602 }
    603 void UniqueExpr::print( std::ostream &os, int indent ) const {
    604         os << "Unique Expression with id:" << id << std::endl << std::string( indent+2, ' ' );
    605         get_expr()->print( os, indent+2 );
    606         if ( get_object() ) {
    607                 os << " with decl: ";
    608                 get_object()->printShort( os, indent+2 );
    609         }
    610565}
    611566

  • src/SynTree/Expression.h

    r3f0c6a5 r47a8d17  
    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         ObjectDecl * get_object() const { return *object; }
    745         UniqueExpr * set_object( ObjectDecl * newValue ) { *object = newValue; return this; }
    746 
    747         int get_id() const { return id; }
    748 
    749         virtual UniqueExpr *clone() const { return new UniqueExpr( *this ); }
    750         virtual void accept( Visitor &v ) { v.visit( this ); }
    751         virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
    752         virtual void print( std::ostream &os, int indent = 0 ) const;
    753 private:
    754         std::shared_ptr< Expression * > expr;
    755         std::shared_ptr< ObjectDecl * > object;
    756         int id;
    757         static long long count;
    758672};
    759673

  • src/SynTree/Initializer.h

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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, spotter.currentFinder.get_indexer(), 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(), spotter.currentFinder.get_indexer(), 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

    r3f0c6a5 r47a8d17  
    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

    r3f0c6a5 r47a8d17  
    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.