Changes in / [b726084:84118d8]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (4 diffs)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• CodeGen/GenType.cc (modified) (1 diff)
• Common/utility.h (modified) (2 diffs)
• ControlStruct/LabelTypeChecker.cc (added)
• ControlStruct/LabelTypeChecker.h (added)
• ControlStruct/Mutate.cc (modified) (2 diffs)
• ControlStruct/module.mk (modified) (2 diffs)
• GenPoly/Box.cc (modified) (26 diffs)
• GenPoly/CopyParams.cc (modified) (1 diff)
• GenPoly/FindFunction.cc (modified) (2 diffs)
• GenPoly/GenPoly.cc (modified) (3 diffs)
• GenPoly/Lvalue.cc (modified) (8 diffs)
• GenPoly/Specialize.cc (modified) (4 diffs)
• InitTweak/FixInit.cc (modified) (14 diffs)
• InitTweak/GenInit.cc (modified) (10 diffs)
• InitTweak/GenInit.h (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (3 diffs)
• Makefile.in (modified) (14 diffs)
• Parser/ExpressionNode.cc (modified) (2 diffs)
• Parser/ParseNode.h (modified) (3 diffs)
• Parser/TypeData.cc (modified) (2 diffs)
• Parser/parser.cc (modified) (270 diffs)
• Parser/parser.yy (modified) (3 diffs)
• ResolvExpr/Alternative.cc (modified) (5 diffs)
• ResolvExpr/Alternative.h (modified) (3 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (31 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (2 diffs)
• ResolvExpr/AlternativePrinter.cc (modified) (2 diffs)
• ResolvExpr/ConversionCost.cc (modified) (1 diff)
• ResolvExpr/FindOpenVars.cc (modified) (3 diffs)
• ResolvExpr/RenameVars.cc (modified) (2 diffs)
• ResolvExpr/ResolveTypeof.cc (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (7 diffs)
• ResolvExpr/TypeEnvironment.cc (modified) (1 diff)
• ResolvExpr/TypeEnvironment.h (modified) (1 diff)
• ResolvExpr/Unify.cc (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (6 diffs)
• SymTab/Autogen.cc (modified) (1 diff)
• SymTab/Indexer.cc (modified) (12 diffs)
• SymTab/Indexer.h (modified) (1 diff)
• SymTab/Mangler.cc (modified) (4 diffs)
• SymTab/Validate.cc (modified) (3 diffs)
• SynTree/AddressExpr.cc (modified) (2 diffs)
• SynTree/ApplicationExpr.cc (modified) (2 diffs)
• SynTree/CommaExpr.cc (modified) (1 diff)
• SynTree/CompoundStmt.cc (modified) (2 diffs)
• SynTree/Expression.cc (modified) (21 diffs)
• SynTree/Expression.h (modified) (9 diffs)
• SynTree/Initializer.h (modified) (1 diff)
• SynTree/Mutator.cc (modified) (20 diffs)
• SynTree/Mutator.h (modified) (2 diffs)
• SynTree/ReferenceToType.cc (modified) (1 diff)
• SynTree/SynTree.h (modified) (2 diffs)
• SynTree/TupleExpr.cc (modified) (3 diffs)
• SynTree/TupleType.cc (modified) (2 diffs)
• SynTree/Type.h (modified) (8 diffs)
• SynTree/TypeSubstitution.cc (modified) (3 diffs)
• SynTree/VarExprReplacer.cc (deleted)
• SynTree/VarExprReplacer.h (deleted)
• SynTree/Visitor.cc (modified) (11 diffs)
• SynTree/Visitor.h (modified) (2 diffs)
• SynTree/module.mk (modified) (1 diff)
• Tuples/Explode.cc (deleted)
• Tuples/Explode.h (deleted)
• Tuples/NameMatcher.cc (added)
• Tuples/NameMatcher.h (added)
• Tuples/TupleAssignment.cc (modified) (3 diffs)
• Tuples/TupleAssignment.h (added)
• Tuples/TupleExpansion.cc (deleted)
• Tuples/Tuples.h (deleted)
• Tuples/module.mk (modified) (2 diffs)
• main.cc (modified) (4 diffs)
• tests/.expect/tupleAssign.txt (deleted)
• tests/.expect/tupleFunction.txt (deleted)
• tests/.expect/tupleMember.txt (deleted)
• tests/tupleAssign.c (deleted)
• tests/tupleFunction.c (deleted)
• tests/tupleMember.c (deleted)

src/CodeGen/CodeGenerator.cc

@@ -307 +307 @@
                                                 } else {
                                                         // no address-of operator, so must be a pointer - add dereference
-                                                        // NOTE: if the assertion starts to trigger, check that the application expr isn't being shared.
-                                                        // Since its arguments are modified here, this assertion most commonly triggers when the application
-                                                        // is visited multiple times.
                                                         UntypedExpr * newExpr = new UntypedExpr( new NameExpr( "*?" ) );
                                                         newExpr->get_args().push_back( *arg );
-                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_result() );
-                                                        assertf( type, "First argument to a derefence must be a pointer. Ensure that expressions are not being shared." );
-                                                        newExpr->set_result( type->clone() );
+                                                        assert( (*arg)->get_results().size() == 1 );
+                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_results().front() );
+                                                        assert( type );
+                                                        newExpr->get_results().push_back( type->clone() );
                                                         *arg = newExpr;
                                                 } // if
@@ -529 +527 @@
                 extension( castExpr );
                 output << "(";
-                if ( castExpr->get_result()->isVoid() ) {
+                if ( castExpr->get_results().empty() ) {
                         output << "(void)" ;
-                } else if ( ! castExpr->get_result()->get_isLvalue() ) {
+                } else if ( ! castExpr->get_results().front()->get_isLvalue() ) {
                         // at least one result type of cast, but not an lvalue
                         output << "(";
-                        output << genType( castExpr->get_result(), "" );
+                        output << genType( castExpr->get_results().front(), "" );
                         output << ")";
                 } else {
@@ -642 +640 @@
         }
 
-        void CodeGenerator::visit( TupleExpr * tupleExpr ) { assert( false ); }
+        void CodeGenerator::visit( TupleExpr * tupleExpr ) {}
 
         void CodeGenerator::visit( TypeExpr * typeExpr ) {}
@@ -656 +654 @@
                 asmExpr->get_operand()->accept( *this );
                 output << " )";
-        }
-
-        void CodeGenerator::visit( CompoundLiteralExpr *compLitExpr ) {
-                assert( compLitExpr->get_type() && dynamic_cast< ListInit * > ( compLitExpr->get_initializer() ) );
-                output << "(" << genType( compLitExpr->get_type(), "" ) << ")";
-                compLitExpr->get_initializer()->accept( *this );
-        }
-
-        void CodeGenerator::visit( StmtExpr * stmtExpr ) {
-                std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
-                output << "({" << std::endl;
-                cur_indent += CodeGenerator::tabsize;
-                unsigned int numStmts = stmts.size();
-                unsigned int i = 0;
-                for ( Statement * stmt : stmts ) {
-                        output << indent << printLabels( stmt->get_labels() );
-                        if ( i+1 == numStmts ) {
-                                // last statement in a statement expression needs to be handled specially -
-                                // cannot cast to void, otherwise the expression statement has no value
-                                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( stmt ) ) {
-                                        exprStmt->get_expr()->accept( *this );
-                                        output << ";" << endl;
-                                        ++i;
-                                        break;
-                                }
-                        }
-                        stmt->accept( *this );
-                        output << endl;
-                        if ( wantSpacing( stmt ) ) {
-                                output << endl;
-                        } // if
-                        ++i;
-                }
-                cur_indent -= CodeGenerator::tabsize;
-                output << indent << "})";
         }
 

src/CodeGen/CodeGenerator.h

@@ -70 +70 @@
                 virtual void visit( ConditionalExpr *conditionalExpr );
                 virtual void visit( CommaExpr *commaExpr );
-                virtual void visit( CompoundLiteralExpr *compLitExpr );
                 virtual void visit( TupleExpr *tupleExpr );
                 virtual void visit( TypeExpr *typeExpr );
                 virtual void visit( AsmExpr * );
-                virtual void visit( StmtExpr * );
 
                 //*** Statements

src/CodeGen/GenType.cc

@@ -227 +227 @@
                         typeString = "_Atomic " + typeString;
                 } // if
+                if ( type->get_isAttribute() ) {
+                        typeString = "__attribute(( )) " + typeString;
+                } // if
         }
 } // namespace CodeGen

src/Common/utility.h

@@ -148 +148 @@
 }
 
-// replace element of list with all elements of another list
 template< typename T >
 void replace( std::list< T > &org, typename std::list< T >::iterator pos, std::list< T > &with ) {
@@ -159 +158 @@
 
         return;
-}
-
-// replace range of a list with a single element
-template< typename T >
-void replace( std::list< T > &org, typename std::list< T >::iterator begin, typename std::list< T >::iterator end, const T & with ) {
-        org.insert( begin, with );
-        org.erase( begin, end );
 }
 

src/ControlStruct/Mutate.cc

@@ -23 +23 @@
 #include "MLEMutator.h"
 #include "ForExprMutator.h"
+#include "LabelTypeChecker.h"
 //#include "ExceptMutator.h"
 
@@ -40 +41 @@
 
                 //ExceptMutator exc;
+                // LabelTypeChecker lbl;
 
                 mutateAll( translationUnit, formut );
                 acceptAll( translationUnit, lfix );
                 //mutateAll( translationUnit, exc );
+                //acceptAll( translationUnit, lbl );
         }
 } // namespace CodeGen

src/ControlStruct/module.mk

@@ -6 +6 @@
 ## file "LICENCE" distributed with Cforall.
 ##
-## module.mk --
+## module.mk -- 
 ##
 ## Author           : Richard C. Bilson
@@ -19 +19 @@
         ControlStruct/MLEMutator.cc \
         ControlStruct/Mutate.cc \
-        ControlStruct/ForExprMutator.cc
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/LabelTypeChecker.cc
 

src/GenPoly/Box.cc

@@ -113 +113 @@
                         void addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars );
                         /// Stores assignment operators from assertion list in local map of assignment operations
-                        void findTypeOps( const Type::ForallList &forall );
+                        void findTypeOps( const std::list< TypeDecl *> &forall );
                         void passAdapters( ApplicationExpr *appExpr, FunctionType *functionType, const TyVarMap &exprTyVars );
                         FunctionDecl *makeAdapter( FunctionType *adaptee, FunctionType *realType, const std::string &mangleName, const TyVarMap &tyVars );
@@ -619 +619 @@
                 }
 
-                void Pass1::findTypeOps( const Type::ForallList &forall ) {
+                void Pass1::findTypeOps( const std::list< TypeDecl *> &forall ) {
                         // what if a nested function uses an assignment operator?
                         // assignOps.clear();
-                        for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
+                        for ( std::list< TypeDecl *>::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
                                 for ( std::list< DeclarationWithType *>::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
                                         std::string typeName;
@@ -687 +687 @@
                                 std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
                                 std::list< FunctionType *> functions;
-                                for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
+                                for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                         for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
                                                 findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter );
@@ -789 +789 @@
 
                         // add size/align for generic types to parameter list
-                        if ( ! appExpr->get_function()->has_result() ) return;
-                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
+                        if ( appExpr->get_function()->get_results().empty() ) return;
+                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_results().front() );
                         assert( funcType );
 
@@ -806 +806 @@
                         for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
                                 VariableExpr *fnArgBase = getBaseVar( *fnArg );
-                                if ( ! fnArgBase ) continue; // xxx - previously had check for non-empty fnArgBase results
-                                passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_result(), arg, exprTyVars, seenTypes );
+                                if ( ! fnArgBase || fnArgBase->get_results().empty() ) continue;
+                                passArgTypeVars( appExpr, (*fnParm)->get_type(), fnArgBase->get_results().front(), arg, exprTyVars, seenTypes );
                         }
                 }
@@ -897 +897 @@
                         Type * adapteeType = new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
                         appExpr->get_args().push_front( new CastExpr( appExpr->get_function(), adapteeType ) );
-                        appExpr->set_function( new NameExpr( adapterName ) ); // xxx - result is never set on NameExpr
+                        appExpr->set_function( new NameExpr( adapterName ) );
 
                         return ret;
@@ -903 +903 @@
 
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-                        assert( arg->has_result() );
+                        assert( ! arg->get_results().empty() );
                         if ( isPolyType( param, exprTyVars ) ) {
-                                if ( isPolyType( arg->get_result() ) ) {
+                                if ( isPolyType( arg->get_results().front() ) ) {
                                         // if the argument's type is polymorphic, we don't need to box again!
                                         return;
-                                } else if ( arg->get_result()->get_isLvalue() ) {
+                                } else if ( arg->get_results().front()->get_isLvalue() ) {
                                         // VariableExpr and MemberExpr are lvalues; need to check this isn't coming from the second arg of a comma expression though (not an lvalue)
                                         // xxx - need to test that this code is still reachable
@@ -953 +953 @@
                 void Pass1::addInferredParams( ApplicationExpr *appExpr, FunctionType *functionType, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
                         std::list< Expression *>::iterator cur = arg;
-                        for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
+                        for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
                                         InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
@@ -994 +994 @@
                                         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
                                         deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
-                                        deref->set_result( arg->get_type()->clone() );
+                                        deref->get_results().push_back( arg->get_type()->clone() );
                                         return deref;
                                 } // if
@@ -1020 +1020 @@
                         Statement *bodyStmt;
 
-                        Type::ForallList::iterator tyArg = realType->get_forall().begin();
-                        Type::ForallList::iterator tyParam = adapterType->get_forall().begin();
-                        Type::ForallList::iterator realTyParam = adaptee->get_forall().begin();
+                        std::list< TypeDecl *>::iterator tyArg = realType->get_forall().begin();
+                        std::list< TypeDecl *>::iterator tyParam = adapterType->get_forall().begin();
+                        std::list< TypeDecl *>::iterator realTyParam = adaptee->get_forall().begin();
                         for ( ; tyParam != adapterType->get_forall().end(); ++tyArg, ++tyParam, ++realTyParam ) {
                                 assert( tyArg != realType->get_forall().end() );
@@ -1071 +1071 @@
                         std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
                         std::list< FunctionType *> functions;
-                        for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
+                        for ( std::list< TypeDecl *>::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
                                         findFunction( (*assert)->get_type(), functions, exprTyVars, needsAdapter );
@@ -1131 +1131 @@
                         } // if
                         addAssign->get_args().push_back( new NameExpr( sizeofName( mangleType( polyType ) ) ) );
-                        addAssign->set_result( appExpr->get_result()->clone() );
+                        addAssign->get_results().front() = appExpr->get_results().front()->clone();
                         if ( appExpr->get_env() ) {
                                 addAssign->set_env( appExpr->get_env() );
@@ -1145 +1145 @@
                                 if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
                                         if ( varExpr->get_var()->get_name() == "?[?]" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 2 );
-                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
-                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
+                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
+                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
                                                 assert( ! baseType1 || ! baseType2 ); // the arguments cannot both be polymorphic pointers
                                                 UntypedExpr *ret = 0;
@@ -1168 +1168 @@
                                                 } // if
                                                 if ( baseType1 || baseType2 ) {
-                                                        ret->set_result( appExpr->get_result()->clone() );
+                                                        ret->get_results().push_front( appExpr->get_results().front()->clone() );
                                                         if ( appExpr->get_env() ) {
                                                                 ret->set_env( appExpr->get_env() );
@@ -1178 +1178 @@
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "*?" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( ! appExpr->get_args().empty() );
-                                                if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
+                                                if ( isPolyType( appExpr->get_results().front(), scopeTyVars, env ) ) {
                                                         Expression *ret = appExpr->get_args().front();
-                                                        delete ret->get_result();
-                                                        ret->set_result( appExpr->get_result()->clone() );
+                                                        delete ret->get_results().front();
+                                                        ret->get_results().front() = appExpr->get_results().front()->clone();
                                                         if ( appExpr->get_env() ) {
                                                                 ret->set_env( appExpr->get_env() );
@@ -1193 +1193 @@
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 1 );
-                                                if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
-                                                        Type *tempType = appExpr->get_result()->clone();
+                                                if ( Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env ) ) {
+                                                        Type *tempType = appExpr->get_results().front()->clone();
                                                         if ( env ) {
                                                                 env->apply( tempType );
@@ -1213 +1213 @@
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 1 );
-                                                if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
+                                                if ( Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env ) ) {
                                                         return makeIncrDecrExpr( appExpr, baseType, varExpr->get_var()->get_name() == "++?" );
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 2 );
-                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
-                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_result(), scopeTyVars, env );
+                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
+                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
                                                 if ( baseType1 && baseType2 ) {
                                                         UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
                                                         divide->get_args().push_back( appExpr );
                                                         divide->get_args().push_back( new SizeofExpr( baseType1->clone() ) );
-                                                        divide->set_result( appExpr->get_result()->clone() );
+                                                        divide->get_results().push_front( appExpr->get_results().front()->clone() );
                                                         if ( appExpr->get_env() ) {
                                                                 divide->set_env( appExpr->get_env() );
@@ -1245 +1245 @@
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
-                                                assert( appExpr->has_result() );
+                                                assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 2 );
-                                                Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env );
+                                                Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env );
                                                 if ( baseType ) {
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
@@ -1273 +1273 @@
                         useRetval = oldUseRetval;
 
-                        assert( appExpr->get_function()->has_result() );
-                        PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
-                        FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                        assert( ! appExpr->get_function()->get_results().empty() );
+                        PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
+                        assert( pointer );
+                        FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
+                        assert( function );
 
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
@@ -1313 +1315 @@
 
                 Expression *Pass1::mutate( UntypedExpr *expr ) {
-                        if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
+                        if ( ! expr->get_results().empty() && isPolyType( expr->get_results().front(), scopeTyVars, env ) ) {
                                 if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
                                         if ( name->get_name() == "*?" ) {
@@ -1327 +1329 @@
 
                 Expression *Pass1::mutate( AddressExpr *addrExpr ) {
-                        assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
+                        assert( ! addrExpr->get_arg()->get_results().empty() );
 
                         bool needs = false;
                         if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
-                                if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
+                                if ( ! expr->get_results().empty() && isPolyType( expr->get_results().front(), scopeTyVars, env ) ) {
                                         if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
                                                 if ( name->get_name() == "*?" ) {
                                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
-                                                                assert( appExpr->get_function()->has_result() );
-                                                                PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
-                                                                FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                                                                assert( ! appExpr->get_function()->get_results().empty() );
+                                                                PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
+                                                                assert( pointer );
+                                                                FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
+                                                                assert( function );
                                                                 needs = needsAdapter( function, scopeTyVars );
                                                         } // if
@@ -1346 +1350 @@
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
-                        bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
+                        bool polytype = isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env );
                         addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
                         if ( polytype || needs ) {
                                 Expression *ret = addrExpr->get_arg();
-                                delete ret->get_result();
-                                ret->set_result( addrExpr->get_result()->clone() );
+                                delete ret->get_results().front();
+                                ret->get_results().front() = addrExpr->get_results().front()->clone();
                                 addrExpr->set_arg( 0 );
                                 delete addrExpr;
@@ -1389 +1393 @@
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
                         if ( retval && returnStmt->get_expr() ) {
-                                assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
+                                assert( ! returnStmt->get_expr()->get_results().empty() );
                                 // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous.
                                 // if ( returnStmt->get_expr()->get_results().front()->get_isLvalue() ) {
@@ -1423 +1427 @@
                                         // find each of its needed secondary assignment operators
                                         std::list< Expression* > &tyParams = refType->get_parameters();
-                                        Type::ForallList &forallParams = functionDecl->get_type()->get_forall();
+                                        std::list< TypeDecl* > &forallParams = functionDecl->get_type()->get_forall();
                                         std::list< Expression* >::const_iterator tyIt = tyParams.begin();
-                                        Type::ForallList::const_iterator forallIt = forallParams.begin();
+                                        std::list< TypeDecl* >::const_iterator forallIt = forallParams.begin();
                                         for ( ; tyIt != tyParams.end() && forallIt != forallParams.end(); ++tyIt, ++forallIt ) {
                                                 // Add appropriate mapping to assignment expression environment
@@ -1469 +1473 @@
                                 // replace return statement with appropriate assignment to out parameter
                                 Expression *retParm = new NameExpr( retval->get_name() );
-                                retParm->set_result( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
+                                retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
                                 assignExpr->get_args().push_back( retParm );
                                 assignExpr->get_args().push_back( returnStmt->get_expr() );
@@ -1599 +1603 @@
                         ObjectDecl newPtr( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
-                        for ( Type::ForallList::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
+                        for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
                                 ObjectDecl *sizeParm, *alignParm;
                                 // add all size and alignment parameters to parameter list

src/GenPoly/CopyParams.cc

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

src/GenPoly/FindFunction.cc

@@ -29 +29 @@
                 virtual Type *mutate( PointerType *pointerType );
           private:
-                void handleForall( const Type::ForallList &forall );
+                void handleForall( const std::list< TypeDecl* > &forall );
 
                 std::list< FunctionType* > &functions;
@@ -51 +51 @@
         }
 
-        void FindFunction::handleForall( const Type::ForallList &forall ) {
-                for ( Type::ForallList::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
+        void FindFunction::handleForall( const std::list< TypeDecl* > &forall ) {
+                for ( std::list< TypeDecl* >::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
                         TyVarMap::iterator var = tyVars.find( (*i)->get_name() );
                         if ( var != tyVars.end() ) {

src/GenPoly/GenPoly.cc

@@ -110 +110 @@
         ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &forallTypes ) {
                 if ( function->get_returnVals().empty() ) return 0;
-
+                
                 return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
         }
@@ -127 +127 @@
 //              } // if
                 if ( isDynRet( adaptee, tyVars ) ) return true;
-
+                
                 for ( std::list< DeclarationWithType* >::const_iterator innerArg = adaptee->get_parameters().begin(); innerArg != adaptee->get_parameters().end(); ++innerArg ) {
 //                      if ( isPolyType( (*innerArg)->get_type(), tyVars ) ) {
@@ -228 +228 @@
 
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
-                for ( Type::ForallList::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
+                for ( std::list< TypeDecl* >::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
                         assert( *tyVar );
                         tyVarMap[ (*tyVar)->get_name() ] = (*tyVar)->get_kind();

src/GenPoly/Lvalue.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Lvalue.cc --
+// Lvalue.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -41 +41 @@
                   public:
                         Pass1();
-
+  
                         virtual Expression *mutate( ApplicationExpr *appExpr );
                         virtual Statement *mutate( ReturnStmt *appExpr );
@@ -55 +55 @@
                   private:
                 };
-
-                /// GCC-like Generalized Lvalues (which have since been removed from GCC)
-                /// https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Lvalues.html#Lvalues
-                /// Replaces &(a,b) with (a, &b), &(a ? b : c) with (a ? &b : &c)
-                class GeneralizedLvalue : public Mutator {
-                        typedef Mutator Parent;
-
-                        virtual Expression * mutate( AddressExpr * addressExpr );
-                };
         } // namespace
 
@@ -69 +60 @@
                 Pass1 p1;
                 Pass2 p2;
-                GeneralizedLvalue genLval;
                 mutateAll( translationUnit, p1 );
                 acceptAll( translationUnit, p2 );
-                mutateAll( translationUnit, genLval );
         }
 
@@ -110 +99 @@
                         appExpr->get_function()->acceptMutator( *this );
                         mutateAll( appExpr->get_args(), *this );
+  
+                        assert( ! appExpr->get_function()->get_results().empty() );
 
-                        PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
-                        FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                        PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
+                        assert( pointer );
+                        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                        assert( function );
 
                         Type *funType = isLvalueRet( function );
                         if ( funType && ! isIntrinsicApp( appExpr ) ) {
                                 Expression *expr = appExpr;
-                                Type *appType = appExpr->get_result();
+                                Type *appType = appExpr->get_results().front();
                                 if ( isPolyType( funType ) && ! isPolyType( appType ) ) {
                                         // make sure cast for polymorphic type is inside dereference
@@ -123 +116 @@
                                 }
                                 UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                deref->set_result( appType->clone() );
-                                appExpr->set_result( new PointerType( Type::Qualifiers(), appType ) );
+                                deref->get_results().push_back( appType->clone() );
+                                appExpr->get_results().front() = new PointerType( Type::Qualifiers(), appType );
                                 deref->get_args().push_back( expr );
                                 return deref;
@@ -134 +127 @@
                 Statement * Pass1::mutate(ReturnStmt *retStmt) {
                         if ( retval && retStmt->get_expr() ) {
-                                if ( retStmt->get_expr()->get_result()->get_isLvalue() ) {
+                                assert( ! retStmt->get_expr()->get_results().empty() );
+                                if ( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
                                         // ***** Code Removal ***** because casts may be stripped already
 
@@ -161 +155 @@
                                 retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
                         } // if
-
+  
                         Visitor::visit( funType );
-                }
-
-                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
-                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
-                        if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( addrExpr->get_arg() ) ) {
-                                Expression * arg1 = commaExpr->get_arg1()->clone();
-                                Expression * arg2 = commaExpr->get_arg2()->clone();
-                                delete addrExpr;
-                                return new CommaExpr( arg1, new AddressExpr( arg2 ) );
-                        } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( addrExpr->get_arg() ) ) {
-                                Expression * arg1 = condExpr->get_arg1()->clone();
-                                Expression * arg2 = condExpr->get_arg2()->clone();
-                                Expression * arg3 = condExpr->get_arg3()->clone();
-                                delete addrExpr;
-                                return new ConditionalExpr( arg1, new AddressExpr( arg2 ), new AddressExpr( arg3 ) );
-                        }
-                        return addrExpr;
                 }
         } // namespace

src/GenPoly/Specialize.cc

@@ -148 +148 @@
 
         Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
-                assertf( actual->has_result(), "attempting to specialize an untyped expression" );
-                if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
+                assert( ! actual->get_results().empty() ); // using front, should have this assert
+                if ( needsSpecialization( formalType, actual->get_results().front(), env ) ) {
                         FunctionType *funType;
                         if ( ( funType = getFunctionType( formalType ) ) ) {
@@ -172 +172 @@
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
-                assert( appExpr->get_function()->has_result() );
-                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                assert( ! appExpr->get_function()->get_results().empty() );
+                FunctionType *function = getFunctionType( appExpr->get_function()->get_results().front() );
                 assert( function );
                 std::list< DeclarationWithType* >::iterator formal;
@@ -201 +201 @@
         Expression * Specialize::mutate( AddressExpr *addrExpr ) {
                 addrExpr->get_arg()->acceptMutator( *this );
-                assert( addrExpr->has_result() );
-                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
+                assert( ! addrExpr->get_results().empty() );
+                addrExpr->set_arg( doSpecialization( addrExpr->get_results().front(), addrExpr->get_arg() ) );
                 return addrExpr;
         }
@@ -208 +208 @@
         Expression * Specialize::mutate( CastExpr *castExpr ) {
                 castExpr->get_arg()->acceptMutator( *this );
-                if ( castExpr->get_result()->isVoid() ) {
+                if ( castExpr->get_results().empty() ) {
                         // can't specialize if we don't have a return value
                         return castExpr;
                 }
-                Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
+                Expression *specialized = doSpecialization( castExpr->get_results().front(), castExpr->get_arg() );
                 if ( specialized != castExpr->get_arg() ) {
                         // assume here that the specialization incorporates the cast

src/InitTweak/FixInit.cc

@@ -18 +18 @@
 #include <iterator>
 #include <algorithm>
-#include <unordered_map>
-#include <unordered_set>
 #include "InitTweak.h"
 #include "FixInit.h"
@@ -37 +35 @@
 #include "GenPoly/DeclMutator.h"
 #include "SynTree/AddStmtVisitor.h"
-#include "CodeGen/GenType.h"  // for warning/error messages
-
-bool ctordtorp = false; // print all debug
-bool ctorp = false; // print ctor debug
-bool cpctorp = false; // print copy ctor debug
-bool dtorp = false; // print dtor debug
+#include "CodeGen/GenType.h"  // for warnings
+
+bool ctordtorp = false;
+bool ctorp = false;
+bool cpctorp = false;
+bool dtorp = false;
 #define PRINT( text ) if ( ctordtorp ) { text }
 #define CP_CTOR_PRINT( text ) if ( ctordtorp || cpctorp ) { text }
@@ -49 +47 @@
 namespace InitTweak {
         namespace {
+                const std::list<Label> noLabels;
+                const std::list<Expression*> noDesignators;
+
                 class InsertImplicitCalls final : public GenPoly::PolyMutator {
                 public:
@@ -66 +67 @@
                         static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
 
-                        typedef SymTab::Indexer Parent;
-                        using Parent::visit;
-
+                        using SymTab::Indexer::visit;
                         virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
-                        virtual void visit( UniqueExpr * unqExpr );
 
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
-                        Expression * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL );
-                        Expression * makeCtorDtor( const std::string & fname, Expression * thisArg, Expression * cpArg = NULL );
+                        ApplicationExpr * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL );
                         /// true if type does not need to be copy constructed to ensure correctness
-                        bool skipCopyConstruct( Type * type );
-                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
-                        void destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
+                        bool skipCopyConstruct( Type * );
                 private:
                         TypeSubstitution * env;
@@ -188 +183 @@
                         using GenPoly::PolyMutator::mutate;
                         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
-                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
                 };
 
@@ -374 +368 @@
                 }
 
-                Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
+                ApplicationExpr * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
                         assert( var );
-                        return makeCtorDtor( fname, new AddressExpr( new VariableExpr( var ) ), cpArg );
-                }
-
-                Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, Expression * thisArg, Expression * cpArg ) {
-                        assert( thisArg );
                         UntypedExpr * untyped = new UntypedExpr( new NameExpr( fname ) );
-                        untyped->get_args().push_back( thisArg );
+                        untyped->get_args().push_back( new AddressExpr( new VariableExpr( var ) ) );
                         if (cpArg) untyped->get_args().push_back( cpArg->clone() );
 
@@ -389 +378 @@
                         // (VariableExpr and already resolved expression)
                         CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
-                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, *this );
-                        assert( resolved );
+                        ApplicationExpr * resolved = dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untyped, *this ) );
                         if ( resolved->get_env() ) {
                                 env->add( *resolved->get_env() );
                         } // if
 
+                        assert( resolved );
                         delete untyped;
                         return resolved;
                 }
 
-                void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
                         static UniqueName tempNamer("_tmp_cp");
-                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
-                        assert( arg->has_result() );
-                        Type * result = arg->get_result();
-                        if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
-
-                        // type may involve type variables, so apply type substitution to get temporary variable's actual type
-                        result = result->clone();
-                        impCpCtorExpr->get_env()->apply( result );
-                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
-                        tmp->get_type()->set_isConst( false );
-
-                        // create and resolve copy constructor
-                        CP_CTOR_PRINT( std::cerr << "makeCtorDtor for an argument" << std::endl; )
-                        Expression * cpCtor = makeCtorDtor( "?{}", tmp, arg );
-
-                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( cpCtor ) ) {
+                        static UniqueName retNamer("_tmp_cp_ret");
+
+                        CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
+                        Visitor::visit( impCpCtorExpr );
+                        env = impCpCtorExpr->get_env(); // xxx - maybe we really should just have a PolyIndexer...
+
+                        ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
+
+                        // take each argument and attempt to copy construct it.
+                        for ( Expression * & arg : appExpr->get_args() ) {
+                                CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
+                                // xxx - need to handle tuple arguments
+                                assert( ! arg->get_results().empty() );
+                                Type * result = arg->get_results().front();
+                                if ( skipCopyConstruct( result ) ) continue; // skip certain non-copyable types
+                                // type may involve type variables, so apply type substitution to get temporary variable's actual type
+                                result = result->clone();
+                                impCpCtorExpr->get_env()->apply( result );
+                                ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
+                                tmp->get_type()->set_isConst( false );
+
+                                // create and resolve copy constructor
+                                CP_CTOR_PRINT( std::cerr << "makeCtorDtor for an argument" << std::endl; )
+                                ApplicationExpr * cpCtor = makeCtorDtor( "?{}", tmp, arg );
+
                                 // if the chosen constructor is intrinsic, the copy is unnecessary, so
                                 // don't create the temporary and don't call the copy constructor
-                                VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
+                                VariableExpr * function = dynamic_cast< VariableExpr * >( cpCtor->get_function() );
                                 assert( function );
-                                if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return;
-                        }
-
-                        // replace argument to function call with temporary
-                        arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) );
-                        impCpCtorExpr->get_tempDecls().push_back( tmp );
-                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
-                }
-
-                void ResolveCopyCtors::destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr ) {
-                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", new AddressExpr( ret ) ) );
-                }
-
-                void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
-                        CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
-                        Parent::visit( impCpCtorExpr );
-                        env = impCpCtorExpr->get_env(); // xxx - maybe we really should just have a PolyIndexer...
-
-                        ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
-
-                        // take each argument and attempt to copy construct it.
-                        for ( Expression * & arg : appExpr->get_args() ) {
-                                copyConstructArg( arg, impCpCtorExpr );
+                                if ( function->get_var()->get_linkage() != LinkageSpec::Intrinsic ) {
+                                        // replace argument to function call with temporary
+                                        arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) );
+                                        impCpCtorExpr->get_tempDecls().push_back( tmp );
+                                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
+                                } // if
                         } // for
 
@@ -453 +434 @@
                         // level. Trying to pass that environment along.
                         callExpr->set_env( impCpCtorExpr->get_env()->clone() );
-                        Type * result = appExpr->get_result();
-                        if ( ! result->isVoid() ) {
-                                static UniqueName retNamer("_tmp_cp_ret");
+                        for ( Type * result : appExpr->get_results() ) {
                                 result = result->clone();
                                 impCpCtorExpr->get_env()->apply( result );
@@ -462 +441 @@
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
-                                if ( ! result->get_isLvalue() ) {
-                                        // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
-                                        destructRet( new VariableExpr( ret ), impCpCtorExpr );
-                                }
+                                impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
                         } // for
                         CP_CTOR_PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
-                }
-
-                void ResolveCopyCtors::visit( UniqueExpr * unqExpr ) {
-                        static std::unordered_set< int > vars;
-                        if ( vars.count( unqExpr->get_id() ) ) {
-                                // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
-                                return;
-                        }
-
-                        Parent::visit( unqExpr );
-                        // it should never be necessary to wrap a void-returning expression in a UniqueExpr - if this assumption changes, this needs to be rethought
-                        assert( unqExpr->get_result() );
-                        if ( ImplicitCopyCtorExpr * impCpCtorExpr = dynamic_cast<ImplicitCopyCtorExpr*>( unqExpr->get_expr() ) ) {
-                                // note the variable used as the result from the call
-                                assert( impCpCtorExpr->get_result() && impCpCtorExpr->get_returnDecls().size() == 1 );
-                                unqExpr->set_var( new VariableExpr( impCpCtorExpr->get_returnDecls().front() ) );
-                        } else {
-                                // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
-                                unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
-                                unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
-                        }
-                        vars.insert( unqExpr->get_id() );
                 }
 
@@ -536 +490 @@
                                 // know the result type of the assignment is the type of the LHS (minus the pointer), so
                                 // add that onto the assignment expression so that later steps have the necessary information
-                                assign->set_result( returnDecl->get_type()->clone() );
+                                assign->add_result( returnDecl->get_type()->clone() );
 
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
-                                if ( callExpr->get_result()->get_isLvalue() ) {
+                                if ( callExpr->get_results().front()->get_isLvalue() ) {
                                         // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
                                         // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
@@ -546 +500 @@
                                         // an AddressExpr.  Effectively, this turns
                                         //   lvalue T f();
-                                        //   &*f();
+                                        //   &*f()
                                         // into
-                                        //   T * f();
                                         //   T * tmp_cp_retN;
-                                        //   &*(tmp_cp_retN = &*f(), tmp_cp_retN);              // the first * and second & are generated here
+                                        //   tmp_cp_ret_N = &*(tmp_cp_ret_N = &*f(), tmp_cp_ret);
                                         // which work out in terms of types, but is pretty messy. It would be nice to find a better way.
                                         assign->get_args().back() = new AddressExpr( assign->get_args().back() );
 
+                                        Type * resultType = returnDecl->get_type()->clone();
                                         returnDecl->set_type( new PointerType( Type::Qualifiers(), returnDecl->get_type() ) );
-                                        retExpr->set_result( new PointerType( Type::Qualifiers(), retExpr->get_result() ) );
-                                        retExpr = UntypedExpr::createDeref( retExpr );
+                                        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                        deref->get_args().push_back( retExpr );
+                                        deref->add_result( resultType );
+                                        retExpr = deref;
                                 } // if
                                 retExpr->set_env( env->clone() );
@@ -563 +519 @@
                                 return callExpr;
                         } // if
-                }
-
-                Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
-                        static std::unordered_map< int, UniqueExpr * > unqMap;
-                        static std::unordered_set< int > addDeref;
-                        // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
-                        unqExpr = safe_dynamic_cast< UniqueExpr * >( Parent::mutate( unqExpr ) );
-                        if ( unqMap.count( unqExpr->get_id() ) ) {
-                                // take data from other UniqueExpr to ensure consistency
-                                delete unqExpr->get_expr();
-                                unqExpr->set_expr( unqMap[unqExpr->get_id()]->get_expr()->clone() );
-                                delete unqExpr->get_result();
-                                unqExpr->set_result( maybeClone( unqExpr->get_expr()->get_result() ) );
-                                if ( addDeref.count( unqExpr->get_id() ) ) {
-                                        // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too
-                                        return UntypedExpr::createDeref( unqExpr );
-                                }
-                                return unqExpr;
-                        }
-                        unqMap[unqExpr->get_id()] = unqExpr;
-                        if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
-                                // unique expression is now a dereference, because the inner expression is an lvalue returning function call.
-                                // Normalize the expression by dereferencing the unique expression, rather than the inner expression
-                                // (i.e. move the dereference out a level)
-                                assert( getFunctionName( deref ) == "*?" );
-                                unqExpr->set_expr( getCallArg( deref, 0 ) );
-                                getCallArg( deref, 0 ) = unqExpr;
-                                addDeref.insert( unqExpr->get_id() );
-                                return deref;
-                        }
-                        return unqExpr;
                 }
 
@@ -1025 +950 @@
                 Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
-                        // xxx - is the size check necessary?
-                        assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
-                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
+                        assert( ctorExpr->get_results().size() == 1 );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_results().front()->clone(), nullptr );
                         addDeclaration( tmp );
 
@@ -1039 +963 @@
                         assign->get_args().push_back( new VariableExpr( tmp ) );
                         assign->get_args().push_back( firstArg );
-                        assign->set_result( ctorExpr->get_result()->clone() );
+                        cloneAll( ctorExpr->get_results(), assign->get_results() );
                         firstArg = assign;
 

src/InitTweak/GenInit.cc

@@ -29 +29 @@
 #include "GenPoly/DeclMutator.h"
 #include "GenPoly/ScopedSet.h"
-#include "ResolvExpr/typeops.h"
 
 namespace InitTweak {
@@ -51 +50 @@
 
           protected:
-                FunctionType * ftype;
+                std::list<DeclarationWithType*> returnVals;
                 UniqueName tempNamer;
                 std::string funcName;
@@ -87 +86 @@
 
                 bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
-                bool isManaged( Type * type ) const; // determine if type is managed
                 void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
                 GenPoly::ScopedSet< std::string > managedTypes;
@@ -138 +136 @@
 
         Statement *ReturnFixer::mutate( ReturnStmt *returnStmt ) {
-                std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
+                // update for multiple return values
                 assert( returnVals.size() == 0 || returnVals.size() == 1 );
                 // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address
@@ -160 +158 @@
 
         DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
-                // xxx - need to handle named return values - this pass may need to happen
-                // after resolution? the ordering is tricky because return statements must be
-                // constructed - the simplest way to do that (while also handling multiple
-                // returns) is to structure the returnVals into a tuple, as done here.
-                // however, if the tuple return value is structured before resolution,
-                // it's difficult to resolve named return values, since the name is lost
-                // in conversion to a tuple. this might be easiest to deal with
-                // after reference types are added, as it may then be possible to
-                // uniformly move named return values to the parameter list directly
-                ValueGuard< FunctionType * > oldFtype( ftype );
+                ValueGuard< std::list<DeclarationWithType*> > oldReturnVals( returnVals );
                 ValueGuard< std::string > oldFuncName( funcName );
 
-                ftype = functionDecl->get_functionType();
-                std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
-                if ( retVals.size() > 1 ) {
-                        TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
-                        ObjectDecl * newRet = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
-                        retVals.clear();
-                        retVals.push_back( newRet );
-                }
+                FunctionType * type = functionDecl->get_functionType();
+                returnVals = type->get_returnVals();
                 funcName = functionDecl->get_name();
                 DeclarationWithType * decl = Mutator::mutate( functionDecl );
@@ -239 +222 @@
         }
 
-        bool CtorDtor::isManaged( Type * type ) const {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
-                        // tuple is also managed if any of its components are managed
-                        if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
-                                return true;
-                        }
-                }
-                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
-        }
-
         bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
                 Type * type = objDecl->get_type();
@@ -254 +227 @@
                         type = at->get_base();
                 }
-                return isManaged( type );
+                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
         }
 
@@ -265 +238 @@
                         managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
                 }
-        }
-
-        ConstructorInit * genCtorInit( ObjectDecl * objDecl ) {
-                // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
-                // for each constructable object
-                std::list< Statement * > ctor;
-                std::list< Statement * > dtor;
-
-                InitExpander srcParam( objDecl->get_init() );
-                InitExpander nullParam( (Initializer *)NULL );
-                SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
-                SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
-
-                // Currently genImplicitCall produces a single Statement - a CompoundStmt
-                // which  wraps everything that needs to happen. As such, it's technically
-                // possible to use a Statement ** in the above calls, but this is inherently
-                // unsafe, so instead we take the slightly less efficient route, but will be
-                // immediately informed if somehow the above assumption is broken. In this case,
-                // we could always wrap the list of statements at this point with a CompoundStmt,
-                // but it seems reasonable at the moment for this to be done by genImplicitCall
-                // itself. It is possible that genImplicitCall produces no statements (e.g. if
-                // an array type does not have a dimension). In this case, it's fine to ignore
-                // the object for the purposes of construction.
-                assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
-                if ( ctor.size() == 1 ) {
-                        // need to remember init expression, in case no ctors exist
-                        // if ctor does exist, want to use ctor expression instead of init
-                        // push this decision to the resolver
-                        assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
-                        return new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() );
-                }
-                return nullptr;
         }
 
@@ -309 +250 @@
                         if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl );
 
-                        objDecl->set_init( genCtorInit( objDecl ) );
+                        // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
+                        // for each constructable object
+                        std::list< Statement * > ctor;
+                        std::list< Statement * > dtor;
+
+                        InitExpander srcParam( objDecl->get_init() );
+                        InitExpander nullParam( (Initializer *)NULL );
+                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
+                        SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
+
+                        // Currently genImplicitCall produces a single Statement - a CompoundStmt
+                        // which  wraps everything that needs to happen. As such, it's technically
+                        // possible to use a Statement ** in the above calls, but this is inherently
+                        // unsafe, so instead we take the slightly less efficient route, but will be
+                        // immediately informed if somehow the above assumption is broken. In this case,
+                        // we could always wrap the list of statements at this point with a CompoundStmt,
+                        // but it seems reasonable at the moment for this to be done by genImplicitCall
+                        // itself. It is possible that genImplicitCall produces no statements (e.g. if
+                        // an array type does not have a dimension). In this case, it's fine to ignore
+                        // the object for the purposes of construction.
+                        assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
+                        if ( ctor.size() == 1 ) {
+                                // need to remember init expression, in case no ctors exist
+                                // if ctor does exist, want to use ctor expression instead of init
+                                // push this decision to the resolver
+                                assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
+                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
+                        }
                 }
                 return Parent::mutate( objDecl );
@@ -322 +290 @@
                 managedTypes.beginScope();
                 // go through assertions and recursively add seen ctor/dtors
-                for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
+                for ( TypeDecl * tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
                                 assertion = assertion->acceptMutator( *this );

src/InitTweak/GenInit.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// GenInit.h --
+// RemoveInit.h --
 //
 // Author           : Rodolfo G. Esteves
@@ -27 +27 @@
         /// Adds return value temporaries and wraps Initializers in ConstructorInit nodes
         void genInit( std::list< Declaration * > & translationUnit );
-
-        /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
-        ConstructorInit * genCtorInit( ObjectDecl * objDecl );
 } // namespace
 

src/InitTweak/InitTweak.cc

@@ -340 +340 @@
                 return allofCtorDtor( stmt, []( Expression * callExpr ){
                         if ( ApplicationExpr * appExpr = isIntrinsicCallExpr( callExpr ) ) {
-                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_result() );
+                                assert( ! appExpr->get_function()->get_results().empty() );
+                                FunctionType *funcType = GenPoly::getFunctionType( appExpr->get_function()->get_results().front() );
                                 assert( funcType );
                                 return funcType->get_parameters().size() == 1;
@@ -387 +388 @@
                                 return memberExpr->get_member()->get_name();
                         } else if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * > ( func ) ) {
-                                return funcName( memberExpr->get_member() );
+                                return memberExpr->get_member();
                         } else {
                                 assertf( false, "Unexpected expression type being called as a function in call expression" );
@@ -450 +451 @@
                 // virtual void visit( LogicalExpr *logicalExpr );
                 // virtual void visit( ConditionalExpr *conditionalExpr );
+                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
+                virtual void visit( SolvedTupleExpr *tupleExpr ) { isConstExpr = false; }
                 virtual void visit( TypeExpr *typeExpr ) { isConstExpr = false; }
                 virtual void visit( AsmExpr *asmExpr ) { isConstExpr = false; }
                 virtual void visit( UntypedValofExpr *valofExpr ) { isConstExpr = false; }
                 virtual void visit( CompoundLiteralExpr *compLitExpr ) { isConstExpr = false; }
-                virtual void visit( TupleExpr *tupleExpr ) { isConstExpr = false; }
-                virtual void visit( TupleAssignExpr *tupleExpr ) { isConstExpr = false; }
 
                 bool isConstExpr;

src/Makefile.in

@@ -105 +105 @@
         ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT) \
         ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT) \
+        ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \
@@ -189 +190 @@
         SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
-        SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT) \
         Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT) \
-        Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT) \
-        Tuples/driver_cfa_cpp-Explode.$(OBJEXT)
+        Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT)
 am_driver_cfa_cpp_OBJECTS = $(am__objects_1)
 driver_cfa_cpp_OBJECTS = $(am_driver_cfa_cpp_OBJECTS)
@@ -365 +364 @@
         ControlStruct/LabelGenerator.cc ControlStruct/LabelFixer.cc \
         ControlStruct/MLEMutator.cc ControlStruct/Mutate.cc \
-        ControlStruct/ForExprMutator.cc GenPoly/Box.cc \
+        ControlStruct/ForExprMutator.cc \
+        ControlStruct/LabelTypeChecker.cc GenPoly/Box.cc \
         GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
         GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
@@ -404 +404 @@
         SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \
         SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \
-        SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
-        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
-        Tuples/Explode.cc
+        SynTree/Attribute.cc Tuples/TupleAssignment.cc \
+        Tuples/NameMatcher.cc
 MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
         ${cfa_cpplib_PROGRAMS}}
@@ -542 +541 @@
         ControlStruct/$(DEPDIR)/$(am__dirstamp)
 ControlStruct/driver_cfa_cpp-ForExprMutator.$(OBJEXT):  \
+        ControlStruct/$(am__dirstamp) \
+        ControlStruct/$(DEPDIR)/$(am__dirstamp)
+ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT):  \
         ControlStruct/$(am__dirstamp) \
         ControlStruct/$(DEPDIR)/$(am__dirstamp)
@@ -767 +769 @@
 SynTree/driver_cfa_cpp-Attribute.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
-SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT):  \
-        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 Tuples/$(am__dirstamp):
         @$(MKDIR_P) Tuples
@@ -777 +777 @@
 Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT):  \
         Tuples/$(am__dirstamp) Tuples/$(DEPDIR)/$(am__dirstamp)
-Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT):  \
-        Tuples/$(am__dirstamp) Tuples/$(DEPDIR)/$(am__dirstamp)
-Tuples/driver_cfa_cpp-Explode.$(OBJEXT): Tuples/$(am__dirstamp) \
+Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT): Tuples/$(am__dirstamp) \
         Tuples/$(DEPDIR)/$(am__dirstamp)
 driver/$(am__dirstamp):
@@ -802 +800 @@
         -rm -f ControlStruct/driver_cfa_cpp-LabelFixer.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-LabelGenerator.$(OBJEXT)
+        -rm -f ControlStruct/driver_cfa_cpp-LabelTypeChecker.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-MLEMutator.$(OBJEXT)
         -rm -f ControlStruct/driver_cfa_cpp-Mutate.$(OBJEXT)
@@ -885 +884 @@
         -rm -f SynTree/driver_cfa_cpp-TypeofType.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-VarArgsType.$(OBJEXT)
-        -rm -f SynTree/driver_cfa_cpp-VarExprReplacer.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-Visitor.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-VoidType.$(OBJEXT)
         -rm -f SynTree/driver_cfa_cpp-ZeroOneType.$(OBJEXT)
-        -rm -f Tuples/driver_cfa_cpp-Explode.$(OBJEXT)
+        -rm -f Tuples/driver_cfa_cpp-NameMatcher.$(OBJEXT)
         -rm -f Tuples/driver_cfa_cpp-TupleAssignment.$(OBJEXT)
-        -rm -f Tuples/driver_cfa_cpp-TupleExpansion.$(OBJEXT)
 
 distclean-compile:
@@ -910 +907 @@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelFixer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelGenerator.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-MLEMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ControlStruct/$(DEPDIR)/driver_cfa_cpp-Mutate.Po@am__quote@
@@ -993 +991 @@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TypeofType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarArgsType.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Visitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-VoidType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ZeroOneType.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po@am__quote@
 
 .cc.o:
@@ -1241 +1237 @@
 @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`
 
+ControlStruct/driver_cfa_cpp-LabelTypeChecker.o: ControlStruct/LabelTypeChecker.cc
+@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
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/LabelTypeChecker.cc' object='ControlStruct/driver_cfa_cpp-LabelTypeChecker.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@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
+
+ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj: ControlStruct/LabelTypeChecker.cc
+@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`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Tpo ControlStruct/$(DEPDIR)/driver_cfa_cpp-LabelTypeChecker.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ControlStruct/LabelTypeChecker.cc' object='ControlStruct/driver_cfa_cpp-LabelTypeChecker.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@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`
+
 GenPoly/driver_cfa_cpp-Box.o: GenPoly/Box.cc
 @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
@@ -2417 +2427 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Attribute.obj `if test -f 'SynTree/Attribute.cc'; then $(CYGPATH_W) 'SynTree/Attribute.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Attribute.cc'; fi`
 
-SynTree/driver_cfa_cpp-VarExprReplacer.o: SynTree/VarExprReplacer.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-VarExprReplacer.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo -c -o SynTree/driver_cfa_cpp-VarExprReplacer.o `test -f 'SynTree/VarExprReplacer.cc' || echo '$(srcdir)/'`SynTree/VarExprReplacer.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/VarExprReplacer.cc' object='SynTree/driver_cfa_cpp-VarExprReplacer.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarExprReplacer.o `test -f 'SynTree/VarExprReplacer.cc' || echo '$(srcdir)/'`SynTree/VarExprReplacer.cc
-
-SynTree/driver_cfa_cpp-VarExprReplacer.obj: SynTree/VarExprReplacer.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-VarExprReplacer.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo -c -o SynTree/driver_cfa_cpp-VarExprReplacer.obj `if test -f 'SynTree/VarExprReplacer.cc'; then $(CYGPATH_W) 'SynTree/VarExprReplacer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarExprReplacer.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-VarExprReplacer.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/VarExprReplacer.cc' object='SynTree/driver_cfa_cpp-VarExprReplacer.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-VarExprReplacer.obj `if test -f 'SynTree/VarExprReplacer.cc'; then $(CYGPATH_W) 'SynTree/VarExprReplacer.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/VarExprReplacer.cc'; fi`
-
 Tuples/driver_cfa_cpp-TupleAssignment.o: Tuples/TupleAssignment.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-TupleAssignment.o -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-TupleAssignment.Tpo -c -o Tuples/driver_cfa_cpp-TupleAssignment.o `test -f 'Tuples/TupleAssignment.cc' || echo '$(srcdir)/'`Tuples/TupleAssignment.cc
@@ -2445 +2441 @@
 @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`
 
-Tuples/driver_cfa_cpp-TupleExpansion.o: Tuples/TupleExpansion.cc
-@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
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/TupleExpansion.cc' object='Tuples/driver_cfa_cpp-TupleExpansion.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@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
-
-Tuples/driver_cfa_cpp-TupleExpansion.obj: Tuples/TupleExpansion.cc
-@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`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-TupleExpansion.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/TupleExpansion.cc' object='Tuples/driver_cfa_cpp-TupleExpansion.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@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`
-
-Tuples/driver_cfa_cpp-Explode.o: Tuples/Explode.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-Explode.o -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo -c -o Tuples/driver_cfa_cpp-Explode.o `test -f 'Tuples/Explode.cc' || echo '$(srcdir)/'`Tuples/Explode.cc
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/Explode.cc' object='Tuples/driver_cfa_cpp-Explode.o' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@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-Explode.o `test -f 'Tuples/Explode.cc' || echo '$(srcdir)/'`Tuples/Explode.cc
-
-Tuples/driver_cfa_cpp-Explode.obj: Tuples/Explode.cc
-@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT Tuples/driver_cfa_cpp-Explode.obj -MD -MP -MF Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo -c -o Tuples/driver_cfa_cpp-Explode.obj `if test -f 'Tuples/Explode.cc'; then $(CYGPATH_W) 'Tuples/Explode.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/Explode.cc'; fi`
-@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-Explode.Po
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/Explode.cc' object='Tuples/driver_cfa_cpp-Explode.obj' libtool=no @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@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-Explode.obj `if test -f 'Tuples/Explode.cc'; then $(CYGPATH_W) 'Tuples/Explode.cc'; else $(CYGPATH_W) '$(srcdir)/Tuples/Explode.cc'; fi`
+Tuples/driver_cfa_cpp-NameMatcher.o: Tuples/NameMatcher.cc
+@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
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/NameMatcher.cc' object='Tuples/driver_cfa_cpp-NameMatcher.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@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
+
+Tuples/driver_cfa_cpp-NameMatcher.obj: Tuples/NameMatcher.cc
+@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`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Tpo Tuples/$(DEPDIR)/driver_cfa_cpp-NameMatcher.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='Tuples/NameMatcher.cc' object='Tuples/driver_cfa_cpp-NameMatcher.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@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`
 
 .ll.cc:

src/Parser/ExpressionNode.cc

@@ -172 +172 @@
 } // build_constantStr
 
-Expression * build_field_name_FLOATINGconstant( const std::string & str ) {
-        // str is of the form A.B -> separate at the . and return member expression
-        int a, b;
-        char dot;
-        std::stringstream ss( str );
-        ss >> a >> dot >> b;
-        UntypedMemberExpr * ret = new UntypedMemberExpr(
-                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::SignedInt ), toString( b ) ) ),
-                new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::SignedInt ), toString( a ) ) ) );
-        delete &str;
-        return ret;
-} // build_field_name_FLOATINGconstant
-
-Expression * make_field_name_fraction_constants( Expression * fieldName, Expression * fracts ) {
-        if ( fracts ) {
-                if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( fracts ) ) {
-                        memberExpr->set_member( make_field_name_fraction_constants( fieldName, memberExpr->get_aggregate() ) );
-                        return memberExpr;
-                } else {
-                        return new UntypedMemberExpr( fracts, fieldName );
-                }
-        }
-        return fieldName;
-} // make_field_name_fraction_constants
-
-Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts ) {
-        return make_field_name_fraction_constants( fieldName, maybeMoveBuild< Expression >( fracts ) );
-} // build_field_name_fraction_constants
-
-Expression * build_field_name_REALFRACTIONconstant( const std::string & str ) {
-        assert( str[0] == '.' );
-        Expression * ret = build_constantInteger( *new std::string( str.substr(1) ) );
-        delete &str;
-        return ret;
-} // build_field_name_REALFRACTIONconstant
-
-Expression * build_field_name_REALDECIMALconstant( const std::string & str ) {
-        assert( str[str.size()-1] == '.' );
-        Expression * ret = build_constantInteger( *new std::string( str.substr( 0, str.size()-1 ) ) );
-        delete &str;
-        return ret;
-} // build_field_name_REALDECIMALconstant
-
 NameExpr * build_varref( const string *name, bool labelp ) {
         NameExpr *expr = new NameExpr( *name, nullptr );
@@ -241 +198 @@
 }
 
-Expression *build_fieldSel( ExpressionNode *expr_node, Expression *member ) {
-        UntypedMemberExpr *ret = new UntypedMemberExpr( member, maybeMoveBuild< Expression >(expr_node) );
-        return ret;
-}
-
-Expression *build_pfieldSel( ExpressionNode *expr_node, Expression *member ) {
+Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member ) {
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeMoveBuild< Expression >(expr_node) );
+        delete member;
+        return ret;
+}
+
+Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member ) {
         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
         deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
-        UntypedMemberExpr *ret = new UntypedMemberExpr( member, deref );
+        UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
+        delete member;
         return ret;
 }

src/Parser/ParseNode.h

@@ -155 +155 @@
 Expression * build_constantChar( const std::string &str );
 ConstantExpr * build_constantStr( const std::string &str );
-Expression * build_field_name_FLOATINGconstant( const std::string & str );
-Expression * build_field_name_fraction_constants( Expression * fieldName, ExpressionNode * fracts );
-Expression * build_field_name_REALFRACTIONconstant( const std::string & str );
-Expression * build_field_name_REALDECIMALconstant( const std::string & str );
 
 NameExpr * build_varref( const std::string * name, bool labelp = false );
@@ -164 +160 @@
 
 Expression * build_cast( DeclarationNode * decl_node, ExpressionNode * expr_node );
-Expression * build_fieldSel( ExpressionNode * expr_node, Expression * member );
-Expression * build_pfieldSel( ExpressionNode * expr_node, Expression * member );
+Expression * build_fieldSel( ExpressionNode * expr_node, NameExpr * member );
+Expression * build_pfieldSel( ExpressionNode * expr_node, NameExpr * member );
 Expression * build_addressOf( ExpressionNode * expr_node );
 Expression * build_sizeOfexpr( ExpressionNode * expr_node );
@@ -387 +383 @@
 //##############################################################################
 
-template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
-void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
+template< typename SynTreeType, typename NodeType >
+void buildList( const NodeType * firstNode, std::list< SynTreeType * > &outputList ) {
         SemanticError errors;
-        std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
+        std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
         const NodeType * cur = firstNode;
 

src/Parser/TypeData.cc

@@ -385 +385 @@
 } // TypeData::print
 
-template< typename ForallList >
-void buildForall( const DeclarationNode * firstNode, ForallList &outputList ) {
+void buildForall( const DeclarationNode * firstNode, list< TypeDecl* > &outputList ) {
         buildList( firstNode, outputList );
-        for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
-                TypeDecl * td = static_cast<TypeDecl*>(*i);
-                if ( td->get_kind() == TypeDecl::Any ) {
+        for ( list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
+                if ( (*i)->get_kind() == TypeDecl::Any ) {
                         // add assertion parameters to `type' tyvars in reverse order
                         // add dtor:  void ^?{}(T *)
                         FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
-                        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 ) );
-                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
+                        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 ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
 
                         // add copy ctor:  void ?{}(T *, T)
                         FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
-                        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 ) );
-                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
+                        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 ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
 
                         // add default ctor:  void ?{}(T *)
                         FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
-                        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 ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
+                        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 ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
 
                         // add assignment operator:  T * ?=?(T *, T)
                         FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
-                        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 ) );
-                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
+                        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 ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+                        (*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
                 } // if
         } // for
@@ -517 +515 @@
                 // character types. The implementation shall define char to have the same range, representation, and behavior as
                 // either signed char or unsigned char.
-                static BasicType::Kind chartype[] = { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::Char };
+                static BasicType::Kind chartype[] = { BasicType::SignedChar, BasicType::UnsignedChar, BasicType::Char }; 
 
                 if ( td->length != DeclarationNode::NoLength ) {

src/Parser/parser.cc

@@ -1026 +1026 @@
 static const yytype_uint16 yyrline[] =
 {
-       0,   305,   305,   309,   316,   317,   318,   319,   320,   324,
-     325,   326,   330,   331,   335,   336,   340,   341,   345,   349,
-     350,   361,   363,   365,   366,   368,   373,   374,   380,   382,
-     384,   386,   388,   390,   392,   394,   396,   398,   407,   408,
-     414,   415,   419,   420,   424,   425,   427,   429,   431,   433,
-     435,   440,   442,   444,   450,   451,   459,   462,   464,   466,
-     471,   484,   486,   488,   490,   492,   494,   496,   498,   500,
-     502,   504,   511,   512,   518,   519,   520,   521,   525,   526,
-     533,   534,   536,   538,   543,   544,   546,   551,   552,   554,
-     559,   560,   562,   564,   566,   571,   572,   574,   579,   580,
-     585,   586,   591,   592,   597,   598,   603,   604,   609,   610,
-     613,   620,   625,   626,   634,   635,   639,   640,   641,   642,
-     643,   644,   645,   646,   647,   648,   649,   650,   660,   662,
-     667,   668,   673,   674,   680,   681,   687,   688,   689,   690,
-     691,   692,   693,   694,   695,   705,   712,   714,   724,   725,
-     730,   732,   738,   740,   744,   745,   750,   755,   758,   760,
-     762,   772,   774,   785,   786,   788,   792,   794,   798,   799,
-     804,   805,   809,   814,   815,   819,   821,   827,   828,   832,
-     834,   836,   838,   844,   845,   849,   851,   856,   858,   860,
-     865,   867,   872,   874,   878,   881,   885,   888,   892,   894,
-     896,   898,   903,   905,   907,   912,   914,   916,   918,   920,
-     925,   927,   929,   931,   936,   948,   949,   954,   956,   961,
-     965,   967,   969,   971,   973,   979,   980,   986,   987,   991,
-     992,   997,   999,  1005,  1006,  1008,  1013,  1018,  1028,  1030,
-    1034,  1035,  1040,  1042,  1046,  1047,  1051,  1053,  1057,  1058,
-    1062,  1063,  1067,  1068,  1083,  1084,  1085,  1086,  1087,  1091,
-    1096,  1103,  1113,  1118,  1123,  1131,  1136,  1141,  1146,  1151,
-    1181,  1186,  1193,  1195,  1202,  1207,  1212,  1223,  1228,  1233,
-    1238,  1243,  1252,  1257,  1265,  1266,  1267,  1268,  1274,  1279,
-    1287,  1288,  1289,  1290,  1294,  1295,  1296,  1297,  1302,  1303,
-    1312,  1313,  1318,  1319,  1324,  1326,  1328,  1330,  1332,  1335,
-    1334,  1346,  1347,  1349,  1359,  1360,  1365,  1367,  1369,  1371,
-    1373,  1376,  1378,  1381,  1386,  1388,  1390,  1392,  1394,  1396,
-    1398,  1400,  1402,  1404,  1406,  1408,  1410,  1416,  1417,  1419,
-    1421,  1423,  1428,  1429,  1435,  1436,  1438,  1440,  1445,  1447,
-    1449,  1451,  1456,  1457,  1459,  1461,  1466,  1467,  1469,  1474,
-    1475,  1477,  1479,  1484,  1486,  1488,  1493,  1494,  1498,  1500,
-    1506,  1505,  1509,  1511,  1516,  1518,  1524,  1525,  1530,  1531,
-    1533,  1534,  1543,  1544,  1546,  1548,  1553,  1555,  1561,  1562,
-    1564,  1567,  1570,  1575,  1576,  1581,  1586,  1590,  1592,  1598,
-    1597,  1604,  1606,  1612,  1613,  1621,  1622,  1626,  1627,  1628,
-    1630,  1632,  1639,  1640,  1642,  1644,  1649,  1650,  1656,  1657,
-    1661,  1662,  1667,  1668,  1669,  1671,  1679,  1680,  1682,  1685,
-    1687,  1691,  1692,  1693,  1695,  1697,  1701,  1706,  1714,  1715,
-    1724,  1726,  1731,  1732,  1733,  1737,  1738,  1739,  1743,  1744,
-    1745,  1749,  1750,  1751,  1756,  1757,  1758,  1759,  1765,  1766,
-    1768,  1773,  1774,  1779,  1780,  1781,  1782,  1783,  1798,  1799,
-    1804,  1805,  1811,  1813,  1816,  1818,  1820,  1843,  1844,  1846,
-    1848,  1853,  1854,  1856,  1861,  1866,  1867,  1873,  1872,  1876,
-    1880,  1882,  1884,  1890,  1891,  1896,  1901,  1903,  1908,  1910,
-    1911,  1913,  1918,  1920,  1922,  1927,  1929,  1934,  1939,  1947,
-    1953,  1952,  1966,  1967,  1972,  1973,  1977,  1982,  1987,  1995,
-    2000,  2011,  2012,  2017,  2018,  2024,  2025,  2029,  2030,  2031,
-    2034,  2033,  2044,  2053,  2059,  2065,  2074,  2080,  2086,  2092,
-    2098,  2106,  2112,  2120,  2126,  2135,  2136,  2137,  2141,  2145,
-    2147,  2152,  2153,  2157,  2158,  2163,  2169,  2170,  2173,  2175,
-    2176,  2180,  2181,  2182,  2183,  2217,  2219,  2220,  2222,  2227,
-    2232,  2237,  2239,  2241,  2246,  2248,  2250,  2252,  2257,  2259,
-    2268,  2270,  2271,  2276,  2278,  2280,  2285,  2287,  2289,  2294,
-    2296,  2298,  2307,  2308,  2309,  2313,  2315,  2317,  2322,  2324,
-    2326,  2331,  2333,  2335,  2350,  2352,  2353,  2355,  2360,  2361,
-    2366,  2368,  2370,  2375,  2377,  2379,  2381,  2386,  2388,  2390,
-    2400,  2402,  2403,  2405,  2410,  2412,  2414,  2419,  2421,  2423,
-    2425,  2430,  2432,  2434,  2465,  2467,  2468,  2470,  2475,  2480,
-    2488,  2490,  2492,  2497,  2499,  2504,  2506,  2520,  2521,  2523,
-    2528,  2530,  2532,  2534,  2536,  2541,  2542,  2544,  2546,  2551,
-    2553,  2555,  2561,  2563,  2565,  2569,  2571,  2573,  2575,  2589,
-    2590,  2592,  2597,  2599,  2601,  2603,  2605,  2610,  2611,  2613,
-    2615,  2620,  2622,  2624,  2630,  2631,  2633,  2642,  2645,  2647,
-    2650,  2652,  2654,  2667,  2668,  2670,  2675,  2677,  2679,  2681,
-    2683,  2688,  2689,  2691,  2693,  2698,  2700,  2708,  2709,  2710,
-    2715,  2716,  2720,  2722,  2724,  2726,  2728,  2730,  2737,  2739,
-    2741,  2743,  2745,  2748,  2750,  2752,  2754,  2756,  2761,  2763,
-    2765,  2770,  2796,  2797,  2799,  2803,  2804,  2808,  2810,  2812,
-    2814,  2816,  2818,  2825,  2827,  2829,  2831,  2833,  2835,  2840,
-    2847,  2849,  2867,  2869,  2874,  2875
+       0,   306,   306,   310,   317,   318,   319,   320,   321,   325,
+     326,   327,   331,   332,   336,   337,   341,   342,   346,   350,
+     351,   362,   364,   366,   367,   369,   374,   375,   381,   383,
+     385,   386,   387,   389,   390,   392,   394,   396,   405,   406,
+     412,   413,   417,   418,   422,   424,   426,   428,   430,   432,
+     434,   439,   441,   443,   447,   449,   453,   456,   458,   460,
+     465,   478,   480,   482,   484,   486,   488,   490,   492,   494,
+     496,   498,   505,   506,   512,   513,   514,   515,   519,   520,
+     527,   528,   530,   532,   537,   538,   540,   545,   546,   548,
+     553,   554,   556,   558,   560,   565,   566,   568,   573,   574,
+     579,   580,   585,   586,   591,   592,   597,   598,   603,   604,
+     607,   614,   619,   620,   628,   629,   633,   634,   635,   636,
+     637,   638,   639,   640,   641,   642,   643,   644,   654,   656,
+     661,   662,   667,   668,   674,   675,   681,   682,   683,   684,
+     685,   686,   687,   688,   689,   699,   706,   708,   718,   719,
+     724,   726,   732,   734,   738,   739,   744,   749,   752,   754,
+     756,   766,   768,   779,   780,   782,   786,   788,   792,   793,
+     798,   799,   803,   808,   809,   813,   815,   821,   822,   826,
+     828,   830,   832,   838,   839,   843,   845,   850,   852,   854,
+     859,   861,   866,   868,   872,   875,   879,   882,   886,   888,
+     890,   892,   897,   899,   901,   906,   908,   910,   912,   914,
+     919,   921,   923,   925,   930,   942,   943,   948,   950,   955,
+     959,   961,   963,   965,   967,   973,   974,   980,   981,   985,
+     986,   991,   993,   999,  1000,  1002,  1007,  1012,  1022,  1024,
+    1028,  1029,  1034,  1036,  1040,  1041,  1045,  1047,  1051,  1052,
+    1056,  1057,  1061,  1062,  1077,  1078,  1079,  1080,  1081,  1085,
+    1090,  1097,  1107,  1112,  1117,  1125,  1130,  1135,  1140,  1145,
+    1175,  1180,  1187,  1189,  1196,  1201,  1206,  1217,  1222,  1227,
+    1232,  1237,  1246,  1251,  1259,  1260,  1261,  1262,  1268,  1273,
+    1281,  1282,  1283,  1284,  1288,  1289,  1290,  1291,  1296,  1297,
+    1306,  1307,  1312,  1313,  1318,  1320,  1322,  1324,  1326,  1329,
+    1328,  1340,  1341,  1343,  1353,  1354,  1359,  1361,  1363,  1365,
+    1367,  1370,  1372,  1375,  1380,  1382,  1384,  1386,  1388,  1390,
+    1392,  1394,  1396,  1398,  1400,  1402,  1404,  1410,  1411,  1413,
+    1415,  1417,  1422,  1423,  1429,  1430,  1432,  1434,  1439,  1441,
+    1443,  1445,  1450,  1451,  1453,  1455,  1460,  1461,  1463,  1468,
+    1469,  1471,  1473,  1478,  1480,  1482,  1487,  1488,  1492,  1494,
+    1500,  1499,  1503,  1505,  1510,  1512,  1518,  1519,  1524,  1525,
+    1527,  1528,  1537,  1538,  1540,  1542,  1547,  1549,  1555,  1556,
+    1558,  1561,  1564,  1569,  1570,  1575,  1580,  1584,  1586,  1592,
+    1591,  1598,  1600,  1606,  1607,  1615,  1616,  1620,  1621,  1622,
+    1624,  1626,  1633,  1634,  1636,  1638,  1643,  1644,  1650,  1651,
+    1655,  1656,  1661,  1662,  1663,  1665,  1673,  1674,  1676,  1679,
+    1681,  1685,  1686,  1687,  1689,  1691,  1695,  1700,  1708,  1709,
+    1718,  1720,  1725,  1726,  1727,  1731,  1732,  1733,  1737,  1738,
+    1739,  1743,  1744,  1745,  1750,  1751,  1752,  1753,  1759,  1760,
+    1762,  1767,  1768,  1773,  1774,  1775,  1776,  1777,  1792,  1793,
+    1798,  1799,  1805,  1807,  1810,  1812,  1814,  1837,  1838,  1840,
+    1842,  1847,  1848,  1850,  1855,  1860,  1861,  1867,  1866,  1870,
+    1874,  1876,  1878,  1884,  1885,  1890,  1895,  1897,  1902,  1904,
+    1905,  1907,  1912,  1914,  1916,  1921,  1923,  1928,  1933,  1941,
+    1947,  1946,  1960,  1961,  1966,  1967,  1971,  1976,  1981,  1989,
+    1994,  2005,  2006,  2011,  2012,  2018,  2019,  2023,  2024,  2025,
+    2028,  2027,  2038,  2047,  2053,  2059,  2068,  2074,  2080,  2086,
+    2092,  2100,  2106,  2114,  2120,  2129,  2130,  2131,  2135,  2139,
+    2141,  2146,  2147,  2151,  2152,  2157,  2163,  2164,  2167,  2169,
+    2170,  2174,  2175,  2176,  2177,  2211,  2213,  2214,  2216,  2221,
+    2226,  2231,  2233,  2235,  2240,  2242,  2244,  2246,  2251,  2253,
+    2262,  2264,  2265,  2270,  2272,  2274,  2279,  2281,  2283,  2288,
+    2290,  2292,  2301,  2302,  2303,  2307,  2309,  2311,  2316,  2318,
+    2320,  2325,  2327,  2329,  2344,  2346,  2347,  2349,  2354,  2355,
+    2360,  2362,  2364,  2369,  2371,  2373,  2375,  2380,  2382,  2384,
+    2394,  2396,  2397,  2399,  2404,  2406,  2408,  2413,  2415,  2417,
+    2419,  2424,  2426,  2428,  2459,  2461,  2462,  2464,  2469,  2474,
+    2482,  2484,  2486,  2491,  2493,  2498,  2500,  2514,  2515,  2517,
+    2522,  2524,  2526,  2528,  2530,  2535,  2536,  2538,  2540,  2545,
+    2547,  2549,  2555,  2557,  2559,  2563,  2565,  2567,  2569,  2583,
+    2584,  2586,  2591,  2593,  2595,  2597,  2599,  2604,  2605,  2607,
+    2609,  2614,  2616,  2618,  2624,  2625,  2627,  2636,  2639,  2641,
+    2644,  2646,  2648,  2661,  2662,  2664,  2669,  2671,  2673,  2675,
+    2677,  2682,  2683,  2685,  2687,  2692,  2694,  2702,  2703,  2704,
+    2709,  2710,  2714,  2716,  2718,  2720,  2722,  2724,  2731,  2733,
+    2735,  2737,  2739,  2742,  2744,  2746,  2748,  2750,  2755,  2757,
+    2759,  2764,  2790,  2791,  2793,  2797,  2798,  2802,  2804,  2806,
+    2808,  2810,  2812,  2819,  2821,  2823,  2825,  2827,  2829,  2834,
+    2841,  2843,  2861,  2863,  2868,  2869
 };
 #endif
@@ -4851 +4851 @@
 
 /* Line 1806 of yacc.c  */
-#line 305 "parser.yy"
+#line 306 "parser.yy"
     { typedefTable.enterScope(); }
     break;
@@ -4858 +4858 @@
 
 /* Line 1806 of yacc.c  */
-#line 309 "parser.yy"
+#line 310 "parser.yy"
     { typedefTable.leaveScope(); }
     break;
@@ -4865 +4865 @@
 
 /* Line 1806 of yacc.c  */
-#line 316 "parser.yy"
+#line 317 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_constantInteger( *(yyvsp[(1) - (1)].tok) ) ); }
     break;
 
   case 5:
-
-/* Line 1806 of yacc.c  */
-#line 317 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
-    break;
-
-  case 6:
 
 /* Line 1806 of yacc.c  */
@@ -4883 +4876 @@
     break;
 
-  case 7:
+  case 6:
 
 /* Line 1806 of yacc.c  */
@@ -4890 +4883 @@
     break;
 
+  case 7:
+
+/* Line 1806 of yacc.c  */
+#line 320 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_constantFloat( *(yyvsp[(1) - (1)].tok) ) ); }
+    break;
+
   case 8:
 
 /* Line 1806 of yacc.c  */
-#line 320 "parser.yy"
+#line 321 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_constantChar( *(yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -4900 +4900 @@
 
 /* Line 1806 of yacc.c  */
-#line 345 "parser.yy"
+#line 346 "parser.yy"
     { (yyval.constant) = build_constantStr( *(yyvsp[(1) - (1)].str) ); }
     break;
@@ -4907 +4907 @@
 
 /* Line 1806 of yacc.c  */
-#line 349 "parser.yy"
+#line 350 "parser.yy"
     { (yyval.str) = (yyvsp[(1) - (1)].tok); }
     break;
@@ -4914 +4914 @@
 
 /* Line 1806 of yacc.c  */
-#line 351 "parser.yy"
+#line 352 "parser.yy"
     {
                         appendStr( (yyvsp[(1) - (2)].str), (yyvsp[(2) - (2)].tok) );                                            // append 2nd juxtaposed string to 1st
@@ -4925 +4925 @@
 
 /* Line 1806 of yacc.c  */
-#line 362 "parser.yy"
+#line 363 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -4932 +4932 @@
 
 /* Line 1806 of yacc.c  */
-#line 364 "parser.yy"
+#line 365 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
     break;
@@ -4939 +4939 @@
 
 /* Line 1806 of yacc.c  */
-#line 367 "parser.yy"
+#line 368 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (3)].en); }
     break;
@@ -4946 +4946 @@
 
 /* Line 1806 of yacc.c  */
-#line 369 "parser.yy"
+#line 370 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_valexpr( (yyvsp[(2) - (3)].sn) ) ); }
     break;
@@ -4953 +4953 @@
 
 /* Line 1806 of yacc.c  */
-#line 379 "parser.yy"
+#line 380 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Index, (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en) ) ); }
     break;
@@ -4960 +4960 @@
 
 /* Line 1806 of yacc.c  */
-#line 381 "parser.yy"
+#line 382 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_func( (yyvsp[(1) - (4)].en), (yyvsp[(3) - (4)].en) ) ); }
     break;
@@ -4967 +4967 @@
 
 /* Line 1806 of yacc.c  */
-#line 383 "parser.yy"
+#line 384 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
     break;
 
-  case 30:
-
-/* Line 1806 of yacc.c  */
-#line 385 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
-    break;
-
-  case 31:
-
-/* Line 1806 of yacc.c  */
-#line 387 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (2)].en), build_field_name_REALFRACTIONconstant( *(yyvsp[(2) - (2)].tok) ) ) ); }
-    break;
-
   case 32:
 
 /* Line 1806 of yacc.c  */
-#line 389 "parser.yy"
+#line 388 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), build_varref( (yyvsp[(3) - (3)].tok) ) ) ); }
     break;
 
-  case 33:
+  case 34:
 
 /* Line 1806 of yacc.c  */
 #line 391 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
-    break;
-
-  case 34:
+    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
+    break;
+
+  case 35:
 
 /* Line 1806 of yacc.c  */
 #line 393 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, (yyvsp[(1) - (2)].en) ) ); }
-    break;
-
-  case 35:
+    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
+    break;
+
+  case 36:
 
 /* Line 1806 of yacc.c  */
 #line 395 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::DecrPost, (yyvsp[(1) - (2)].en) ) ); }
-    break;
-
-  case 36:
+    { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
+    break;
+
+  case 37:
 
 /* Line 1806 of yacc.c  */
 #line 397 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_compoundLiteral( (yyvsp[(2) - (7)].decl), new InitializerNode( (yyvsp[(5) - (7)].in), true ) ) ); }
-    break;
-
-  case 37:
-
-/* Line 1806 of yacc.c  */
-#line 399 "parser.yy"
     {
                         Token fn;
@@ -5034 +5013 @@
 
 /* Line 1806 of yacc.c  */
-#line 409 "parser.yy"
+#line 407 "parser.yy"
     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
     break;
@@ -5041 +5020 @@
 
 /* Line 1806 of yacc.c  */
-#line 414 "parser.yy"
+#line 412 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -5048 +5027 @@
 
 /* Line 1806 of yacc.c  */
-#line 420 "parser.yy"
+#line 418 "parser.yy"
     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     break;
 
+  case 44:
+
+/* Line 1806 of yacc.c  */
+#line 423 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (1)].tok) ) ); }
+    break;
+
   case 45:
 
 /* Line 1806 of yacc.c  */
-#line 426 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *(yyvsp[(1) - (2)].tok) ) ), maybeMoveBuild<Expression>( (yyvsp[(2) - (2)].en) ) ) ); }
+#line 425 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(2) - (2)].en), build_varref( (yyvsp[(1) - (2)].tok) ) ) ); }
     break;
 
@@ -5062 +5048 @@
 
 /* Line 1806 of yacc.c  */
-#line 428 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *(yyvsp[(1) - (6)].tok) ) ), build_tuple( (yyvsp[(4) - (6)].en) ) ) ); }
+#line 427 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(4) - (6)].en), build_varref( (yyvsp[(1) - (6)].tok) ) ) ); }
     break;
 
@@ -5069 +5055 @@
 
 /* Line 1806 of yacc.c  */
-#line 430 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (3)].en), maybeMoveBuild<Expression>( (yyvsp[(3) - (3)].en) ) ) ); }
+#line 429 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
     break;
 
@@ -5076 +5062 @@
 
 /* Line 1806 of yacc.c  */
-#line 432 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
+#line 431 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_fieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
     break;
 
@@ -5083 +5069 @@
 
 /* Line 1806 of yacc.c  */
-#line 434 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (3)].en), maybeMoveBuild<Expression>( (yyvsp[(3) - (3)].en) ) ) ); }
+#line 433 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(3) - (3)].en), build_varref( (yyvsp[(1) - (3)].tok) ) ) ); }
     break;
 
@@ -5090 +5076 @@
 
 /* Line 1806 of yacc.c  */
-#line 436 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(1) - (7)].en), build_tuple( (yyvsp[(5) - (7)].en) ) ) ); }
+#line 435 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_pfieldSel( (yyvsp[(5) - (7)].en), build_varref( (yyvsp[(1) - (7)].tok) ) ) ); }
     break;
 
@@ -5097 +5083 @@
 
 /* Line 1806 of yacc.c  */
-#line 441 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *(yyvsp[(1) - (2)].tok) ), (yyvsp[(2) - (2)].en) ) ); }
+#line 440 "parser.yy"
+    { (yyval.tok) = (yyvsp[(1) - (2)].tok); }
     break;
 
@@ -5104 +5090 @@
 
 /* Line 1806 of yacc.c  */
-#line 443 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *(yyvsp[(1) - (2)].tok) ), (yyvsp[(2) - (2)].en) ) ); }
+#line 442 "parser.yy"
+    { (yyval.tok) = (yyvsp[(1) - (2)].tok); }
     break;
 
@@ -5111 +5097 @@
 
 /* Line 1806 of yacc.c  */
-#line 445 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_field_name_fraction_constants( build_varref( (yyvsp[(1) - (2)].tok) ), (yyvsp[(2) - (2)].en) ) ); }
-    break;
-
-  case 54:
-
-/* Line 1806 of yacc.c  */
-#line 450 "parser.yy"
-    { (yyval.en) = nullptr; }
-    break;
-
-  case 55:
-
-/* Line 1806 of yacc.c  */
-#line 452 "parser.yy"
-    {
-                        Expression * constant = build_field_name_REALFRACTIONconstant( *(yyvsp[(2) - (2)].tok) );
-                        (yyval.en) = (yyvsp[(1) - (2)].en) != nullptr ? new ExpressionNode( build_fieldSel( (yyvsp[(1) - (2)].en),  constant ) ) : new ExpressionNode( constant );
-                }
+#line 444 "parser.yy"
+    { (yyval.tok) = (yyvsp[(1) - (2)].tok); }
     break;
 
@@ -5135 +5104 @@
 
 /* Line 1806 of yacc.c  */
-#line 463 "parser.yy"
+#line 457 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
@@ -5142 +5111 @@
 
 /* Line 1806 of yacc.c  */
-#line 465 "parser.yy"
+#line 459 "parser.yy"
     { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
     break;
@@ -5149 +5118 @@
 
 /* Line 1806 of yacc.c  */
-#line 467 "parser.yy"
+#line 461 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en)->set_extension( true ); }
     break;
@@ -5156 +5125 @@
 
 /* Line 1806 of yacc.c  */
-#line 472 "parser.yy"
+#line 466 "parser.yy"
     {
                         switch ( (yyvsp[(1) - (2)].op) ) {
@@ -5174 +5143 @@
 
 /* Line 1806 of yacc.c  */
+#line 479 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
+    break;
+
+  case 62:
+
+/* Line 1806 of yacc.c  */
+#line 481 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
+    break;
+
+  case 63:
+
+/* Line 1806 of yacc.c  */
+#line 483 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
+    break;
+
+  case 64:
+
+/* Line 1806 of yacc.c  */
 #line 485 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_unary_val( (yyvsp[(1) - (2)].op), (yyvsp[(2) - (2)].en) ) ); }
-    break;
-
-  case 62:
+    { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
+    break;
+
+  case 65:
 
 /* Line 1806 of yacc.c  */
 #line 487 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Incr, (yyvsp[(2) - (2)].en) ) ); }
-    break;
-
-  case 63:
+    { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
+    break;
+
+  case 66:
 
 /* Line 1806 of yacc.c  */
 #line 489 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_unary_ptr( OperKinds::Decr, (yyvsp[(2) - (2)].en) ) ); }
-    break;
-
-  case 64:
+    { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
+    break;
+
+  case 67:
 
 /* Line 1806 of yacc.c  */
 #line 491 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_sizeOfexpr( (yyvsp[(2) - (2)].en) ) ); }
-    break;
-
-  case 65:
+    { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
+    break;
+
+  case 68:
 
 /* Line 1806 of yacc.c  */
 #line 493 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_sizeOftype( (yyvsp[(3) - (4)].decl) ) ); }
-    break;
-
-  case 66:
+    { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
+    break;
+
+  case 69:
 
 /* Line 1806 of yacc.c  */
 #line 495 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_alignOfexpr( (yyvsp[(2) - (2)].en) ) ); }
-    break;
-
-  case 67:
+    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
+    break;
+
+  case 70:
 
 /* Line 1806 of yacc.c  */
 #line 497 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_alignOftype( (yyvsp[(3) - (4)].decl) ) ); }
-    break;
-
-  case 68:
+    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
+    break;
+
+  case 71:
 
 /* Line 1806 of yacc.c  */
 #line 499 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_offsetOf( (yyvsp[(3) - (6)].decl), build_varref( (yyvsp[(5) - (6)].tok) ) ) ); }
-    break;
-
-  case 69:
-
-/* Line 1806 of yacc.c  */
-#line 501 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (1)].tok) ), nullptr ) ); }
-    break;
-
-  case 70:
-
-/* Line 1806 of yacc.c  */
-#line 503 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_attrexpr( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].en) ) ); }
-    break;
-
-  case 71:
+    { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
+    break;
+
+  case 72:
 
 /* Line 1806 of yacc.c  */
 #line 505 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_attrtype( build_varref( (yyvsp[(1) - (4)].tok) ), (yyvsp[(3) - (4)].decl) ) ); }
-    break;
-
-  case 72:
-
-/* Line 1806 of yacc.c  */
-#line 511 "parser.yy"
     { (yyval.op) = OperKinds::PointTo; }
     break;
@@ -5258 +5227 @@
 
 /* Line 1806 of yacc.c  */
+#line 506 "parser.yy"
+    { (yyval.op) = OperKinds::AddressOf; }
+    break;
+
+  case 74:
+
+/* Line 1806 of yacc.c  */
 #line 512 "parser.yy"
-    { (yyval.op) = OperKinds::AddressOf; }
-    break;
-
-  case 74:
-
-/* Line 1806 of yacc.c  */
-#line 518 "parser.yy"
     { (yyval.op) = OperKinds::UnPlus; }
     break;
@@ -5272 +5241 @@
 
 /* Line 1806 of yacc.c  */
-#line 519 "parser.yy"
+#line 513 "parser.yy"
     { (yyval.op) = OperKinds::UnMinus; }
     break;
@@ -5279 +5248 @@
 
 /* Line 1806 of yacc.c  */
-#line 520 "parser.yy"
+#line 514 "parser.yy"
     { (yyval.op) = OperKinds::Neg; }
     break;
@@ -5286 +5255 @@
 
 /* Line 1806 of yacc.c  */
+#line 515 "parser.yy"
+    { (yyval.op) = OperKinds::BitNeg; }
+    break;
+
+  case 79:
+
+/* Line 1806 of yacc.c  */
 #line 521 "parser.yy"
-    { (yyval.op) = OperKinds::BitNeg; }
-    break;
-
-  case 79:
-
-/* Line 1806 of yacc.c  */
-#line 527 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cast( (yyvsp[(2) - (4)].decl), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -5300 +5269 @@
 
 /* Line 1806 of yacc.c  */
-#line 535 "parser.yy"
+#line 529 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mul, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5307 +5276 @@
 
 /* Line 1806 of yacc.c  */
-#line 537 "parser.yy"
+#line 531 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Div, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5314 +5283 @@
 
 /* Line 1806 of yacc.c  */
+#line 533 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 85:
+
+/* Line 1806 of yacc.c  */
 #line 539 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Mod, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 85:
-
-/* Line 1806 of yacc.c  */
-#line 545 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Plus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5328 +5297 @@
 
 /* Line 1806 of yacc.c  */
+#line 541 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 88:
+
+/* Line 1806 of yacc.c  */
 #line 547 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Minus, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 88:
-
-/* Line 1806 of yacc.c  */
-#line 553 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5342 +5311 @@
 
 /* Line 1806 of yacc.c  */
+#line 549 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 91:
+
+/* Line 1806 of yacc.c  */
 #line 555 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::RShift, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 91:
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 92:
+
+/* Line 1806 of yacc.c  */
+#line 557 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 93:
+
+/* Line 1806 of yacc.c  */
+#line 559 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 94:
 
 /* Line 1806 of yacc.c  */
 #line 561 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 92:
-
-/* Line 1806 of yacc.c  */
-#line 563 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 93:
-
-/* Line 1806 of yacc.c  */
-#line 565 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::LEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 94:
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 96:
 
 /* Line 1806 of yacc.c  */
 #line 567 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::GEThan, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 96:
-
-/* Line 1806 of yacc.c  */
-#line 573 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Eq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5384 +5353 @@
 
 /* Line 1806 of yacc.c  */
+#line 569 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 99:
+
+/* Line 1806 of yacc.c  */
 #line 575 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Neq, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 99:
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 101:
 
 /* Line 1806 of yacc.c  */
 #line 581 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitAnd, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 101:
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 103:
 
 /* Line 1806 of yacc.c  */
 #line 587 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::Xor, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 103:
+    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
+    break;
+
+  case 105:
 
 /* Line 1806 of yacc.c  */
 #line 593 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_binary_val( OperKinds::BitOr, (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
-    break;
-
-  case 105:
+    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
+    break;
+
+  case 107:
 
 /* Line 1806 of yacc.c  */
 #line 599 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), true ) ); }
-    break;
-
-  case 107:
+    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
+    break;
+
+  case 109:
 
 /* Line 1806 of yacc.c  */
 #line 605 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_and_or( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en), false ) ); }
-    break;
-
-  case 109:
-
-/* Line 1806 of yacc.c  */
-#line 611 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (5)].en), (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].en) ) ); }
     break;
@@ -5433 +5402 @@
 
 /* Line 1806 of yacc.c  */
-#line 614 "parser.yy"
+#line 608 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_cond( (yyvsp[(1) - (4)].en), (yyvsp[(1) - (4)].en), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -5440 +5409 @@
 
 /* Line 1806 of yacc.c  */
-#line 627 "parser.yy"
+#line 621 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_binary_ptr( (yyvsp[(2) - (3)].op), (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5447 +5416 @@
 
 /* Line 1806 of yacc.c  */
+#line 628 "parser.yy"
+    { (yyval.en) = nullptr; }
+    break;
+
+  case 116:
+
+/* Line 1806 of yacc.c  */
+#line 633 "parser.yy"
+    { (yyval.op) = OperKinds::Assign; }
+    break;
+
+  case 117:
+
+/* Line 1806 of yacc.c  */
 #line 634 "parser.yy"
-    { (yyval.en) = nullptr; }
-    break;
-
-  case 116:
+    { (yyval.op) = OperKinds::AtAssn; }
+    break;
+
+  case 118:
+
+/* Line 1806 of yacc.c  */
+#line 635 "parser.yy"
+    { (yyval.op) = OperKinds::MulAssn; }
+    break;
+
+  case 119:
+
+/* Line 1806 of yacc.c  */
+#line 636 "parser.yy"
+    { (yyval.op) = OperKinds::DivAssn; }
+    break;
+
+  case 120:
+
+/* Line 1806 of yacc.c  */
+#line 637 "parser.yy"
+    { (yyval.op) = OperKinds::ModAssn; }
+    break;
+
+  case 121:
+
+/* Line 1806 of yacc.c  */
+#line 638 "parser.yy"
+    { (yyval.op) = OperKinds::PlusAssn; }
+    break;
+
+  case 122:
 
 /* Line 1806 of yacc.c  */
 #line 639 "parser.yy"
-    { (yyval.op) = OperKinds::Assign; }
-    break;
-
-  case 117:
+    { (yyval.op) = OperKinds::MinusAssn; }
+    break;
+
+  case 123:
 
 /* Line 1806 of yacc.c  */
 #line 640 "parser.yy"
-    { (yyval.op) = OperKinds::AtAssn; }
-    break;
-
-  case 118:
+    { (yyval.op) = OperKinds::LSAssn; }
+    break;
+
+  case 124:
 
 /* Line 1806 of yacc.c  */
 #line 641 "parser.yy"
-    { (yyval.op) = OperKinds::MulAssn; }
-    break;
-
-  case 119:
+    { (yyval.op) = OperKinds::RSAssn; }
+    break;
+
+  case 125:
 
 /* Line 1806 of yacc.c  */
 #line 642 "parser.yy"
-    { (yyval.op) = OperKinds::DivAssn; }
-    break;
-
-  case 120:
+    { (yyval.op) = OperKinds::AndAssn; }
+    break;
+
+  case 126:
 
 /* Line 1806 of yacc.c  */
 #line 643 "parser.yy"
-    { (yyval.op) = OperKinds::ModAssn; }
-    break;
-
-  case 121:
+    { (yyval.op) = OperKinds::ERAssn; }
+    break;
+
+  case 127:
 
 /* Line 1806 of yacc.c  */
 #line 644 "parser.yy"
-    { (yyval.op) = OperKinds::PlusAssn; }
-    break;
-
-  case 122:
-
-/* Line 1806 of yacc.c  */
-#line 645 "parser.yy"
-    { (yyval.op) = OperKinds::MinusAssn; }
-    break;
-
-  case 123:
-
-/* Line 1806 of yacc.c  */
-#line 646 "parser.yy"
-    { (yyval.op) = OperKinds::LSAssn; }
-    break;
-
-  case 124:
-
-/* Line 1806 of yacc.c  */
-#line 647 "parser.yy"
-    { (yyval.op) = OperKinds::RSAssn; }
-    break;
-
-  case 125:
-
-/* Line 1806 of yacc.c  */
-#line 648 "parser.yy"
-    { (yyval.op) = OperKinds::AndAssn; }
-    break;
-
-  case 126:
-
-/* Line 1806 of yacc.c  */
-#line 649 "parser.yy"
-    { (yyval.op) = OperKinds::ERAssn; }
-    break;
-
-  case 127:
-
-/* Line 1806 of yacc.c  */
-#line 650 "parser.yy"
     { (yyval.op) = OperKinds::OrAssn; }
     break;
@@ -5538 +5507 @@
 
 /* Line 1806 of yacc.c  */
-#line 661 "parser.yy"
+#line 655 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(new ExpressionNode( nullptr ) )->set_last( (yyvsp[(4) - (6)].en) ) ) ); }
     break;
@@ -5545 +5514 @@
 
 /* Line 1806 of yacc.c  */
+#line 657 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
+    break;
+
+  case 131:
+
+/* Line 1806 of yacc.c  */
 #line 663 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_tuple( (ExpressionNode *)(yyvsp[(3) - (7)].en)->set_last( (yyvsp[(5) - (7)].en) ) ) ); }
-    break;
-
-  case 131:
+    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
+    break;
+
+  case 133:
 
 /* Line 1806 of yacc.c  */
 #line 669 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
-    break;
-
-  case 133:
-
-/* Line 1806 of yacc.c  */
-#line 675 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_comma( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5566 +5535 @@
 
 /* Line 1806 of yacc.c  */
-#line 680 "parser.yy"
+#line 674 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -5573 +5542 @@
 
 /* Line 1806 of yacc.c  */
-#line 689 "parser.yy"
+#line 683 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (1)].sn); }
     break;
@@ -5580 +5549 @@
 
 /* Line 1806 of yacc.c  */
-#line 696 "parser.yy"
+#line 690 "parser.yy"
     {
                         Token fn;
@@ -5591 +5560 @@
 
 /* Line 1806 of yacc.c  */
-#line 706 "parser.yy"
+#line 700 "parser.yy"
     {
                         (yyval.sn) = (yyvsp[(4) - (4)].sn)->add_label( (yyvsp[(1) - (4)].tok) );
@@ -5600 +5569 @@
 
 /* Line 1806 of yacc.c  */
-#line 713 "parser.yy"
+#line 707 "parser.yy"
     { (yyval.sn) = new StatementNode( build_compound( (StatementNode *)0 ) ); }
     break;
@@ -5607 +5576 @@
 
 /* Line 1806 of yacc.c  */
+#line 714 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); }
+    break;
+
+  case 149:
+
+/* Line 1806 of yacc.c  */
 #line 720 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_compound( (yyvsp[(5) - (7)].sn) ) ); }
-    break;
-
-  case 149:
-
-/* Line 1806 of yacc.c  */
-#line 726 "parser.yy"
     { if ( (yyvsp[(1) - (3)].sn) != 0 ) { (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ); (yyval.sn) = (yyvsp[(1) - (3)].sn); } }
     break;
@@ -5621 +5590 @@
 
 /* Line 1806 of yacc.c  */
-#line 731 "parser.yy"
+#line 725 "parser.yy"
     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
     break;
@@ -5628 +5597 @@
 
 /* Line 1806 of yacc.c  */
-#line 733 "parser.yy"
+#line 727 "parser.yy"
     {   // mark all fields in list
                         for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
@@ -5639 +5608 @@
 
 /* Line 1806 of yacc.c  */
-#line 739 "parser.yy"
+#line 733 "parser.yy"
     { (yyval.sn) = new StatementNode( (yyvsp[(1) - (1)].decl) ); }
     break;
@@ -5646 +5615 @@
 
 /* Line 1806 of yacc.c  */
-#line 746 "parser.yy"
+#line 740 "parser.yy"
     { if ( (yyvsp[(1) - (2)].sn) != 0 ) { (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) ); (yyval.sn) = (yyvsp[(1) - (2)].sn); } }
     break;
@@ -5653 +5622 @@
 
 /* Line 1806 of yacc.c  */
+#line 745 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); }
+    break;
+
+  case 157:
+
+/* Line 1806 of yacc.c  */
 #line 751 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_expr( (yyvsp[(1) - (2)].en) ) ); }
-    break;
-
-  case 157:
+    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
+    break;
+
+  case 158:
+
+/* Line 1806 of yacc.c  */
+#line 753 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
+    break;
+
+  case 159:
+
+/* Line 1806 of yacc.c  */
+#line 755 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
+    break;
+
+  case 160:
 
 /* Line 1806 of yacc.c  */
 #line 757 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn), nullptr ) ); }
-    break;
-
-  case 158:
-
-/* Line 1806 of yacc.c  */
-#line 759 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_if( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].sn), (yyvsp[(7) - (7)].sn) ) ); }
-    break;
-
-  case 159:
-
-/* Line 1806 of yacc.c  */
-#line 761 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
-    break;
-
-  case 160:
-
-/* Line 1806 of yacc.c  */
-#line 763 "parser.yy"
     {
                         StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
@@ -5696 +5665 @@
 
 /* Line 1806 of yacc.c  */
-#line 773 "parser.yy"
+#line 767 "parser.yy"
     { (yyval.sn) = new StatementNode( build_switch( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
     break;
@@ -5703 +5672 @@
 
 /* Line 1806 of yacc.c  */
-#line 775 "parser.yy"
+#line 769 "parser.yy"
     {
                         StatementNode *sw = new StatementNode( build_switch( (yyvsp[(3) - (9)].en), (yyvsp[(8) - (9)].sn) ) );
@@ -5713 +5682 @@
 
 /* Line 1806 of yacc.c  */
-#line 785 "parser.yy"
+#line 779 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
@@ -5720 +5689 @@
 
 /* Line 1806 of yacc.c  */
-#line 787 "parser.yy"
+#line 781 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -5727 +5696 @@
 
 /* Line 1806 of yacc.c  */
+#line 786 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
+    break;
+
+  case 167:
+
+/* Line 1806 of yacc.c  */
+#line 788 "parser.yy"
+    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
+    break;
+
+  case 168:
+
+/* Line 1806 of yacc.c  */
 #line 792 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_case( (yyvsp[(1) - (1)].en) ) ); }
-    break;
-
-  case 167:
-
-/* Line 1806 of yacc.c  */
-#line 794 "parser.yy"
-    { (yyval.sn) = (StatementNode *)((yyvsp[(1) - (3)].sn)->set_last( new StatementNode( build_case( (yyvsp[(3) - (3)].en) ) ) ) ); }
-    break;
-
-  case 168:
-
-/* Line 1806 of yacc.c  */
-#line 798 "parser.yy"
     { (yyval.sn) = (yyvsp[(2) - (3)].sn); }
     break;
@@ -5748 +5717 @@
 
 /* Line 1806 of yacc.c  */
+#line 793 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_default() ); }
+    break;
+
+  case 171:
+
+/* Line 1806 of yacc.c  */
 #line 799 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_default() ); }
-    break;
-
-  case 171:
-
-/* Line 1806 of yacc.c  */
-#line 805 "parser.yy"
     { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (2)].sn)->set_last( (yyvsp[(2) - (2)].sn) )); }
     break;
@@ -5762 +5731 @@
 
 /* Line 1806 of yacc.c  */
-#line 809 "parser.yy"
+#line 803 "parser.yy"
     { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
     break;
@@ -5769 +5738 @@
 
 /* Line 1806 of yacc.c  */
+#line 808 "parser.yy"
+    { (yyval.sn) = 0; }
+    break;
+
+  case 175:
+
+/* Line 1806 of yacc.c  */
 #line 814 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
+    break;
+
+  case 176:
+
+/* Line 1806 of yacc.c  */
+#line 816 "parser.yy"
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); }
+    break;
+
+  case 177:
+
+/* Line 1806 of yacc.c  */
+#line 821 "parser.yy"
     { (yyval.sn) = 0; }
     break;
 
-  case 175:
-
-/* Line 1806 of yacc.c  */
-#line 820 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(2) - (2)].sn) ) ) ); }
-    break;
-
-  case 176:
-
-/* Line 1806 of yacc.c  */
-#line 822 "parser.yy"
-    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( new StatementNode( build_compound( (yyvsp[(3) - (3)].sn) ) ) ) ) ); }
-    break;
-
-  case 177:
+  case 179:
 
 /* Line 1806 of yacc.c  */
 #line 827 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
+    break;
+
+  case 180:
+
+/* Line 1806 of yacc.c  */
+#line 829 "parser.yy"
+    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); }
+    break;
+
+  case 181:
+
+/* Line 1806 of yacc.c  */
+#line 831 "parser.yy"
+    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
+    break;
+
+  case 182:
+
+/* Line 1806 of yacc.c  */
+#line 833 "parser.yy"
+    { (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) ) ) ) ) ) ); }
+    break;
+
+  case 183:
+
+/* Line 1806 of yacc.c  */
+#line 838 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
+    break;
+
+  case 185:
+
+/* Line 1806 of yacc.c  */
+#line 844 "parser.yy"
     { (yyval.sn) = 0; }
     break;
 
-  case 179:
-
-/* Line 1806 of yacc.c  */
-#line 833 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (2)].sn)->append_last_case( (yyvsp[(2) - (2)].sn) ); }
-    break;
-
-  case 180:
-
-/* Line 1806 of yacc.c  */
-#line 835 "parser.yy"
-    { (yyval.sn) = (yyvsp[(1) - (3)].sn)->append_last_case( new StatementNode( build_compound( (StatementNode *)(yyvsp[(2) - (3)].sn)->set_last( (yyvsp[(3) - (3)].sn) ) ) ) ); }
-    break;
-
-  case 181:
-
-/* Line 1806 of yacc.c  */
-#line 837 "parser.yy"
-    { (yyval.sn) = (StatementNode *)( (yyvsp[(1) - (3)].sn)->set_last( (yyvsp[(2) - (3)].sn)->append_last_case( (yyvsp[(3) - (3)].sn) ))); }
-    break;
-
-  case 182:
-
-/* Line 1806 of yacc.c  */
-#line 839 "parser.yy"
-    { (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) ) ) ) ) ) ); }
-    break;
-
-  case 183:
-
-/* Line 1806 of yacc.c  */
-#line 844 "parser.yy"
+  case 186:
+
+/* Line 1806 of yacc.c  */
+#line 846 "parser.yy"
+    { (yyval.sn) = 0; }
+    break;
+
+  case 187:
+
+/* Line 1806 of yacc.c  */
+#line 851 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
+    break;
+
+  case 188:
+
+/* Line 1806 of yacc.c  */
+#line 853 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); }
+    break;
+
+  case 189:
+
+/* Line 1806 of yacc.c  */
+#line 855 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
+    break;
+
+  case 190:
+
+/* Line 1806 of yacc.c  */
+#line 860 "parser.yy"
+    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
+    break;
+
+  case 191:
+
+/* Line 1806 of yacc.c  */
+#line 862 "parser.yy"
+    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
+    break;
+
+  case 192:
+
+/* Line 1806 of yacc.c  */
+#line 867 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
+    break;
+
+  case 193:
+
+/* Line 1806 of yacc.c  */
+#line 871 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
+    break;
+
+  case 194:
+
+/* Line 1806 of yacc.c  */
+#line 874 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
+    break;
+
+  case 195:
+
+/* Line 1806 of yacc.c  */
+#line 878 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
+    break;
+
+  case 196:
+
+/* Line 1806 of yacc.c  */
+#line 881 "parser.yy"
     { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
     break;
 
-  case 185:
-
-/* Line 1806 of yacc.c  */
-#line 850 "parser.yy"
-    { (yyval.sn) = 0; }
-    break;
-
-  case 186:
-
-/* Line 1806 of yacc.c  */
-#line 852 "parser.yy"
-    { (yyval.sn) = 0; }
-    break;
-
-  case 187:
-
-/* Line 1806 of yacc.c  */
-#line 857 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(3) - (5)].en), (yyvsp[(5) - (5)].sn) ) ); }
-    break;
-
-  case 188:
-
-/* Line 1806 of yacc.c  */
-#line 859 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_while( (yyvsp[(5) - (7)].en), (yyvsp[(2) - (7)].sn), true ) ); }
-    break;
-
-  case 189:
-
-/* Line 1806 of yacc.c  */
-#line 861 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_for( (yyvsp[(4) - (6)].fctl), (yyvsp[(6) - (6)].sn) ) ); }
-    break;
-
-  case 190:
-
-/* Line 1806 of yacc.c  */
-#line 866 "parser.yy"
-    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (6)].en), (yyvsp[(4) - (6)].en), (yyvsp[(6) - (6)].en) ); }
-    break;
-
-  case 191:
-
-/* Line 1806 of yacc.c  */
-#line 868 "parser.yy"
-    { (yyval.fctl) = new ForCtl( (yyvsp[(1) - (4)].decl), (yyvsp[(2) - (4)].en), (yyvsp[(4) - (4)].en) ); }
-    break;
-
-  case 192:
-
-/* Line 1806 of yacc.c  */
-#line 873 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Goto ) ); }
-    break;
-
-  case 193:
-
-/* Line 1806 of yacc.c  */
-#line 877 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_computedgoto( (yyvsp[(3) - (4)].en) ) ); }
-    break;
-
-  case 194:
-
-/* Line 1806 of yacc.c  */
-#line 880 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Continue ) ); }
-    break;
-
-  case 195:
-
-/* Line 1806 of yacc.c  */
-#line 884 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Continue ) ); }
-    break;
-
-  case 196:
+  case 197:
+
+/* Line 1806 of yacc.c  */
+#line 885 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); }
+    break;
+
+  case 198:
 
 /* Line 1806 of yacc.c  */
 #line 887 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_branch( BranchStmt::Break ) ); }
-    break;
-
-  case 197:
+    { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
+    break;
+
+  case 199:
+
+/* Line 1806 of yacc.c  */
+#line 889 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
+    break;
+
+  case 200:
 
 /* Line 1806 of yacc.c  */
 #line 891 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_branch( (yyvsp[(2) - (3)].tok), BranchStmt::Break ) ); }
-    break;
-
-  case 198:
+    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
+    break;
+
+  case 201:
 
 /* Line 1806 of yacc.c  */
 #line 893 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_return( (yyvsp[(2) - (3)].en) ) ); }
-    break;
-
-  case 199:
-
-/* Line 1806 of yacc.c  */
-#line 895 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
-    break;
-
-  case 200:
-
-/* Line 1806 of yacc.c  */
-#line 897 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (3)].en) ) ); }
-    break;
-
-  case 201:
-
-/* Line 1806 of yacc.c  */
-#line 899 "parser.yy"
     { (yyval.sn) = new StatementNode( build_throw( (yyvsp[(2) - (5)].en) ) ); }
     break;
@@ -5951 +5920 @@
 
 /* Line 1806 of yacc.c  */
-#line 904 "parser.yy"
+#line 898 "parser.yy"
     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), (yyvsp[(3) - (3)].sn), 0 ) ); }
     break;
@@ -5958 +5927 @@
 
 /* Line 1806 of yacc.c  */
-#line 906 "parser.yy"
+#line 900 "parser.yy"
     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (3)].sn), 0, (yyvsp[(3) - (3)].sn) ) ); }
     break;
@@ -5965 +5934 @@
 
 /* Line 1806 of yacc.c  */
-#line 908 "parser.yy"
+#line 902 "parser.yy"
     { (yyval.sn) = new StatementNode( build_try( (yyvsp[(2) - (4)].sn), (yyvsp[(3) - (4)].sn), (yyvsp[(4) - (4)].sn) ) ); }
     break;
@@ -5972 +5941 @@
 
 /* Line 1806 of yacc.c  */
+#line 909 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
+    break;
+
+  case 207:
+
+/* Line 1806 of yacc.c  */
+#line 911 "parser.yy"
+    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
+    break;
+
+  case 208:
+
+/* Line 1806 of yacc.c  */
+#line 913 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
+    break;
+
+  case 209:
+
+/* Line 1806 of yacc.c  */
 #line 915 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
-    break;
-
-  case 207:
-
-/* Line 1806 of yacc.c  */
-#line 917 "parser.yy"
     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
     break;
 
-  case 208:
-
-/* Line 1806 of yacc.c  */
-#line 919 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_catch( 0, (yyvsp[(5) - (5)].sn), true ) ); }
-    break;
-
-  case 209:
-
-/* Line 1806 of yacc.c  */
-#line 921 "parser.yy"
-    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (6)].sn)->set_last( new StatementNode( build_catch( 0, (yyvsp[(6) - (6)].sn), true ) ) ); }
-    break;
-
   case 210:
 
 /* Line 1806 of yacc.c  */
+#line 920 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
+    break;
+
+  case 211:
+
+/* Line 1806 of yacc.c  */
+#line 922 "parser.yy"
+    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
+    break;
+
+  case 212:
+
+/* Line 1806 of yacc.c  */
+#line 924 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
+    break;
+
+  case 213:
+
+/* Line 1806 of yacc.c  */
 #line 926 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
-    break;
-
-  case 211:
-
-/* Line 1806 of yacc.c  */
-#line 928 "parser.yy"
     { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
     break;
 
-  case 212:
-
-/* Line 1806 of yacc.c  */
-#line 930 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_catch( (yyvsp[(5) - (9)].decl), (yyvsp[(8) - (9)].sn) ) ); }
-    break;
-
-  case 213:
-
-/* Line 1806 of yacc.c  */
-#line 932 "parser.yy"
-    { (yyval.sn) = (StatementNode *)(yyvsp[(1) - (10)].sn)->set_last( new StatementNode( build_catch( (yyvsp[(6) - (10)].decl), (yyvsp[(9) - (10)].sn) ) ) ); }
-    break;
-
   case 214:
 
 /* Line 1806 of yacc.c  */
-#line 937 "parser.yy"
+#line 931 "parser.yy"
     {
                         (yyval.sn) = new StatementNode( build_finally( (yyvsp[(2) - (2)].sn) ) );
@@ -6037 +6006 @@
 
 /* Line 1806 of yacc.c  */
-#line 950 "parser.yy"
+#line 944 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6047 +6016 @@
 
 /* Line 1806 of yacc.c  */
-#line 955 "parser.yy"
+#line 949 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -6054 +6023 @@
 
 /* Line 1806 of yacc.c  */
-#line 957 "parser.yy"
+#line 951 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6064 +6033 @@
 
 /* Line 1806 of yacc.c  */
+#line 960 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); }
+    break;
+
+  case 221:
+
+/* Line 1806 of yacc.c  */
+#line 962 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); }
+    break;
+
+  case 222:
+
+/* Line 1806 of yacc.c  */
+#line 964 "parser.yy"
+    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); }
+    break;
+
+  case 223:
+
+/* Line 1806 of yacc.c  */
 #line 966 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (6)].flag), (yyvsp[(4) - (6)].constant), 0 ) ); }
-    break;
-
-  case 221:
+    { (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) ) ); }
+    break;
+
+  case 224:
 
 /* Line 1806 of yacc.c  */
 #line 968 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (8)].flag), (yyvsp[(4) - (8)].constant), (yyvsp[(6) - (8)].en) ) ); }
-    break;
-
-  case 222:
-
-/* Line 1806 of yacc.c  */
-#line 970 "parser.yy"
-    { (yyval.sn) = new StatementNode( build_asmstmt( (yyvsp[(2) - (10)].flag), (yyvsp[(4) - (10)].constant), (yyvsp[(6) - (10)].en), (yyvsp[(8) - (10)].en) ) ); }
-    break;
-
-  case 223:
-
-/* Line 1806 of yacc.c  */
-#line 972 "parser.yy"
-    { (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) ) ); }
-    break;
-
-  case 224:
-
-/* Line 1806 of yacc.c  */
-#line 974 "parser.yy"
     { (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) ) ); }
     break;
@@ -6099 +6068 @@
 
 /* Line 1806 of yacc.c  */
-#line 979 "parser.yy"
+#line 973 "parser.yy"
     { (yyval.flag) = false; }
     break;
@@ -6106 +6075 @@
 
 /* Line 1806 of yacc.c  */
-#line 981 "parser.yy"
+#line 975 "parser.yy"
     { (yyval.flag) = true; }
     break;
@@ -6113 +6082 @@
 
 /* Line 1806 of yacc.c  */
-#line 986 "parser.yy"
+#line 980 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -6120 +6089 @@
 
 /* Line 1806 of yacc.c  */
-#line 993 "parser.yy"
+#line 987 "parser.yy"
     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) ); }
     break;
@@ -6127 +6096 @@
 
 /* Line 1806 of yacc.c  */
-#line 998 "parser.yy"
+#line 992 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_asmexpr( 0, (yyvsp[(1) - (4)].constant), (yyvsp[(3) - (4)].en) ) ); }
     break;
@@ -6134 +6103 @@
 
 /* Line 1806 of yacc.c  */
-#line 1000 "parser.yy"
+#line 994 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_asmexpr( (yyvsp[(2) - (7)].en), (yyvsp[(4) - (7)].constant), (yyvsp[(6) - (7)].en) ) ); }
     break;
@@ -6141 +6110 @@
 
 /* Line 1806 of yacc.c  */
-#line 1005 "parser.yy"
+#line 999 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -6148 +6117 @@
 
 /* Line 1806 of yacc.c  */
-#line 1007 "parser.yy"
+#line 1001 "parser.yy"
     { (yyval.en) = new ExpressionNode( (yyvsp[(1) - (1)].constant) ); }
     break;
@@ -6155 +6124 @@
 
 /* Line 1806 of yacc.c  */
-#line 1009 "parser.yy"
+#line 1003 "parser.yy"
     { (yyval.en) = (ExpressionNode *)(yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( (yyvsp[(3) - (3)].constant) ) ); }
     break;
@@ -6162 +6131 @@
 
 /* Line 1806 of yacc.c  */
-#line 1014 "parser.yy"
+#line 1008 "parser.yy"
     {
                         (yyval.label) = new LabelNode(); (yyval.label)->labels.push_back( *(yyvsp[(1) - (1)].tok) );
@@ -6172 +6141 @@
 
 /* Line 1806 of yacc.c  */
-#line 1019 "parser.yy"
+#line 1013 "parser.yy"
     {
                         (yyval.label) = (yyvsp[(1) - (3)].label); (yyvsp[(1) - (3)].label)->labels.push_back( *(yyvsp[(3) - (3)].tok) );
@@ -6182 +6151 @@
 
 /* Line 1806 of yacc.c  */
-#line 1029 "parser.yy"
+#line 1023 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -6189 +6158 @@
 
 /* Line 1806 of yacc.c  */
-#line 1036 "parser.yy"
+#line 1030 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6196 +6165 @@
 
 /* Line 1806 of yacc.c  */
-#line 1041 "parser.yy"
+#line 1035 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -6203 +6172 @@
 
 /* Line 1806 of yacc.c  */
-#line 1048 "parser.yy"
+#line 1042 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6210 +6179 @@
 
 /* Line 1806 of yacc.c  */
-#line 1062 "parser.yy"
+#line 1056 "parser.yy"
     {}
     break;
@@ -6217 +6186 @@
 
 /* Line 1806 of yacc.c  */
-#line 1063 "parser.yy"
+#line 1057 "parser.yy"
     {}
     break;
@@ -6224 +6193 @@
 
 /* Line 1806 of yacc.c  */
-#line 1092 "parser.yy"
+#line 1086 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6234 +6203 @@
 
 /* Line 1806 of yacc.c  */
-#line 1099 "parser.yy"
+#line 1093 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6244 +6213 @@
 
 /* Line 1806 of yacc.c  */
-#line 1104 "parser.yy"
+#line 1098 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (6)].tok), TypedefTable::ID );
@@ -6254 +6223 @@
 
 /* Line 1806 of yacc.c  */
-#line 1114 "parser.yy"
+#line 1108 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
@@ -6264 +6233 @@
 
 /* Line 1806 of yacc.c  */
-#line 1119 "parser.yy"
+#line 1113 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(2) - (3)].tok) );
@@ -6274 +6243 @@
 
 /* Line 1806 of yacc.c  */
-#line 1124 "parser.yy"
+#line 1118 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(3) - (4)].tok) );
@@ -6284 +6253 @@
 
 /* Line 1806 of yacc.c  */
-#line 1132 "parser.yy"
+#line 1126 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6294 +6263 @@
 
 /* Line 1806 of yacc.c  */
-#line 1137 "parser.yy"
+#line 1131 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6304 +6273 @@
 
 /* Line 1806 of yacc.c  */
-#line 1142 "parser.yy"
+#line 1136 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6314 +6283 @@
 
 /* Line 1806 of yacc.c  */
-#line 1147 "parser.yy"
+#line 1141 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6324 +6293 @@
 
 /* Line 1806 of yacc.c  */
-#line 1152 "parser.yy"
+#line 1146 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
@@ -6334 +6303 @@
 
 /* Line 1806 of yacc.c  */
-#line 1183 "parser.yy"
+#line 1177 "parser.yy"
     {
                         (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
@@ -6343 +6312 @@
 
 /* Line 1806 of yacc.c  */
-#line 1187 "parser.yy"
+#line 1181 "parser.yy"
     {
                         (yyval.decl) = DeclarationNode::newFunction( (yyvsp[(2) - (7)].tok), (yyvsp[(1) - (7)].decl), (yyvsp[(5) - (7)].decl), 0, true );
@@ -6352 +6321 @@
 
 /* Line 1806 of yacc.c  */
-#line 1194 "parser.yy"
+#line 1188 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     break;
@@ -6359 +6328 @@
 
 /* Line 1806 of yacc.c  */
-#line 1198 "parser.yy"
+#line 1192 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (9)].decl)->appendList( (yyvsp[(7) - (9)].decl) ) ); }
     break;
@@ -6366 +6335 @@
 
 /* Line 1806 of yacc.c  */
-#line 1203 "parser.yy"
+#line 1197 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6376 +6345 @@
 
 /* Line 1806 of yacc.c  */
-#line 1208 "parser.yy"
+#line 1202 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6386 +6355 @@
 
 /* Line 1806 of yacc.c  */
-#line 1213 "parser.yy"
+#line 1207 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (5)].tok), TypedefTable::TD );
@@ -6396 +6365 @@
 
 /* Line 1806 of yacc.c  */
-#line 1224 "parser.yy"
+#line 1218 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6406 +6375 @@
 
 /* Line 1806 of yacc.c  */
-#line 1229 "parser.yy"
+#line 1223 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6416 +6385 @@
 
 /* Line 1806 of yacc.c  */
-#line 1234 "parser.yy"
+#line 1228 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6426 +6395 @@
 
 /* Line 1806 of yacc.c  */
-#line 1239 "parser.yy"
+#line 1233 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6436 +6405 @@
 
 /* Line 1806 of yacc.c  */
-#line 1244 "parser.yy"
+#line 1238 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::TD );
@@ -6446 +6415 @@
 
 /* Line 1806 of yacc.c  */
-#line 1253 "parser.yy"
+#line 1247 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(2) - (4)].tok), TypedefTable::TD );
@@ -6456 +6425 @@
 
 /* Line 1806 of yacc.c  */
-#line 1258 "parser.yy"
+#line 1252 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(5) - (7)].tok), TypedefTable::TD );
@@ -6466 +6435 @@
 
 /* Line 1806 of yacc.c  */
-#line 1275 "parser.yy"
+#line 1269 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6476 +6445 @@
 
 /* Line 1806 of yacc.c  */
-#line 1280 "parser.yy"
+#line 1274 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -6486 +6455 @@
 
 /* Line 1806 of yacc.c  */
-#line 1302 "parser.yy"
+#line 1296 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -6493 +6462 @@
 
 /* Line 1806 of yacc.c  */
-#line 1314 "parser.yy"
+#line 1308 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6500 +6469 @@
 
 /* Line 1806 of yacc.c  */
+#line 1319 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
+    break;
+
+  case 305:
+
+/* Line 1806 of yacc.c  */
+#line 1321 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
+    break;
+
+  case 306:
+
+/* Line 1806 of yacc.c  */
+#line 1323 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
+    break;
+
+  case 307:
+
+/* Line 1806 of yacc.c  */
 #line 1325 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Const ); }
-    break;
-
-  case 305:
+    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
+    break;
+
+  case 308:
 
 /* Line 1806 of yacc.c  */
 #line 1327 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
-    break;
-
-  case 306:
+    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
+    break;
+
+  case 309:
 
 /* Line 1806 of yacc.c  */
 #line 1329 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
-    break;
-
-  case 307:
-
-/* Line 1806 of yacc.c  */
-#line 1331 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
-    break;
-
-  case 308:
-
-/* Line 1806 of yacc.c  */
-#line 1333 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
-    break;
-
-  case 309:
-
-/* Line 1806 of yacc.c  */
-#line 1335 "parser.yy"
     {
                         typedefTable.enterScope();
@@ -6544 +6513 @@
 
 /* Line 1806 of yacc.c  */
-#line 1339 "parser.yy"
+#line 1333 "parser.yy"
     {
                         typedefTable.leaveScope();
@@ -6554 +6523 @@
 
 /* Line 1806 of yacc.c  */
-#line 1348 "parser.yy"
+#line 1342 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6561 +6530 @@
 
 /* Line 1806 of yacc.c  */
-#line 1350 "parser.yy"
+#line 1344 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -6568 +6537 @@
 
 /* Line 1806 of yacc.c  */
-#line 1361 "parser.yy"
+#line 1355 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -6575 +6544 @@
 
 /* Line 1806 of yacc.c  */
+#line 1360 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
+    break;
+
+  case 317:
+
+/* Line 1806 of yacc.c  */
+#line 1362 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
+    break;
+
+  case 318:
+
+/* Line 1806 of yacc.c  */
+#line 1364 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
+    break;
+
+  case 319:
+
+/* Line 1806 of yacc.c  */
 #line 1366 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
-    break;
-
-  case 317:
-
-/* Line 1806 of yacc.c  */
-#line 1368 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
-    break;
-
-  case 318:
-
-/* Line 1806 of yacc.c  */
-#line 1370 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
-    break;
-
-  case 319:
-
-/* Line 1806 of yacc.c  */
-#line 1372 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
     break;
@@ -6603 +6572 @@
 
 /* Line 1806 of yacc.c  */
-#line 1375 "parser.yy"
+#line 1369 "parser.yy"
     { (yyval.decl) = new DeclarationNode; (yyval.decl)->isInline = true; }
     break;
@@ -6610 +6579 @@
 
 /* Line 1806 of yacc.c  */
-#line 1377 "parser.yy"
+#line 1371 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
     break;
@@ -6617 +6586 @@
 
 /* Line 1806 of yacc.c  */
-#line 1380 "parser.yy"
+#line 1374 "parser.yy"
     { (yyval.decl) = new DeclarationNode; (yyval.decl)->isNoreturn = true; }
     break;
@@ -6624 +6593 @@
 
 /* Line 1806 of yacc.c  */
-#line 1382 "parser.yy"
+#line 1376 "parser.yy"
     { (yyval.decl) = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
     break;
@@ -6631 +6600 @@
 
 /* Line 1806 of yacc.c  */
+#line 1381 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
+    break;
+
+  case 325:
+
+/* Line 1806 of yacc.c  */
+#line 1383 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
+    break;
+
+  case 326:
+
+/* Line 1806 of yacc.c  */
+#line 1385 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
+    break;
+
+  case 327:
+
+/* Line 1806 of yacc.c  */
 #line 1387 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Char ); }
-    break;
-
-  case 325:
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
+    break;
+
+  case 328:
 
 /* Line 1806 of yacc.c  */
 #line 1389 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Double ); }
-    break;
-
-  case 326:
+    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
+    break;
+
+  case 329:
 
 /* Line 1806 of yacc.c  */
 #line 1391 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Float ); }
-    break;
-
-  case 327:
+    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
+    break;
+
+  case 330:
 
 /* Line 1806 of yacc.c  */
 #line 1393 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Int ); }
-    break;
-
-  case 328:
+    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
+    break;
+
+  case 331:
 
 /* Line 1806 of yacc.c  */
 #line 1395 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Long ); }
-    break;
-
-  case 329:
+    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
+    break;
+
+  case 332:
 
 /* Line 1806 of yacc.c  */
 #line 1397 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newLength( DeclarationNode::Short ); }
-    break;
-
-  case 330:
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
+    break;
+
+  case 333:
 
 /* Line 1806 of yacc.c  */
 #line 1399 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Signed ); }
-    break;
-
-  case 331:
+    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
+    break;
+
+  case 334:
 
 /* Line 1806 of yacc.c  */
 #line 1401 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newSignedNess( DeclarationNode::Unsigned ); }
-    break;
-
-  case 332:
+    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
+    break;
+
+  case 335:
 
 /* Line 1806 of yacc.c  */
 #line 1403 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Void ); }
-    break;
-
-  case 333:
+    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
+    break;
+
+  case 336:
 
 /* Line 1806 of yacc.c  */
 #line 1405 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBasicType( DeclarationNode::Bool ); }
-    break;
-
-  case 334:
-
-/* Line 1806 of yacc.c  */
-#line 1407 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Complex ); }
-    break;
-
-  case 335:
-
-/* Line 1806 of yacc.c  */
-#line 1409 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newComplexType( DeclarationNode::Imaginary ); }
-    break;
-
-  case 336:
-
-/* Line 1806 of yacc.c  */
-#line 1411 "parser.yy"
     { (yyval.decl) = DeclarationNode::newBuiltinType( DeclarationNode::Valist ); }
     break;
@@ -6722 +6691 @@
 
 /* Line 1806 of yacc.c  */
+#line 1412 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 339:
+
+/* Line 1806 of yacc.c  */
+#line 1414 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 340:
+
+/* Line 1806 of yacc.c  */
+#line 1416 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
+    break;
+
+  case 341:
+
+/* Line 1806 of yacc.c  */
 #line 1418 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
+    break;
+
+  case 343:
+
+/* Line 1806 of yacc.c  */
+#line 1424 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
+    break;
+
+  case 345:
+
+/* Line 1806 of yacc.c  */
+#line 1431 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
 
-  case 339:
-
-/* Line 1806 of yacc.c  */
-#line 1420 "parser.yy"
+  case 346:
+
+/* Line 1806 of yacc.c  */
+#line 1433 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 340:
-
-/* Line 1806 of yacc.c  */
-#line 1422 "parser.yy"
+  case 347:
+
+/* Line 1806 of yacc.c  */
+#line 1435 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 348:
+
+/* Line 1806 of yacc.c  */
+#line 1440 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
+    break;
+
+  case 349:
+
+/* Line 1806 of yacc.c  */
+#line 1442 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
+    break;
+
+  case 350:
+
+/* Line 1806 of yacc.c  */
+#line 1444 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
+    break;
+
+  case 351:
+
+/* Line 1806 of yacc.c  */
+#line 1446 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
+    break;
+
+  case 353:
+
+/* Line 1806 of yacc.c  */
+#line 1452 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 354:
+
+/* Line 1806 of yacc.c  */
+#line 1454 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 355:
+
+/* Line 1806 of yacc.c  */
+#line 1456 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
 
-  case 341:
-
-/* Line 1806 of yacc.c  */
-#line 1424 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addType( (yyvsp[(1) - (3)].decl) ); }
-    break;
-
-  case 343:
-
-/* Line 1806 of yacc.c  */
-#line 1430 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 345:
-
-/* Line 1806 of yacc.c  */
-#line 1437 "parser.yy"
+  case 357:
+
+/* Line 1806 of yacc.c  */
+#line 1462 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
 
-  case 346:
-
-/* Line 1806 of yacc.c  */
-#line 1439 "parser.yy"
+  case 358:
+
+/* Line 1806 of yacc.c  */
+#line 1464 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 347:
-
-/* Line 1806 of yacc.c  */
-#line 1441 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addType( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 348:
-
-/* Line 1806 of yacc.c  */
-#line 1446 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (4)].decl); }
-    break;
-
-  case 349:
-
-/* Line 1806 of yacc.c  */
-#line 1448 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newTypeof( (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 350:
-
-/* Line 1806 of yacc.c  */
-#line 1450 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].decl) ); }
-    break;
-
-  case 351:
-
-/* Line 1806 of yacc.c  */
-#line 1452 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAttr( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 353:
-
-/* Line 1806 of yacc.c  */
-#line 1458 "parser.yy"
+  case 360:
+
+/* Line 1806 of yacc.c  */
+#line 1470 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
 
-  case 354:
-
-/* Line 1806 of yacc.c  */
-#line 1460 "parser.yy"
+  case 361:
+
+/* Line 1806 of yacc.c  */
+#line 1472 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 355:
-
-/* Line 1806 of yacc.c  */
-#line 1462 "parser.yy"
+  case 362:
+
+/* Line 1806 of yacc.c  */
+#line 1474 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
     break;
 
-  case 357:
-
-/* Line 1806 of yacc.c  */
-#line 1468 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 358:
-
-/* Line 1806 of yacc.c  */
-#line 1470 "parser.yy"
+  case 363:
+
+/* Line 1806 of yacc.c  */
+#line 1479 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
+    break;
+
+  case 364:
+
+/* Line 1806 of yacc.c  */
+#line 1481 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 365:
+
+/* Line 1806 of yacc.c  */
+#line 1483 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 360:
-
-/* Line 1806 of yacc.c  */
-#line 1476 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 361:
-
-/* Line 1806 of yacc.c  */
-#line 1478 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 362:
-
-/* Line 1806 of yacc.c  */
-#line 1480 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 363:
-
-/* Line 1806 of yacc.c  */
-#line 1485 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(1) - (1)].tok) ); }
-    break;
-
-  case 364:
-
-/* Line 1806 of yacc.c  */
-#line 1487 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypedef( (yyvsp[(2) - (2)].tok) )->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 365:
-
-/* Line 1806 of yacc.c  */
-#line 1489 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
   case 368:
 
 /* Line 1806 of yacc.c  */
-#line 1499 "parser.yy"
+#line 1493 "parser.yy"
     { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (4)].aggKey), nullptr, nullptr, (yyvsp[(3) - (4)].decl), true ); }
     break;
@@ -6890 +6859 @@
 
 /* Line 1806 of yacc.c  */
-#line 1501 "parser.yy"
+#line 1495 "parser.yy"
     {
                         typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
@@ -6900 +6869 @@
 
 /* Line 1806 of yacc.c  */
+#line 1500 "parser.yy"
+    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
+    break;
+
+  case 371:
+
+/* Line 1806 of yacc.c  */
+#line 1502 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); }
+    break;
+
+  case 372:
+
+/* Line 1806 of yacc.c  */
+#line 1504 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
+    break;
+
+  case 373:
+
+/* Line 1806 of yacc.c  */
 #line 1506 "parser.yy"
-    { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
-    break;
-
-  case 371:
-
-/* Line 1806 of yacc.c  */
-#line 1508 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (6)].aggKey), (yyvsp[(2) - (6)].tok), nullptr, (yyvsp[(5) - (6)].decl), true ); }
-    break;
-
-  case 372:
-
-/* Line 1806 of yacc.c  */
-#line 1510 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newAggregate( (yyvsp[(1) - (7)].aggKey), nullptr, (yyvsp[(3) - (7)].en), (yyvsp[(6) - (7)].decl), false ); }
-    break;
-
-  case 373:
-
-/* Line 1806 of yacc.c  */
-#line 1512 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
     break;
@@ -6928 +6897 @@
 
 /* Line 1806 of yacc.c  */
-#line 1517 "parser.yy"
+#line 1511 "parser.yy"
     { (yyval.aggKey) = DeclarationNode::Struct; }
     break;
@@ -6935 +6904 @@
 
 /* Line 1806 of yacc.c  */
-#line 1519 "parser.yy"
+#line 1513 "parser.yy"
     { (yyval.aggKey) = DeclarationNode::Union; }
     break;
@@ -6942 +6911 @@
 
 /* Line 1806 of yacc.c  */
-#line 1524 "parser.yy"
+#line 1518 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -6949 +6918 @@
 
 /* Line 1806 of yacc.c  */
+#line 1520 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
+    break;
+
+  case 379:
+
+/* Line 1806 of yacc.c  */
 #line 1526 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
-    break;
-
-  case 379:
-
-/* Line 1806 of yacc.c  */
-#line 1532 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl)->set_extension( true ); }
     break;
@@ -6963 +6932 @@
 
 /* Line 1806 of yacc.c  */
-#line 1535 "parser.yy"
+#line 1529 "parser.yy"
     {   // mark all fields in list
                         for ( DeclarationNode *iter = (yyvsp[(2) - (3)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
@@ -6974 +6943 @@
 
 /* Line 1806 of yacc.c  */
-#line 1545 "parser.yy"
+#line 1539 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addName( (yyvsp[(2) - (2)].tok) ); }
     break;
@@ -6981 +6950 @@
 
 /* Line 1806 of yacc.c  */
-#line 1547 "parser.yy"
+#line 1541 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(1) - (3)].decl)->cloneType( (yyvsp[(3) - (3)].tok) ) ); }
     break;
@@ -6988 +6957 @@
 
 /* Line 1806 of yacc.c  */
-#line 1549 "parser.yy"
+#line 1543 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(1) - (2)].decl)->cloneType( 0 ) ); }
     break;
@@ -6995 +6964 @@
 
 /* Line 1806 of yacc.c  */
-#line 1554 "parser.yy"
+#line 1548 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7002 +6971 @@
 
 /* Line 1806 of yacc.c  */
-#line 1556 "parser.yy"
+#line 1550 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(1) - (4)].decl)->cloneBaseType( (yyvsp[(4) - (4)].decl) ) ); }
     break;
@@ -7009 +6978 @@
 
 /* Line 1806 of yacc.c  */
-#line 1561 "parser.yy"
+#line 1555 "parser.yy"
     { (yyval.decl) = DeclarationNode::newName( 0 ); /* XXX */ }
     break;
@@ -7016 +6985 @@
 
 /* Line 1806 of yacc.c  */
+#line 1557 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
+    break;
+
+  case 390:
+
+/* Line 1806 of yacc.c  */
+#line 1560 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
+    break;
+
+  case 391:
+
+/* Line 1806 of yacc.c  */
 #line 1563 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newBitfield( (yyvsp[(1) - (1)].en) ); }
-    break;
-
-  case 390:
-
-/* Line 1806 of yacc.c  */
-#line 1566 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
     break;
 
-  case 391:
+  case 393:
 
 /* Line 1806 of yacc.c  */
 #line 1569 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addBitfield( (yyvsp[(2) - (2)].en) ); }
-    break;
-
-  case 393:
-
-/* Line 1806 of yacc.c  */
-#line 1575 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -7044 +7013 @@
 
 /* Line 1806 of yacc.c  */
-#line 1577 "parser.yy"
+#line 1571 "parser.yy"
     { (yyval.en) = (yyvsp[(1) - (1)].en); }
     break;
@@ -7051 +7020 @@
 
 /* Line 1806 of yacc.c  */
-#line 1582 "parser.yy"
+#line 1576 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -7058 +7027 @@
 
 /* Line 1806 of yacc.c  */
-#line 1591 "parser.yy"
+#line 1585 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnum( nullptr, (yyvsp[(3) - (5)].decl) ); }
     break;
@@ -7065 +7034 @@
 
 /* Line 1806 of yacc.c  */
-#line 1593 "parser.yy"
+#line 1587 "parser.yy"
     {
                         typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) );
@@ -7075 +7044 @@
 
 /* Line 1806 of yacc.c  */
-#line 1598 "parser.yy"
+#line 1592 "parser.yy"
     { typedefTable.makeTypedef( *(yyvsp[(2) - (2)].tok) ); }
     break;
@@ -7082 +7051 @@
 
 /* Line 1806 of yacc.c  */
-#line 1600 "parser.yy"
+#line 1594 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnum( (yyvsp[(2) - (7)].tok), (yyvsp[(5) - (7)].decl) ); }
     break;
@@ -7089 +7058 @@
 
 /* Line 1806 of yacc.c  */
-#line 1605 "parser.yy"
+#line 1599 "parser.yy"
     { (yyval.decl) = DeclarationNode::newEnumConstant( (yyvsp[(1) - (2)].tok), (yyvsp[(2) - (2)].en) ); }
     break;
@@ -7096 +7065 @@
 
 /* Line 1806 of yacc.c  */
-#line 1607 "parser.yy"
+#line 1601 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( DeclarationNode::newEnumConstant( (yyvsp[(3) - (4)].tok), (yyvsp[(4) - (4)].en) ) ); }
     break;
@@ -7103 +7072 @@
 
 /* Line 1806 of yacc.c  */
-#line 1612 "parser.yy"
+#line 1606 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -7110 +7079 @@
 
 /* Line 1806 of yacc.c  */
-#line 1614 "parser.yy"
+#line 1608 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -7117 +7086 @@
 
 /* Line 1806 of yacc.c  */
-#line 1621 "parser.yy"
+#line 1615 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7124 +7093 @@
 
 /* Line 1806 of yacc.c  */
-#line 1629 "parser.yy"
+#line 1623 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7131 +7100 @@
 
 /* Line 1806 of yacc.c  */
-#line 1631 "parser.yy"
+#line 1625 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7138 +7107 @@
 
 /* Line 1806 of yacc.c  */
-#line 1633 "parser.yy"
+#line 1627 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7145 +7114 @@
 
 /* Line 1806 of yacc.c  */
-#line 1641 "parser.yy"
+#line 1635 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7152 +7121 @@
 
 /* Line 1806 of yacc.c  */
-#line 1643 "parser.yy"
+#line 1637 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7159 +7128 @@
 
 /* Line 1806 of yacc.c  */
+#line 1639 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
+    break;
+
+  case 417:
+
+/* Line 1806 of yacc.c  */
 #line 1645 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (9)].decl)->appendList( (yyvsp[(5) - (9)].decl) )->appendList( (yyvsp[(9) - (9)].decl) ); }
-    break;
-
-  case 417:
-
-/* Line 1806 of yacc.c  */
-#line 1651 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7173 +7142 @@
 
 /* Line 1806 of yacc.c  */
-#line 1656 "parser.yy"
+#line 1650 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7180 +7149 @@
 
 /* Line 1806 of yacc.c  */
-#line 1663 "parser.yy"
+#line 1657 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->addVarArgs(); }
     break;
@@ -7187 +7156 @@
 
 /* Line 1806 of yacc.c  */
-#line 1670 "parser.yy"
+#line 1664 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7194 +7163 @@
 
 /* Line 1806 of yacc.c  */
-#line 1672 "parser.yy"
+#line 1666 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (5)].decl)->appendList( (yyvsp[(5) - (5)].decl) ); }
     break;
@@ -7201 +7170 @@
 
 /* Line 1806 of yacc.c  */
-#line 1681 "parser.yy"
+#line 1675 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     break;
@@ -7208 +7177 @@
 
 /* Line 1806 of yacc.c  */
-#line 1684 "parser.yy"
+#line 1678 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addName( (yyvsp[(2) - (3)].tok) ); }
     break;
@@ -7215 +7184 @@
 
 /* Line 1806 of yacc.c  */
-#line 1686 "parser.yy"
+#line 1680 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addName( (yyvsp[(3) - (4)].tok) )->addQualifiers( (yyvsp[(1) - (4)].decl) ); }
     break;
@@ -7222 +7191 @@
 
 /* Line 1806 of yacc.c  */
+#line 1690 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 436:
+
+/* Line 1806 of yacc.c  */
 #line 1696 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 436:
-
-/* Line 1806 of yacc.c  */
-#line 1702 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7239 +7208 @@
 
 /* Line 1806 of yacc.c  */
-#line 1707 "parser.yy"
+#line 1701 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7249 +7218 @@
 
 /* Line 1806 of yacc.c  */
-#line 1716 "parser.yy"
+#line 1710 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7256 +7225 @@
 
 /* Line 1806 of yacc.c  */
-#line 1725 "parser.yy"
+#line 1719 "parser.yy"
     { (yyval.decl) = DeclarationNode::newName( (yyvsp[(1) - (1)].tok) ); }
     break;
@@ -7263 +7232 @@
 
 /* Line 1806 of yacc.c  */
-#line 1727 "parser.yy"
+#line 1721 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( DeclarationNode::newName( (yyvsp[(3) - (3)].tok) ) ); }
     break;
@@ -7270 +7239 @@
 
 /* Line 1806 of yacc.c  */
-#line 1752 "parser.yy"
+#line 1746 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7277 +7246 @@
 
 /* Line 1806 of yacc.c  */
-#line 1760 "parser.yy"
+#line 1754 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addType( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7284 +7253 @@
 
 /* Line 1806 of yacc.c  */
-#line 1765 "parser.yy"
+#line 1759 "parser.yy"
     { (yyval.in) = 0; }
     break;
@@ -7291 +7260 @@
 
 /* Line 1806 of yacc.c  */
+#line 1761 "parser.yy"
+    { (yyval.in) = (yyvsp[(2) - (2)].in); }
+    break;
+
+  case 460:
+
+/* Line 1806 of yacc.c  */
+#line 1763 "parser.yy"
+    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
+    break;
+
+  case 461:
+
+/* Line 1806 of yacc.c  */
 #line 1767 "parser.yy"
-    { (yyval.in) = (yyvsp[(2) - (2)].in); }
-    break;
-
-  case 460:
-
-/* Line 1806 of yacc.c  */
-#line 1769 "parser.yy"
-    { (yyval.in) = (yyvsp[(2) - (2)].in)->set_maybeConstructed( false ); }
-    break;
-
-  case 461:
+    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
+    break;
+
+  case 462:
+
+/* Line 1806 of yacc.c  */
+#line 1768 "parser.yy"
+    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
+    break;
+
+  case 463:
 
 /* Line 1806 of yacc.c  */
 #line 1773 "parser.yy"
-    { (yyval.in) = new InitializerNode( (yyvsp[(1) - (1)].en) ); }
-    break;
-
-  case 462:
-
-/* Line 1806 of yacc.c  */
-#line 1774 "parser.yy"
-    { (yyval.in) = new InitializerNode( (yyvsp[(2) - (4)].in), true ); }
-    break;
-
-  case 463:
-
-/* Line 1806 of yacc.c  */
-#line 1779 "parser.yy"
     { (yyval.in) = 0; }
     break;
@@ -7326 +7295 @@
 
 /* Line 1806 of yacc.c  */
-#line 1781 "parser.yy"
+#line 1775 "parser.yy"
     { (yyval.in) = (yyvsp[(2) - (2)].in)->set_designators( (yyvsp[(1) - (2)].en) ); }
     break;
@@ -7333 +7302 @@
 
 /* Line 1806 of yacc.c  */
-#line 1782 "parser.yy"
+#line 1776 "parser.yy"
     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (3)].in)->set_last( (yyvsp[(3) - (3)].in) ) ); }
     break;
@@ -7340 +7309 @@
 
 /* Line 1806 of yacc.c  */
-#line 1784 "parser.yy"
+#line 1778 "parser.yy"
     { (yyval.in) = (InitializerNode *)( (yyvsp[(1) - (4)].in)->set_last( (yyvsp[(4) - (4)].in)->set_designators( (yyvsp[(3) - (4)].en) ) ) ); }
     break;
@@ -7347 +7316 @@
 
 /* Line 1806 of yacc.c  */
+#line 1794 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
+    break;
+
+  case 471:
+
+/* Line 1806 of yacc.c  */
 #line 1800 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(1) - (2)].tok) ) ); }
-    break;
-
-  case 471:
+    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
+    break;
+
+  case 472:
 
 /* Line 1806 of yacc.c  */
 #line 1806 "parser.yy"
-    { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (2)].en)->set_last( (yyvsp[(2) - (2)].en) ) ); }
-    break;
-
-  case 472:
-
-/* Line 1806 of yacc.c  */
-#line 1812 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_varref( (yyvsp[(2) - (2)].tok) ) ); }
     break;
@@ -7368 +7337 @@
 
 /* Line 1806 of yacc.c  */
+#line 1809 "parser.yy"
+    { (yyval.en) = (yyvsp[(3) - (5)].en); }
+    break;
+
+  case 474:
+
+/* Line 1806 of yacc.c  */
+#line 1811 "parser.yy"
+    { (yyval.en) = (yyvsp[(3) - (5)].en); }
+    break;
+
+  case 475:
+
+/* Line 1806 of yacc.c  */
+#line 1813 "parser.yy"
+    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
+    break;
+
+  case 476:
+
+/* Line 1806 of yacc.c  */
 #line 1815 "parser.yy"
-    { (yyval.en) = (yyvsp[(3) - (5)].en); }
-    break;
-
-  case 474:
-
-/* Line 1806 of yacc.c  */
-#line 1817 "parser.yy"
-    { (yyval.en) = (yyvsp[(3) - (5)].en); }
-    break;
-
-  case 475:
-
-/* Line 1806 of yacc.c  */
-#line 1819 "parser.yy"
-    { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(3) - (7)].en), (yyvsp[(5) - (7)].en) ) ); }
-    break;
-
-  case 476:
-
-/* Line 1806 of yacc.c  */
-#line 1821 "parser.yy"
     { (yyval.en) = (yyvsp[(4) - (6)].en); }
     break;
@@ -7396 +7365 @@
 
 /* Line 1806 of yacc.c  */
-#line 1845 "parser.yy"
+#line 1839 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7403 +7372 @@
 
 /* Line 1806 of yacc.c  */
-#line 1847 "parser.yy"
+#line 1841 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7410 +7379 @@
 
 /* Line 1806 of yacc.c  */
+#line 1843 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
+    break;
+
+  case 482:
+
+/* Line 1806 of yacc.c  */
 #line 1849 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (3)].decl)->addQualifiers( (yyvsp[(2) - (3)].decl) )->addQualifiers( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 482:
-
-/* Line 1806 of yacc.c  */
-#line 1855 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -7424 +7393 @@
 
 /* Line 1806 of yacc.c  */
-#line 1857 "parser.yy"
+#line 1851 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7431 +7400 @@
 
 /* Line 1806 of yacc.c  */
+#line 1856 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
+    break;
+
+  case 486:
+
+/* Line 1806 of yacc.c  */
 #line 1862 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFromTypeGen( (yyvsp[(1) - (4)].tok), (yyvsp[(3) - (4)].en) ); }
-    break;
-
-  case 486:
-
-/* Line 1806 of yacc.c  */
-#line 1868 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->appendList( (yyvsp[(3) - (4)].decl) ); }
     break;
@@ -7445 +7414 @@
 
 /* Line 1806 of yacc.c  */
-#line 1873 "parser.yy"
+#line 1867 "parser.yy"
     { typedefTable.addToEnclosingScope( *(yyvsp[(2) - (2)].tok), TypedefTable::TD ); }
     break;
@@ -7452 +7421 @@
 
 /* Line 1806 of yacc.c  */
+#line 1869 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 490:
+
+/* Line 1806 of yacc.c  */
 #line 1875 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newTypeParam( (yyvsp[(1) - (4)].tclass), (yyvsp[(2) - (4)].tok) )->addAssertions( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 490:
-
-/* Line 1806 of yacc.c  */
-#line 1881 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Otype; }
     break;
@@ -7466 +7435 @@
 
 /* Line 1806 of yacc.c  */
-#line 1883 "parser.yy"
+#line 1877 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Ftype; }
     break;
@@ -7473 +7442 @@
 
 /* Line 1806 of yacc.c  */
-#line 1885 "parser.yy"
+#line 1879 "parser.yy"
     { (yyval.tclass) = DeclarationNode::Dtype; }
     break;
@@ -7480 +7449 @@
 
 /* Line 1806 of yacc.c  */
-#line 1890 "parser.yy"
+#line 1884 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7487 +7456 @@
 
 /* Line 1806 of yacc.c  */
-#line 1892 "parser.yy"
+#line 1886 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl) != 0 ? (yyvsp[(1) - (2)].decl)->appendList( (yyvsp[(2) - (2)].decl) ) : (yyvsp[(2) - (2)].decl); }
     break;
@@ -7494 +7463 @@
 
 /* Line 1806 of yacc.c  */
-#line 1897 "parser.yy"
+#line 1891 "parser.yy"
     {
                         typedefTable.openTrait( *(yyvsp[(2) - (5)].tok) );
@@ -7504 +7473 @@
 
 /* Line 1806 of yacc.c  */
-#line 1902 "parser.yy"
+#line 1896 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (5)].decl); }
     break;
@@ -7511 +7480 @@
 
 /* Line 1806 of yacc.c  */
-#line 1904 "parser.yy"
+#line 1898 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7518 +7487 @@
 
 /* Line 1806 of yacc.c  */
-#line 1909 "parser.yy"
+#line 1903 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_typevalue( (yyvsp[(1) - (1)].decl) ) ); }
     break;
@@ -7525 +7494 @@
 
 /* Line 1806 of yacc.c  */
-#line 1912 "parser.yy"
+#line 1906 "parser.yy"
     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( new ExpressionNode( build_typevalue( (yyvsp[(3) - (3)].decl) ) ) ) ); }
     break;
@@ -7532 +7501 @@
 
 /* Line 1806 of yacc.c  */
-#line 1914 "parser.yy"
+#line 1908 "parser.yy"
     { (yyval.en) = (ExpressionNode *)( (yyvsp[(1) - (3)].en)->set_last( (yyvsp[(3) - (3)].en) )); }
     break;
@@ -7539 +7508 @@
 
 /* Line 1806 of yacc.c  */
-#line 1919 "parser.yy"
+#line 1913 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl); }
     break;
@@ -7546 +7515 @@
 
 /* Line 1806 of yacc.c  */
-#line 1921 "parser.yy"
+#line 1915 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addQualifiers( (yyvsp[(1) - (3)].decl) ); }
     break;
@@ -7553 +7522 @@
 
 /* Line 1806 of yacc.c  */
-#line 1923 "parser.yy"
+#line 1917 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl)->copyStorageClasses( (yyvsp[(1) - (3)].decl) ) ); }
     break;
@@ -7560 +7529 @@
 
 /* Line 1806 of yacc.c  */
-#line 1928 "parser.yy"
+#line 1922 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addAssertions( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7567 +7536 @@
 
 /* Line 1806 of yacc.c  */
-#line 1930 "parser.yy"
+#line 1924 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addAssertions( (yyvsp[(2) - (4)].decl) )->addType( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -7574 +7543 @@
 
 /* Line 1806 of yacc.c  */
-#line 1935 "parser.yy"
+#line 1929 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(1) - (1)].tok), TypedefTable::TD );
@@ -7584 +7553 @@
 
 /* Line 1806 of yacc.c  */
-#line 1940 "parser.yy"
+#line 1934 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(1) - (6)].tok), TypedefTable::TG );
@@ -7594 +7563 @@
 
 /* Line 1806 of yacc.c  */
-#line 1948 "parser.yy"
+#line 1942 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( *(yyvsp[(2) - (9)].tok), TypedefTable::ID );
@@ -7604 +7573 @@
 
 /* Line 1806 of yacc.c  */
-#line 1953 "parser.yy"
+#line 1947 "parser.yy"
     {
                         typedefTable.enterTrait( *(yyvsp[(2) - (8)].tok) );
@@ -7614 +7583 @@
 
 /* Line 1806 of yacc.c  */
-#line 1958 "parser.yy"
+#line 1952 "parser.yy"
     {
                         typedefTable.leaveTrait();
@@ -7625 +7594 @@
 
 /* Line 1806 of yacc.c  */
-#line 1968 "parser.yy"
+#line 1962 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ); }
     break;
@@ -7632 +7601 @@
 
 /* Line 1806 of yacc.c  */
-#line 1978 "parser.yy"
+#line 1972 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -7642 +7611 @@
 
 /* Line 1806 of yacc.c  */
-#line 1983 "parser.yy"
+#line 1977 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -7652 +7621 @@
 
 /* Line 1806 of yacc.c  */
-#line 1988 "parser.yy"
+#line 1982 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( *(yyvsp[(5) - (5)].tok), TypedefTable::ID );
@@ -7662 +7631 @@
 
 /* Line 1806 of yacc.c  */
-#line 1996 "parser.yy"
+#line 1990 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -7672 +7641 @@
 
 /* Line 1806 of yacc.c  */
-#line 2001 "parser.yy"
+#line 1995 "parser.yy"
     {
                         typedefTable.addToEnclosingScope2( TypedefTable::ID );
@@ -7682 +7651 @@
 
 /* Line 1806 of yacc.c  */
-#line 2011 "parser.yy"
+#line 2005 "parser.yy"
     {}
     break;
@@ -7689 +7658 @@
 
 /* Line 1806 of yacc.c  */
+#line 2007 "parser.yy"
+    { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl);    }
+    break;
+
+  case 524:
+
+/* Line 1806 of yacc.c  */
 #line 2013 "parser.yy"
-    { parseTree = parseTree != nullptr ? parseTree->appendList( (yyvsp[(1) - (1)].decl) ) : (yyvsp[(1) - (1)].decl);    }
-    break;
-
-  case 524:
-
-/* Line 1806 of yacc.c  */
-#line 2019 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (3)].decl) != nullptr ? (yyvsp[(1) - (3)].decl)->appendList( (yyvsp[(3) - (3)].decl) ) : (yyvsp[(3) - (3)].decl); }
     break;
@@ -7703 +7672 @@
 
 /* Line 1806 of yacc.c  */
-#line 2024 "parser.yy"
+#line 2018 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7710 +7679 @@
 
 /* Line 1806 of yacc.c  */
-#line 2032 "parser.yy"
+#line 2026 "parser.yy"
     {}
     break;
@@ -7717 +7686 @@
 
 /* Line 1806 of yacc.c  */
-#line 2034 "parser.yy"
+#line 2028 "parser.yy"
     {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
@@ -7727 +7696 @@
 
 /* Line 1806 of yacc.c  */
-#line 2039 "parser.yy"
+#line 2033 "parser.yy"
     {
                         linkage = linkageStack.top();
@@ -7738 +7707 @@
 
 /* Line 1806 of yacc.c  */
-#line 2045 "parser.yy"
+#line 2039 "parser.yy"
     {   // mark all fields in list
                         for ( DeclarationNode *iter = (yyvsp[(2) - (2)].decl); iter != nullptr; iter = (DeclarationNode *)iter->get_next() )
@@ -7749 +7718 @@
 
 /* Line 1806 of yacc.c  */
-#line 2060 "parser.yy"
+#line 2054 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7760 +7729 @@
 
 /* Line 1806 of yacc.c  */
-#line 2066 "parser.yy"
+#line 2060 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7771 +7740 @@
 
 /* Line 1806 of yacc.c  */
-#line 2075 "parser.yy"
+#line 2069 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7782 +7751 @@
 
 /* Line 1806 of yacc.c  */
-#line 2081 "parser.yy"
+#line 2075 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7791 +7760 @@
 
   case 538:
+
+/* Line 1806 of yacc.c  */
+#line 2081 "parser.yy"
+    {
+                        typedefTable.addToEnclosingScope( TypedefTable::ID );
+                        typedefTable.leaveScope();
+                        (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) );
+                }
+    break;
+
+  case 539:
 
 /* Line 1806 of yacc.c  */
@@ -7801 +7781 @@
     break;
 
-  case 539:
+  case 540:
 
 /* Line 1806 of yacc.c  */
 #line 2093 "parser.yy"
-    {
-                        typedefTable.addToEnclosingScope( TypedefTable::ID );
-                        typedefTable.leaveScope();
-                        (yyval.decl) = (yyvsp[(2) - (3)].decl)->addFunctionBody( (yyvsp[(3) - (3)].sn) )->addQualifiers( (yyvsp[(1) - (3)].decl) );
-                }
-    break;
-
-  case 540:
-
-/* Line 1806 of yacc.c  */
-#line 2099 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7826 +7795 @@
 
 /* Line 1806 of yacc.c  */
-#line 2107 "parser.yy"
+#line 2101 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7837 +7806 @@
 
 /* Line 1806 of yacc.c  */
-#line 2113 "parser.yy"
+#line 2107 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7848 +7817 @@
 
 /* Line 1806 of yacc.c  */
-#line 2121 "parser.yy"
+#line 2115 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7859 +7828 @@
 
 /* Line 1806 of yacc.c  */
-#line 2127 "parser.yy"
+#line 2121 "parser.yy"
     {
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
@@ -7870 +7839 @@
 
 /* Line 1806 of yacc.c  */
-#line 2142 "parser.yy"
+#line 2136 "parser.yy"
     { (yyval.en) = new ExpressionNode( build_range( (yyvsp[(1) - (3)].en), (yyvsp[(3) - (3)].en) ) ); }
     break;
@@ -7877 +7846 @@
 
 /* Line 1806 of yacc.c  */
-#line 2147 "parser.yy"
+#line 2141 "parser.yy"
     { delete (yyvsp[(3) - (5)].str); }
     break;
@@ -7884 +7853 @@
 
 /* Line 1806 of yacc.c  */
-#line 2152 "parser.yy"
+#line 2146 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7891 +7860 @@
 
 /* Line 1806 of yacc.c  */
+#line 2153 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 555:
+
+/* Line 1806 of yacc.c  */
 #line 2159 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 555:
-
-/* Line 1806 of yacc.c  */
-#line 2165 "parser.yy"
     { (yyval.decl) = 0; }
     break;
@@ -7905 +7874 @@
 
 /* Line 1806 of yacc.c  */
+#line 2170 "parser.yy"
+    { delete (yyvsp[(3) - (4)].en); }
+    break;
+
+  case 561:
+
+/* Line 1806 of yacc.c  */
+#line 2174 "parser.yy"
+    { delete (yyvsp[(1) - (1)].tok); }
+    break;
+
+  case 562:
+
+/* Line 1806 of yacc.c  */
+#line 2175 "parser.yy"
+    { delete (yyvsp[(1) - (1)].decl); }
+    break;
+
+  case 563:
+
+/* Line 1806 of yacc.c  */
 #line 2176 "parser.yy"
-    { delete (yyvsp[(3) - (4)].en); }
-    break;
-
-  case 561:
-
-/* Line 1806 of yacc.c  */
-#line 2180 "parser.yy"
-    { delete (yyvsp[(1) - (1)].tok); }
-    break;
-
-  case 562:
-
-/* Line 1806 of yacc.c  */
-#line 2181 "parser.yy"
     { delete (yyvsp[(1) - (1)].decl); }
     break;
 
-  case 563:
-
-/* Line 1806 of yacc.c  */
-#line 2182 "parser.yy"
+  case 564:
+
+/* Line 1806 of yacc.c  */
+#line 2177 "parser.yy"
     { delete (yyvsp[(1) - (1)].decl); }
     break;
 
-  case 564:
-
-/* Line 1806 of yacc.c  */
-#line 2183 "parser.yy"
-    { delete (yyvsp[(1) - (1)].decl); }
-    break;
-
   case 565:
 
 /* Line 1806 of yacc.c  */
-#line 2218 "parser.yy"
+#line 2212 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7947 +7916 @@
 
 /* Line 1806 of yacc.c  */
-#line 2221 "parser.yy"
+#line 2215 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7954 +7923 @@
 
 /* Line 1806 of yacc.c  */
-#line 2223 "parser.yy"
+#line 2217 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -7961 +7930 @@
 
 /* Line 1806 of yacc.c  */
-#line 2228 "parser.yy"
+#line 2222 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -7971 +7940 @@
 
 /* Line 1806 of yacc.c  */
-#line 2233 "parser.yy"
+#line 2227 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -7978 +7947 @@
 
 /* Line 1806 of yacc.c  */
-#line 2238 "parser.yy"
+#line 2232 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -7985 +7954 @@
 
 /* Line 1806 of yacc.c  */
-#line 2240 "parser.yy"
+#line 2234 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -7992 +7961 @@
 
 /* Line 1806 of yacc.c  */
-#line 2242 "parser.yy"
+#line 2236 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -7999 +7968 @@
 
 /* Line 1806 of yacc.c  */
+#line 2241 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 575:
+
+/* Line 1806 of yacc.c  */
+#line 2243 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 576:
+
+/* Line 1806 of yacc.c  */
+#line 2245 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 577:
+
+/* Line 1806 of yacc.c  */
 #line 2247 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 578:
+
+/* Line 1806 of yacc.c  */
+#line 2252 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+
+  case 579:
+
+/* Line 1806 of yacc.c  */
+#line 2254 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 580:
+
+/* Line 1806 of yacc.c  */
+#line 2263 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 582:
+
+/* Line 1806 of yacc.c  */
+#line 2266 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 583:
+
+/* Line 1806 of yacc.c  */
+#line 2271 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
+    break;
+
+  case 584:
+
+/* Line 1806 of yacc.c  */
+#line 2273 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+
+  case 585:
+
+/* Line 1806 of yacc.c  */
+#line 2275 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 586:
+
+/* Line 1806 of yacc.c  */
+#line 2280 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 587:
+
+/* Line 1806 of yacc.c  */
+#line 2282 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 588:
+
+/* Line 1806 of yacc.c  */
+#line 2284 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 589:
+
+/* Line 1806 of yacc.c  */
+#line 2289 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 590:
+
+/* Line 1806 of yacc.c  */
+#line 2291 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 591:
+
+/* Line 1806 of yacc.c  */
+#line 2293 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 595:
+
+/* Line 1806 of yacc.c  */
+#line 2308 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
+    break;
+
+  case 596:
+
+/* Line 1806 of yacc.c  */
+#line 2310 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
+    break;
+
+  case 597:
+
+/* Line 1806 of yacc.c  */
+#line 2312 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 598:
+
+/* Line 1806 of yacc.c  */
+#line 2317 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 599:
+
+/* Line 1806 of yacc.c  */
+#line 2319 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 600:
+
+/* Line 1806 of yacc.c  */
+#line 2321 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 601:
+
+/* Line 1806 of yacc.c  */
+#line 2326 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 602:
+
+/* Line 1806 of yacc.c  */
+#line 2328 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 603:
+
+/* Line 1806 of yacc.c  */
+#line 2330 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 604:
+
+/* Line 1806 of yacc.c  */
+#line 2345 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 606:
+
+/* Line 1806 of yacc.c  */
+#line 2348 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 607:
+
+/* Line 1806 of yacc.c  */
+#line 2350 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 609:
+
+/* Line 1806 of yacc.c  */
+#line 2356 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 610:
+
+/* Line 1806 of yacc.c  */
+#line 2361 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 611:
+
+/* Line 1806 of yacc.c  */
+#line 2363 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 612:
+
+/* Line 1806 of yacc.c  */
+#line 2365 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 613:
+
+/* Line 1806 of yacc.c  */
+#line 2370 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 575:
-
-/* Line 1806 of yacc.c  */
-#line 2249 "parser.yy"
+  case 614:
+
+/* Line 1806 of yacc.c  */
+#line 2372 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
 
-  case 576:
-
-/* Line 1806 of yacc.c  */
-#line 2251 "parser.yy"
+  case 615:
+
+/* Line 1806 of yacc.c  */
+#line 2374 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
 
-  case 577:
-
-/* Line 1806 of yacc.c  */
-#line 2253 "parser.yy"
+  case 616:
+
+/* Line 1806 of yacc.c  */
+#line 2376 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 578:
-
-/* Line 1806 of yacc.c  */
-#line 2258 "parser.yy"
+  case 617:
+
+/* Line 1806 of yacc.c  */
+#line 2381 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
+    break;
+
+  case 618:
+
+/* Line 1806 of yacc.c  */
+#line 2383 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
 
-  case 579:
-
-/* Line 1806 of yacc.c  */
-#line 2260 "parser.yy"
+  case 619:
+
+/* Line 1806 of yacc.c  */
+#line 2385 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 580:
-
-/* Line 1806 of yacc.c  */
-#line 2269 "parser.yy"
+  case 620:
+
+/* Line 1806 of yacc.c  */
+#line 2395 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 582:
-
-/* Line 1806 of yacc.c  */
-#line 2272 "parser.yy"
+  case 622:
+
+/* Line 1806 of yacc.c  */
+#line 2398 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 583:
-
-/* Line 1806 of yacc.c  */
-#line 2277 "parser.yy"
+  case 623:
+
+/* Line 1806 of yacc.c  */
+#line 2400 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 624:
+
+/* Line 1806 of yacc.c  */
+#line 2405 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 625:
+
+/* Line 1806 of yacc.c  */
+#line 2407 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 626:
+
+/* Line 1806 of yacc.c  */
+#line 2409 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 627:
+
+/* Line 1806 of yacc.c  */
+#line 2414 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 628:
+
+/* Line 1806 of yacc.c  */
+#line 2416 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 629:
+
+/* Line 1806 of yacc.c  */
+#line 2418 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 630:
+
+/* Line 1806 of yacc.c  */
+#line 2420 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 631:
+
+/* Line 1806 of yacc.c  */
+#line 2425 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     break;
 
-  case 584:
-
-/* Line 1806 of yacc.c  */
-#line 2279 "parser.yy"
+  case 632:
+
+/* Line 1806 of yacc.c  */
+#line 2427 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
 
-  case 585:
-
-/* Line 1806 of yacc.c  */
-#line 2281 "parser.yy"
+  case 633:
+
+/* Line 1806 of yacc.c  */
+#line 2429 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 586:
-
-/* Line 1806 of yacc.c  */
-#line 2286 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 587:
-
-/* Line 1806 of yacc.c  */
-#line 2288 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 588:
-
-/* Line 1806 of yacc.c  */
-#line 2290 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 589:
-
-/* Line 1806 of yacc.c  */
-#line 2295 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 590:
-
-/* Line 1806 of yacc.c  */
-#line 2297 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 591:
-
-/* Line 1806 of yacc.c  */
-#line 2299 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 595:
-
-/* Line 1806 of yacc.c  */
-#line 2314 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (4)].decl)->addIdList( (yyvsp[(3) - (4)].decl) ); }
-    break;
-
-  case 596:
-
-/* Line 1806 of yacc.c  */
-#line 2316 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (6)].decl)->addIdList( (yyvsp[(5) - (6)].decl) ); }
-    break;
-
-  case 597:
-
-/* Line 1806 of yacc.c  */
-#line 2318 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 598:
-
-/* Line 1806 of yacc.c  */
-#line 2323 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 599:
-
-/* Line 1806 of yacc.c  */
-#line 2325 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 600:
-
-/* Line 1806 of yacc.c  */
-#line 2327 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 601:
-
-/* Line 1806 of yacc.c  */
-#line 2332 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 602:
-
-/* Line 1806 of yacc.c  */
-#line 2334 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 603:
-
-/* Line 1806 of yacc.c  */
-#line 2336 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 604:
-
-/* Line 1806 of yacc.c  */
-#line 2351 "parser.yy"
+  case 634:
+
+/* Line 1806 of yacc.c  */
+#line 2460 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 606:
-
-/* Line 1806 of yacc.c  */
-#line 2354 "parser.yy"
+  case 636:
+
+/* Line 1806 of yacc.c  */
+#line 2463 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 607:
-
-/* Line 1806 of yacc.c  */
-#line 2356 "parser.yy"
+  case 637:
+
+/* Line 1806 of yacc.c  */
+#line 2465 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 609:
-
-/* Line 1806 of yacc.c  */
-#line 2362 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 610:
-
-/* Line 1806 of yacc.c  */
-#line 2367 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 611:
-
-/* Line 1806 of yacc.c  */
-#line 2369 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 612:
-
-/* Line 1806 of yacc.c  */
-#line 2371 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 613:
-
-/* Line 1806 of yacc.c  */
-#line 2376 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 614:
-
-/* Line 1806 of yacc.c  */
-#line 2378 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 615:
-
-/* Line 1806 of yacc.c  */
-#line 2380 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 616:
-
-/* Line 1806 of yacc.c  */
-#line 2382 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 617:
-
-/* Line 1806 of yacc.c  */
-#line 2387 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-
-  case 618:
-
-/* Line 1806 of yacc.c  */
-#line 2389 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 619:
-
-/* Line 1806 of yacc.c  */
-#line 2391 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 620:
-
-/* Line 1806 of yacc.c  */
-#line 2401 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 622:
-
-/* Line 1806 of yacc.c  */
-#line 2404 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 623:
-
-/* Line 1806 of yacc.c  */
-#line 2406 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 624:
-
-/* Line 1806 of yacc.c  */
-#line 2411 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 625:
-
-/* Line 1806 of yacc.c  */
-#line 2413 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 626:
-
-/* Line 1806 of yacc.c  */
-#line 2415 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 627:
-
-/* Line 1806 of yacc.c  */
-#line 2420 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 628:
-
-/* Line 1806 of yacc.c  */
-#line 2422 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 629:
-
-/* Line 1806 of yacc.c  */
-#line 2424 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 630:
-
-/* Line 1806 of yacc.c  */
-#line 2426 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 631:
-
-/* Line 1806 of yacc.c  */
-#line 2431 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
-    break;
-
-  case 632:
-
-/* Line 1806 of yacc.c  */
-#line 2433 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 633:
-
-/* Line 1806 of yacc.c  */
-#line 2435 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 634:
-
-/* Line 1806 of yacc.c  */
-#line 2466 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 636:
-
-/* Line 1806 of yacc.c  */
-#line 2469 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 637:
-
-/* Line 1806 of yacc.c  */
-#line 2471 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
   case 638:
 
 /* Line 1806 of yacc.c  */
-#line 2476 "parser.yy"
+#line 2470 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8401 +8370 @@
 
 /* Line 1806 of yacc.c  */
-#line 2481 "parser.yy"
+#line 2475 "parser.yy"
     {
                         typedefTable.setNextIdentifier( *(yyvsp[(1) - (1)].tok) );
@@ -8411 +8380 @@
 
 /* Line 1806 of yacc.c  */
-#line 2489 "parser.yy"
+#line 2483 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
@@ -8418 +8387 @@
 
 /* Line 1806 of yacc.c  */
-#line 2491 "parser.yy"
+#line 2485 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
@@ -8425 +8394 @@
 
 /* Line 1806 of yacc.c  */
-#line 2493 "parser.yy"
+#line 2487 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
@@ -8432 +8401 @@
 
 /* Line 1806 of yacc.c  */
-#line 2498 "parser.yy"
+#line 2492 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8439 +8408 @@
 
 /* Line 1806 of yacc.c  */
-#line 2500 "parser.yy"
+#line 2494 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
@@ -8446 +8415 @@
 
 /* Line 1806 of yacc.c  */
-#line 2505 "parser.yy"
+#line 2499 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addParamList( (yyvsp[(4) - (6)].decl) ); }
     break;
@@ -8453 +8422 @@
 
 /* Line 1806 of yacc.c  */
-#line 2507 "parser.yy"
+#line 2501 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
@@ -8460 +8429 @@
 
 /* Line 1806 of yacc.c  */
-#line 2522 "parser.yy"
+#line 2516 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8467 +8436 @@
 
 /* Line 1806 of yacc.c  */
-#line 2524 "parser.yy"
+#line 2518 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
@@ -8474 +8443 @@
 
 /* Line 1806 of yacc.c  */
+#line 2523 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
+    break;
+
+  case 651:
+
+/* Line 1806 of yacc.c  */
+#line 2525 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 652:
+
+/* Line 1806 of yacc.c  */
+#line 2527 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 653:
+
+/* Line 1806 of yacc.c  */
 #line 2529 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
+    break;
+
+  case 654:
+
+/* Line 1806 of yacc.c  */
+#line 2531 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 656:
+
+/* Line 1806 of yacc.c  */
+#line 2537 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 657:
+
+/* Line 1806 of yacc.c  */
+#line 2539 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
+    break;
+
+  case 658:
+
+/* Line 1806 of yacc.c  */
+#line 2541 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 659:
+
+/* Line 1806 of yacc.c  */
+#line 2546 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
+    break;
+
+  case 660:
+
+/* Line 1806 of yacc.c  */
+#line 2548 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
+    break;
+
+  case 661:
+
+/* Line 1806 of yacc.c  */
+#line 2550 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
+    break;
+
+  case 662:
+
+/* Line 1806 of yacc.c  */
+#line 2556 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
+    break;
+
+  case 663:
+
+/* Line 1806 of yacc.c  */
+#line 2558 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
+    break;
+
+  case 665:
+
+/* Line 1806 of yacc.c  */
+#line 2564 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
+    break;
+
+  case 666:
+
+/* Line 1806 of yacc.c  */
+#line 2566 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
+    break;
+
+  case 667:
+
+/* Line 1806 of yacc.c  */
+#line 2568 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
+    break;
+
+  case 668:
+
+/* Line 1806 of yacc.c  */
+#line 2570 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
+    break;
+
+  case 670:
+
+/* Line 1806 of yacc.c  */
+#line 2585 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 671:
+
+/* Line 1806 of yacc.c  */
+#line 2587 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 672:
+
+/* Line 1806 of yacc.c  */
+#line 2592 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     break;
 
-  case 651:
-
-/* Line 1806 of yacc.c  */
-#line 2531 "parser.yy"
+  case 673:
+
+/* Line 1806 of yacc.c  */
+#line 2594 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 652:
-
-/* Line 1806 of yacc.c  */
-#line 2533 "parser.yy"
+  case 674:
+
+/* Line 1806 of yacc.c  */
+#line 2596 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
 
-  case 653:
-
-/* Line 1806 of yacc.c  */
-#line 2535 "parser.yy"
+  case 675:
+
+/* Line 1806 of yacc.c  */
+#line 2598 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
 
-  case 654:
-
-/* Line 1806 of yacc.c  */
-#line 2537 "parser.yy"
+  case 676:
+
+/* Line 1806 of yacc.c  */
+#line 2600 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 656:
-
-/* Line 1806 of yacc.c  */
-#line 2543 "parser.yy"
+  case 678:
+
+/* Line 1806 of yacc.c  */
+#line 2606 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
 
-  case 657:
-
-/* Line 1806 of yacc.c  */
-#line 2545 "parser.yy"
+  case 679:
+
+/* Line 1806 of yacc.c  */
+#line 2608 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
 
-  case 658:
-
-/* Line 1806 of yacc.c  */
-#line 2547 "parser.yy"
+  case 680:
+
+/* Line 1806 of yacc.c  */
+#line 2610 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 659:
-
-/* Line 1806 of yacc.c  */
-#line 2552 "parser.yy"
+  case 681:
+
+/* Line 1806 of yacc.c  */
+#line 2615 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
     break;
 
-  case 660:
-
-/* Line 1806 of yacc.c  */
-#line 2554 "parser.yy"
+  case 682:
+
+/* Line 1806 of yacc.c  */
+#line 2617 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
 
-  case 661:
-
-/* Line 1806 of yacc.c  */
-#line 2556 "parser.yy"
+  case 683:
+
+/* Line 1806 of yacc.c  */
+#line 2619 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 662:
-
-/* Line 1806 of yacc.c  */
-#line 2562 "parser.yy"
+  case 685:
+
+/* Line 1806 of yacc.c  */
+#line 2626 "parser.yy"
+    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
+    break;
+
+  case 687:
+
+/* Line 1806 of yacc.c  */
+#line 2637 "parser.yy"
     { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
     break;
 
-  case 663:
-
-/* Line 1806 of yacc.c  */
-#line 2564 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false )->addArray( (yyvsp[(3) - (3)].decl) ); }
-    break;
-
-  case 665:
-
-/* Line 1806 of yacc.c  */
-#line 2570 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(3) - (5)].en), 0, false ); }
-    break;
-
-  case 666:
-
-/* Line 1806 of yacc.c  */
-#line 2572 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newVarArray( 0 ); }
-    break;
-
-  case 667:
-
-/* Line 1806 of yacc.c  */
-#line 2574 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newArray( (yyvsp[(4) - (6)].en), 0, false ) ); }
-    break;
-
-  case 668:
-
-/* Line 1806 of yacc.c  */
-#line 2576 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (6)].decl)->addArray( DeclarationNode::newVarArray( 0 ) ); }
-    break;
-
-  case 670:
-
-/* Line 1806 of yacc.c  */
-#line 2591 "parser.yy"
+  case 688:
+
+/* Line 1806 of yacc.c  */
+#line 2640 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
+    break;
+
+  case 689:
+
+/* Line 1806 of yacc.c  */
+#line 2642 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
+    break;
+
+  case 690:
+
+/* Line 1806 of yacc.c  */
+#line 2645 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
+    break;
+
+  case 691:
+
+/* Line 1806 of yacc.c  */
+#line 2647 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
+    break;
+
+  case 692:
+
+/* Line 1806 of yacc.c  */
+#line 2649 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
+    break;
+
+  case 694:
+
+/* Line 1806 of yacc.c  */
+#line 2663 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 671:
-
-/* Line 1806 of yacc.c  */
-#line 2593 "parser.yy"
+  case 695:
+
+/* Line 1806 of yacc.c  */
+#line 2665 "parser.yy"
     { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 672:
-
-/* Line 1806 of yacc.c  */
-#line 2598 "parser.yy"
+  case 696:
+
+/* Line 1806 of yacc.c  */
+#line 2670 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
     break;
 
-  case 673:
-
-/* Line 1806 of yacc.c  */
-#line 2600 "parser.yy"
+  case 697:
+
+/* Line 1806 of yacc.c  */
+#line 2672 "parser.yy"
     { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
     break;
 
-  case 674:
-
-/* Line 1806 of yacc.c  */
-#line 2602 "parser.yy"
+  case 698:
+
+/* Line 1806 of yacc.c  */
+#line 2674 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
 
-  case 675:
-
-/* Line 1806 of yacc.c  */
-#line 2604 "parser.yy"
+  case 699:
+
+/* Line 1806 of yacc.c  */
+#line 2676 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
     break;
 
-  case 676:
-
-/* Line 1806 of yacc.c  */
-#line 2606 "parser.yy"
+  case 700:
+
+/* Line 1806 of yacc.c  */
+#line 2678 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 678:
-
-/* Line 1806 of yacc.c  */
-#line 2612 "parser.yy"
+  case 702:
+
+/* Line 1806 of yacc.c  */
+#line 2684 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
 
-  case 679:
-
-/* Line 1806 of yacc.c  */
-#line 2614 "parser.yy"
+  case 703:
+
+/* Line 1806 of yacc.c  */
+#line 2686 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
     break;
 
-  case 680:
-
-/* Line 1806 of yacc.c  */
-#line 2616 "parser.yy"
+  case 704:
+
+/* Line 1806 of yacc.c  */
+#line 2688 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 681:
-
-/* Line 1806 of yacc.c  */
-#line 2621 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newFunction( nullptr, nullptr, (yyvsp[(3) - (5)].decl), nullptr ); }
-    break;
-
-  case 682:
-
-/* Line 1806 of yacc.c  */
-#line 2623 "parser.yy"
+  case 705:
+
+/* Line 1806 of yacc.c  */
+#line 2693 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
     break;
 
-  case 683:
-
-/* Line 1806 of yacc.c  */
-#line 2625 "parser.yy"
+  case 706:
+
+/* Line 1806 of yacc.c  */
+#line 2695 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
     break;
 
-  case 685:
-
-/* Line 1806 of yacc.c  */
-#line 2632 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addArray( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 687:
-
-/* Line 1806 of yacc.c  */
-#line 2643 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, 0, false ); }
-    break;
-
-  case 688:
-
-/* Line 1806 of yacc.c  */
-#line 2646 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
-    break;
-
-  case 689:
-
-/* Line 1806 of yacc.c  */
-#line 2648 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( 0, (yyvsp[(3) - (5)].decl), false ); }
-    break;
-
-  case 690:
-
-/* Line 1806 of yacc.c  */
-#line 2651 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
-    break;
-
-  case 691:
-
-/* Line 1806 of yacc.c  */
-#line 2653 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl), true ); }
-    break;
-
-  case 692:
-
-/* Line 1806 of yacc.c  */
-#line 2655 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(3) - (7)].decl), true ); }
-    break;
-
-  case 694:
-
-/* Line 1806 of yacc.c  */
-#line 2669 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 695:
-
-/* Line 1806 of yacc.c  */
-#line 2671 "parser.yy"
-    { (yyval.decl) = (yyvsp[(1) - (2)].decl)->addQualifiers( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 696:
-
-/* Line 1806 of yacc.c  */
-#line 2676 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( 0 ); }
-    break;
-
-  case 697:
-
-/* Line 1806 of yacc.c  */
-#line 2678 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newPointer( (yyvsp[(2) - (2)].decl) ); }
-    break;
-
-  case 698:
-
-/* Line 1806 of yacc.c  */
-#line 2680 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 699:
-
-/* Line 1806 of yacc.c  */
-#line 2682 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addPointer( DeclarationNode::newPointer( (yyvsp[(2) - (3)].decl) ) ); }
-    break;
-
-  case 700:
-
-/* Line 1806 of yacc.c  */
-#line 2684 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 702:
-
-/* Line 1806 of yacc.c  */
-#line 2690 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 703:
-
-/* Line 1806 of yacc.c  */
-#line 2692 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (4)].decl)->addArray( (yyvsp[(4) - (4)].decl) ); }
-    break;
-
-  case 704:
-
-/* Line 1806 of yacc.c  */
-#line 2694 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
-  case 705:
-
-/* Line 1806 of yacc.c  */
-#line 2699 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (8)].decl)->addParamList( (yyvsp[(6) - (8)].decl) ); }
-    break;
-
-  case 706:
-
-/* Line 1806 of yacc.c  */
-#line 2701 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (3)].decl); }
-    break;
-
   case 709:
 
 /* Line 1806 of yacc.c  */
-#line 2711 "parser.yy"
+#line 2705 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
     break;
@@ -8824 +8793 @@
 
 /* Line 1806 of yacc.c  */
+#line 2715 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 713:
+
+/* Line 1806 of yacc.c  */
+#line 2717 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+
+  case 714:
+
+/* Line 1806 of yacc.c  */
+#line 2719 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 715:
+
+/* Line 1806 of yacc.c  */
 #line 2721 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+
+  case 716:
+
+/* Line 1806 of yacc.c  */
+#line 2723 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
     break;
 
-  case 713:
-
-/* Line 1806 of yacc.c  */
-#line 2723 "parser.yy"
+  case 717:
+
+/* Line 1806 of yacc.c  */
+#line 2725 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
     break;
 
-  case 714:
-
-/* Line 1806 of yacc.c  */
-#line 2725 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 715:
-
-/* Line 1806 of yacc.c  */
-#line 2727 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 716:
-
-/* Line 1806 of yacc.c  */
-#line 2729 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 717:
-
-/* Line 1806 of yacc.c  */
-#line 2731 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
   case 718:
 
 /* Line 1806 of yacc.c  */
+#line 2732 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+
+  case 719:
+
+/* Line 1806 of yacc.c  */
+#line 2734 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 720:
+
+/* Line 1806 of yacc.c  */
+#line 2736 "parser.yy"
+    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+
+  case 721:
+
+/* Line 1806 of yacc.c  */
 #line 2738 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 719:
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
+    break;
+
+  case 722:
 
 /* Line 1806 of yacc.c  */
@@ -8877 +8867 @@
     break;
 
-  case 720:
-
-/* Line 1806 of yacc.c  */
-#line 2742 "parser.yy"
+  case 723:
+
+/* Line 1806 of yacc.c  */
+#line 2743 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+    break;
+
+  case 724:
+
+/* Line 1806 of yacc.c  */
+#line 2745 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 725:
+
+/* Line 1806 of yacc.c  */
+#line 2747 "parser.yy"
     { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
     break;
 
-  case 721:
-
-/* Line 1806 of yacc.c  */
-#line 2744 "parser.yy"
+  case 726:
+
+/* Line 1806 of yacc.c  */
+#line 2749 "parser.yy"
     { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
     break;
 
-  case 722:
-
-/* Line 1806 of yacc.c  */
-#line 2746 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 723:
-
-/* Line 1806 of yacc.c  */
-#line 2749 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 724:
+  case 727:
 
 /* Line 1806 of yacc.c  */
@@ -8912 +8902 @@
     break;
 
-  case 725:
-
-/* Line 1806 of yacc.c  */
-#line 2753 "parser.yy"
-    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
-    break;
-
-  case 726:
-
-/* Line 1806 of yacc.c  */
-#line 2755 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( (yyvsp[(2) - (3)].decl) )->addNewArray( (yyvsp[(1) - (3)].decl) ); }
-    break;
-
-  case 727:
-
-/* Line 1806 of yacc.c  */
-#line 2757 "parser.yy"
+  case 728:
+
+/* Line 1806 of yacc.c  */
+#line 2756 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
+    break;
+
+  case 729:
+
+/* Line 1806 of yacc.c  */
+#line 2758 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
+    break;
+
+  case 730:
+
+/* Line 1806 of yacc.c  */
+#line 2763 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
+    break;
+
+  case 731:
+
+/* Line 1806 of yacc.c  */
+#line 2765 "parser.yy"
+    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
+    break;
+
+  case 733:
+
+/* Line 1806 of yacc.c  */
+#line 2792 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
+    break;
+
+  case 737:
+
+/* Line 1806 of yacc.c  */
+#line 2803 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 738:
+
+/* Line 1806 of yacc.c  */
+#line 2805 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+
+  case 739:
+
+/* Line 1806 of yacc.c  */
+#line 2807 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 740:
+
+/* Line 1806 of yacc.c  */
+#line 2809 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+
+  case 741:
+
+/* Line 1806 of yacc.c  */
+#line 2811 "parser.yy"
+    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+    break;
+
+  case 742:
+
+/* Line 1806 of yacc.c  */
+#line 2813 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
+    break;
+
+  case 743:
+
+/* Line 1806 of yacc.c  */
+#line 2820 "parser.yy"
+    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
+    break;
+
+  case 744:
+
+/* Line 1806 of yacc.c  */
+#line 2822 "parser.yy"
+    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
+    break;
+
+  case 745:
+
+/* Line 1806 of yacc.c  */
+#line 2824 "parser.yy"
     { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
     break;
 
-  case 728:
-
-/* Line 1806 of yacc.c  */
-#line 2762 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newVarArray( (yyvsp[(3) - (6)].decl) ); }
-    break;
-
-  case 729:
-
-/* Line 1806 of yacc.c  */
-#line 2764 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), false ); }
-    break;
-
-  case 730:
-
-/* Line 1806 of yacc.c  */
-#line 2769 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(4) - (6)].en), (yyvsp[(3) - (6)].decl), true ); }
-    break;
-
-  case 731:
-
-/* Line 1806 of yacc.c  */
-#line 2771 "parser.yy"
-    { (yyval.decl) = DeclarationNode::newArray( (yyvsp[(5) - (7)].en), (yyvsp[(4) - (7)].decl)->addQualifiers( (yyvsp[(3) - (7)].decl) ), true ); }
-    break;
-
-  case 733:
-
-/* Line 1806 of yacc.c  */
-#line 2798 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addQualifiers( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
-  case 737:
-
-/* Line 1806 of yacc.c  */
-#line 2809 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 738:
-
-/* Line 1806 of yacc.c  */
-#line 2811 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 739:
-
-/* Line 1806 of yacc.c  */
-#line 2813 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 740:
-
-/* Line 1806 of yacc.c  */
-#line 2815 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 741:
-
-/* Line 1806 of yacc.c  */
-#line 2817 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
-    break;
-
-  case 742:
-
-/* Line 1806 of yacc.c  */
-#line 2819 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewPointer( DeclarationNode::newPointer( (yyvsp[(1) - (3)].decl) ) ); }
-    break;
-
-  case 743:
+  case 746:
 
 /* Line 1806 of yacc.c  */
@@ -9017 +9007 @@
     break;
 
-  case 744:
+  case 747:
 
 /* Line 1806 of yacc.c  */
@@ -9024 +9014 @@
     break;
 
-  case 745:
+  case 748:
 
 /* Line 1806 of yacc.c  */
@@ -9031 +9021 @@
     break;
 
-  case 746:
-
-/* Line 1806 of yacc.c  */
-#line 2832 "parser.yy"
-    { (yyval.decl) = (yyvsp[(3) - (3)].decl)->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
-    break;
-
-  case 747:
-
-/* Line 1806 of yacc.c  */
-#line 2834 "parser.yy"
-    { (yyval.decl) = (yyvsp[(4) - (4)].decl)->addNewArray( (yyvsp[(3) - (4)].decl) )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
-    break;
-
-  case 748:
-
-/* Line 1806 of yacc.c  */
-#line 2836 "parser.yy"
-    { (yyval.decl) = (yyvsp[(2) - (2)].decl)->addNewArray( (yyvsp[(1) - (2)].decl) ); }
-    break;
-
   case 749:
 
 /* Line 1806 of yacc.c  */
-#line 2841 "parser.yy"
+#line 2835 "parser.yy"
     { (yyval.decl) = DeclarationNode::newTuple( (yyvsp[(3) - (5)].decl) ); }
     break;
@@ -9062 +9031 @@
 
 /* Line 1806 of yacc.c  */
-#line 2848 "parser.yy"
+#line 2842 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
     break;
@@ -9069 +9038 @@
 
 /* Line 1806 of yacc.c  */
-#line 2850 "parser.yy"
+#line 2844 "parser.yy"
     { (yyval.decl) = DeclarationNode::newFunction( nullptr, (yyvsp[(1) - (6)].decl), (yyvsp[(4) - (6)].decl), nullptr ); }
     break;
@@ -9076 +9045 @@
 
 /* Line 1806 of yacc.c  */
-#line 2874 "parser.yy"
+#line 2868 "parser.yy"
     { (yyval.en) = 0; }
     break;
@@ -9083 +9052 @@
 
 /* Line 1806 of yacc.c  */
-#line 2876 "parser.yy"
+#line 2870 "parser.yy"
     { (yyval.en) = (yyvsp[(2) - (2)].en); }
     break;
@@ -9090 +9059 @@
 
 /* Line 1806 of yacc.c  */
-#line 9093 "Parser/parser.cc"
+#line 9062 "Parser/parser.cc"
       default: break;
     }
@@ -9321 +9290 @@
 
 /* Line 2067 of yacc.c  */
-#line 2879 "parser.yy"
+#line 2873 "parser.yy"
 
 // ----end of grammar----

src/Parser/parser.yy

@@ -199 +199 @@
 
 %type<decl> field_declaration field_declaration_list field_declarator field_declaring_list
-%type<en> field field_list field_name fraction_constants
+%type<en> field field_list
+%type<tok> field_name
 
 %type<decl> external_function_definition function_definition function_array function_declarator function_no_ptr function_ptr
@@ -383 +384 @@
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_varref( $3 ) ) ); }
         | postfix_expression '.' '[' push field_list pop ']' // CFA, tuple field selector
-                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
         | postfix_expression REALFRACTIONconstant                       // CFA, tuple index
-                { $$ = new ExpressionNode( build_fieldSel( $1, build_field_name_REALFRACTIONconstant( *$2 ) ) ); }
         | postfix_expression ARROW no_attr_identifier
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
         | postfix_expression ARROW '[' push field_list pop ']' // CFA, tuple field selector
-                        { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
         | postfix_expression ICR
                 { $$ = new ExpressionNode( build_unary_ptr( OperKinds::IncrPost, $1 ) ); }
@@ -423 +421 @@
 field:                                                                                                  // CFA, tuple field selector
         field_name
+                { $$ = new ExpressionNode( build_varref( $1 ) ); }
         | REALDECIMALconstant field
-                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *$1 ) ), maybeMoveBuild<Expression>( $2 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $2, build_varref( $1 ) ) ); }
         | REALDECIMALconstant '[' push field_list pop ']'
-                { $$ = new ExpressionNode( build_fieldSel( new ExpressionNode( build_field_name_REALDECIMALconstant( *$1 ) ), build_tuple( $4 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $4, build_varref( $1 ) ) ); }
         | field_name '.' field
-                { $$ = new ExpressionNode( build_fieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $3, build_varref( $1 ) ) ); }
         | field_name '.' '[' push field_list pop ']'
-                { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $5 ) ) ); }
+                { $$ = new ExpressionNode( build_fieldSel( $5, build_varref( $1 ) ) ); }
         | field_name ARROW field
-                { $$ = new ExpressionNode( build_pfieldSel( $1, maybeMoveBuild<Expression>( $3 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $3, build_varref( $1 ) ) ); }
         | field_name ARROW '[' push field_list pop ']'
-                { $$ = new ExpressionNode( build_pfieldSel( $1, build_tuple( $5 ) ) ); }
+                { $$ = new ExpressionNode( build_pfieldSel( $5, build_varref( $1 ) ) ); }
         ;
 
 field_name:
         INTEGERconstant fraction_constants
-                { $$ = new ExpressionNode( build_field_name_fraction_constants( build_constantInteger( *$1 ), $2 ) ); }
+                { $$ = $1; }
         | FLOATINGconstant fraction_constants
-                { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
+                { $$ = $1; }
         | no_attr_identifier fraction_constants
-                { $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) ); }
+                { $$ = $1; }
         ;
 
 fraction_constants:
         // empty
-                { $$ = nullptr; }
         | fraction_constants REALFRACTIONconstant
-                {
-                        Expression * constant = build_field_name_REALFRACTIONconstant( *$2 );
-                        $$ = $1 != nullptr ? new ExpressionNode( build_fieldSel( $1,  constant ) ) : new ExpressionNode( constant );
-                }
         ;
 

src/ResolvExpr/Alternative.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Alternative.cc --
+// Alternative.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -12 +12 @@
 // Last Modified On : Sat May 16 23:54:23 2015
 // Update Count     : 2
-//
+// 
 
 #include "Alternative.h"
@@ -20 +20 @@
 
 namespace ResolvExpr {
-        Alternative::Alternative() : cost( Cost::zero ), cvtCost( Cost::zero ), expr( 0 ) {}
+        Alternative::Alternative() : expr( 0 ) {}
 
         Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost )
@@ -35 +35 @@
                 if ( &other == this ) return *this;
                 initialize( other, *this );
-                return *this;
-        }
-
-        Alternative::Alternative( Alternative && other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( other.expr ), env( other.env ) {
-                other.expr = nullptr;
-        }
-
-        Alternative & Alternative::operator=( Alternative && other ) {
-                if ( &other == this )  return *this;
-                delete expr;
-                cost = other.cost;
-                cvtCost = other.cvtCost;
-                expr = other.expr;
-                env = other.env;
-                other.expr = nullptr;
                 return *this;
         }
@@ -69 +54 @@
                         expr->print( os, indent );
                         os << "(types:" << std::endl;
-                        os << std::string( indent+4, ' ' );
-                        expr->get_result()->print( os, indent + 4 );
-                        os << std::endl << ")" << std::endl;
+                        printAll( expr->get_results(), os, indent + 4 );
+                        os << ")" << std::endl;
                 } else {
                         os << "Null expression!" << std::endl;

src/ResolvExpr/Alternative.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Alternative.h --
+// Alternative.h -- 
 //
 // Author           : Richard C. Bilson
@@ -12 +12 @@
 // Last Modified On : Sat May 16 23:54:39 2015
 // Update Count     : 2
-//
+// 
 
 #ifndef ALTERNATIVE_H
@@ -32 +32 @@
                 Alternative( const Alternative &other );
                 Alternative &operator=( const Alternative &other );
-                Alternative( Alternative && other );
-                Alternative &operator=( Alternative && other );
                 ~Alternative();
-
+  
                 void initialize( const Alternative &src, Alternative &dest );
-
+  
                 void print( std::ostream &os, int indent = 0 ) const;
-
+  
                 Cost cost;
                 Cost cvtCost;

src/ResolvExpr/AlternativeFinder.cc

@@ -38 +38 @@
 #include "SynTree/TypeSubstitution.h"
 #include "SymTab/Validate.h"
-#include "Tuples/Tuples.h"
-#include "Tuples/Explode.h"
+#include "Tuples/TupleAssignment.h"
+#include "Tuples/NameMatcher.h"
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
-#include "InitTweak/GenInit.h"
 #include "ResolveTypeof.h"
 
@@ -65 +64 @@
         }
 
-        Cost sumCost( const AltList &in ) {
-                Cost total;
-                for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
-                        total += i->cost;
-                }
-                return total;
-        }
-
         namespace {
                 void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
@@ -85 +76 @@
                                 out.push_back( i->expr->clone() );
                         }
+                }
+
+                Cost sumCost( const AltList &in ) {
+                        Cost total;
+                        for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
+                                total += i->cost;
+                        }
+                        return total;
                 }
 
@@ -102 +101 @@
                                 PruneStruct current( candidate );
                                 std::string mangleName;
-                                {
-                                        Type * newType = candidate->expr->get_result()->clone();
+                                for ( std::list< Type* >::const_iterator retType = candidate->expr->get_results().begin(); retType != candidate->expr->get_results().end(); ++retType ) {
+                                        Type *newType = (*retType)->clone();
                                         candidate->env.apply( newType );
-                                        mangleName = SymTab::Mangler::mangle( newType );
+                                        mangleName += SymTab::Mangler::mangle( newType );
                                         delete newType;
                                 }
@@ -134 +133 @@
                                 if ( ! target->second.isAmbiguous ) {
                                         Alternative &alt = *target->second.candidate;
-                                        alt.env.applyFree( alt.expr->get_result() );
+                                        for ( std::list< Type* >::iterator result = alt.expr->get_results().begin(); result != alt.expr->get_results().end(); ++result ) {
+                                                alt.env.applyFree( *result );
+                                        }
                                         *out++ = alt;
                                 }
                         }
+
+                }
+
+                template< typename InputIterator, typename OutputIterator >
+                void findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
+                        AltList alternatives;
+
+                        // select the alternatives that have the minimum parameter cost
+                        Cost minCost = Cost::infinity;
+                        for ( AltList::iterator i = begin; i != end; ++i ) {
+                                if ( i->cost < minCost ) {
+                                        minCost = i->cost;
+                                        i->cost = i->cvtCost;
+                                        alternatives.clear();
+                                        alternatives.push_back( *i );
+                                } else if ( i->cost == minCost ) {
+                                        i->cost = i->cvtCost;
+                                        alternatives.push_back( *i );
+                                }
+                        }
+                        std::copy( alternatives.begin(), alternatives.end(), out );
+                }
+
+                template< typename InputIterator >
+                void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
+                        while ( begin != end ) {
+                                result.simpleCombine( (*begin++).env );
+                        }
                 }
 
                 void renameTypes( Expression *expr ) {
-                        expr->get_result()->accept( global_renamer );
+                        for ( std::list< Type* >::iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
+                                (*i)->accept( global_renamer );
+                        }
                 }
         }
@@ -173 +204 @@
                 for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
                         if ( adjust ) {
-                                adjustExprType( i->expr->get_result(), i->env, indexer );
+                                adjustExprTypeList( i->expr->get_results().begin(), i->expr->get_results().end(), i->env, indexer );
                         }
                 }
@@ -209 +240 @@
         }
 
-        // std::unordered_map< Expression *, UniqueExpr * > ;
-
         template< typename StructOrUnionType >
-        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
-                // by this point, member must be a name expr
-                NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member );
-                const std::string & name = nameExpr->get_name();
+        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name ) {
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
@@ -228 +254 @@
         }
 
-        void AlternativeFinder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
-                if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) {
-                        // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning
-                        // xxx - this should be improved by memoizing the value of constant exprs
-                        // during parsing and reusing that information here.
-                        std::stringstream ss( constantExpr->get_constant()->get_value() );
-                        int val;
-                        std::string tmp;
-                        if ( ss >> val && ! (ss >> tmp) ) {
-                                if ( val >= 0 && (unsigned int)val < tupleType->size() ) {
-                                        alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
-                                } // if
-                        } // if
-                } else if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ) ) {
-                        // xxx - temporary hack until 0/1 are int constants
-                        if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
-                                std::stringstream ss( nameExpr->get_name() );
-                                int val;
-                                ss >> val;
-                                alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
-                        }
-                } // if
-        }
-
         void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) {
                 alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
@@ -257 +259 @@
 
         Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
-                ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
-                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
-                FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                ApplicationExpr *appExpr = dynamic_cast< ApplicationExpr* >( alt.expr );
+                assert( appExpr );
+                PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
+                assert( pointer );
+                FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                assert( function );
 
                 Cost convCost( 0, 0, 0 );
@@ -265 +270 @@
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
                 std::list< Expression* >& actuals = appExpr->get_args();
-
-                std::list< Type * > formalTypes;
-                std::list< Type * >::iterator formalType = formalTypes.end();
-
                 for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
-
                         PRINT(
                                 std::cerr << "actual expression:" << std::endl;
                                 (*actualExpr)->print( std::cerr, 8 );
                                 std::cerr << "--- results are" << std::endl;
-                                (*actualExpr)->get_result()->print( std::cerr, 8 );
+                                printAll( (*actualExpr)->get_results(), std::cerr, 8 );
                         )
                         std::list< DeclarationWithType* >::iterator startFormal = formal;
                         Cost actualCost;
-                        std::list< Type * > flatActualTypes;
-                        flatten( (*actualExpr)->get_result(), back_inserter( flatActualTypes ) );
-                        for ( std::list< Type* >::iterator actualType = flatActualTypes.begin(); actualType != flatActualTypes.end(); ++actualType ) {
-
-
-                                // tuple handling code
-                                if ( formalType == formalTypes.end() ) {
-                                        // the type of the formal parameter may be a tuple type. To make this easier to work with,
-                                        // flatten the tuple type and traverse the resulting list of types, incrementing the formal
-                                        // iterator once its types have been extracted. Once a particular formal parameter's type has
-                                        // been exhausted load the next formal parameter's type.
-                                        if ( formal == formals.end() ) {
-                                                if ( function->get_isVarArgs() ) {
-                                                        convCost += Cost( 1, 0, 0 );
-                                                        break;
-                                                } else {
-                                                        return Cost::infinity;
-                                                }
+                        for ( std::list< Type* >::iterator actual = (*actualExpr)->get_results().begin(); actual != (*actualExpr)->get_results().end(); ++actual ) {
+                                if ( formal == formals.end() ) {
+                                        if ( function->get_isVarArgs() ) {
+                                                convCost += Cost( 1, 0, 0 );
+                                                break;
+                                        } else {
+                                                return Cost::infinity;
                                         }
-                                        formalTypes.clear();
-                                        flatten( (*formal)->get_type(), back_inserter( formalTypes ) );
-                                        formalType = formalTypes.begin();
-                                        ++formal;
                                 }
-
                                 PRINT(
                                         std::cerr << std::endl << "converting ";
-                                        (*actualType)->print( std::cerr, 8 );
+                                        (*actual)->print( std::cerr, 8 );
                                         std::cerr << std::endl << " to ";
                                         (*formal)->get_type()->print( std::cerr, 8 );
                                 )
-                                Cost newCost = conversionCost( *actualType, *formalType, indexer, alt.env );
+                                Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
                                 PRINT(
                                         std::cerr << std::endl << "cost is" << newCost << std::endl;
@@ -321 +305 @@
                                 actualCost += newCost;
 
-                                convCost += Cost( 0, polyCost( *formalType, alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
-
-                                formalType++;
+                                convCost += Cost( 0, polyCost( (*formal)->get_type(), alt.env, indexer ) + polyCost( *actual, alt.env, indexer ), 0 );
+
+                                formal++;
                         }
                         if ( actualCost != Cost( 0, 0, 0 ) ) {
@@ -372 +356 @@
         /// Adds type variables to the open variable set and marks their assertions
         void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
-                for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
+                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
                         unifiableVars[ (*tyvar)->get_name() ] = (*tyvar)->get_kind();
                         for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
@@ -381 +365 @@
         }
 
-        /// instantiate a single argument by matching actuals from [actualIt, actualEnd) against formalType,
-        /// producing expression(s) in out and their total cost in cost.
-        template< typename AltIterator, typename OutputIterator >
-        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 ) {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * >( formalType ) ) {
-                        // formalType is a TupleType - group actuals into a TupleExpr whose type unifies with the TupleType
-                        TupleExpr * tupleExpr = new TupleExpr();
-                        for ( Type * type : *tupleType ) {
-                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( tupleExpr->get_exprs() ) ) ) {
-                                        delete tupleExpr;
-                                        return false;
-                                }
-                        }
-                        tupleExpr->set_result( Tuples::makeTupleType( tupleExpr->get_exprs() ) );
-                        *out++ = tupleExpr;
-                } else if ( actualIt != actualEnd ) {
-                        // both actualType and formalType are atomic (non-tuple) types - if they unify
-                        // then accept actual as an argument, otherwise return false (fail to instantiate argument)
-                        Expression * actual = actualIt->expr;
-                        Type * actualType = actual->get_result();
-                        PRINT(
-                                std::cerr << "formal type is ";
-                                formalType->print( std::cerr );
-                                std::cerr << std::endl << "actual type is ";
-                                actualType->print( std::cerr );
-                                std::cerr << std::endl;
-                        )
-                        if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
-                                return false;
-                        }
-                        // move the expression from the alternative to the output iterator
-                        *out++ = actual;
-                        actualIt->expr = nullptr;
-                        cost += actualIt->cost;
-                        ++actualIt;
-                } else {
-                        // End of actuals - Handle default values
-                        if ( SingleInit *si = dynamic_cast<SingleInit *>( defaultValue )) {
-                                // so far, only constant expressions are accepted as default values
-                                if ( ConstantExpr *cnstexpr = dynamic_cast<ConstantExpr *>( si->get_value()) ) {
-                                        if ( Constant *cnst = dynamic_cast<Constant *>( cnstexpr->get_constant() ) ) {
-                                                if ( unify( formalType, cnst->get_type(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
-                                                        // xxx - Don't know if this is right
-                                                        *out++ = cnstexpr->clone();
-                                                        return true;
-                                                } // if
-                                        } // if
-                                } // if
-                        } // if
-                        return false;
-                } // if
-                return true;
-        }
-
-        bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, const AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave, AltList & out ) {
+        bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave ) {
                 simpleCombineEnvironments( actuals.begin(), actuals.end(), resultEnv );
                 // make sure we don't widen any existing bindings
@@ -443 +373 @@
                 resultEnv.extractOpenVars( openVars );
 
-                // flatten actuals so that each actual has an atomic (non-tuple) type
-                AltList exploded;
-                Tuples::explode( actuals, indexer, back_inserter( exploded ) );
-
-                AltList::iterator actualExpr = exploded.begin();
-                AltList::iterator actualEnd = exploded.end();
-                for ( DeclarationWithType * formal : formals ) {
-                        // match flattened actuals with formal parameters - actuals will be grouped to match
-                        // with formals as appropriate
-                        Cost cost;
-                        std::list< Expression * > newExprs;
-                        ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
-                        if ( ! instantiateArgument( obj->get_type(), obj->get_init(), actualExpr, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( newExprs ) ) ) {
-                                deleteAll( newExprs );
-                                return false;
-                        }
-                        // success - produce argument as a new alternative
-                        assert( newExprs.size() == 1 );
-                        out.push_back( Alternative( newExprs.front(), resultEnv, cost ) );
-                }
-                if ( actualExpr != actualEnd ) {
-                        // there are still actuals remaining, but we've run out of formal parameters to match against
-                        // this is okay only if the function is variadic
-                        if ( ! isVarArgs ) {
-                                return false;
-                        }
-                        out.splice( out.end(), exploded, actualExpr, actualEnd );
+                /*
+                  Tuples::NameMatcher matcher( formals );
+                  try {
+                  matcher.match( actuals );
+                  } catch ( Tuples::NoMatch &e ) {
+                  std::cerr << "Alternative doesn't match: " << e.message << std::endl;
+                  }
+                */
+                std::list< DeclarationWithType* >::iterator formal = formals.begin();
+                for ( AltList::const_iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
+                        for ( std::list< Type* >::iterator actual = actualExpr->expr->get_results().begin(); actual != actualExpr->expr->get_results().end(); ++actual ) {
+                                if ( formal == formals.end() ) {
+                                        return isVarArgs;
+                                }
+                                PRINT(
+                                        std::cerr << "formal type is ";
+                                        (*formal)->get_type()->print( std::cerr );
+                                        std::cerr << std::endl << "actual type is ";
+                                        (*actual)->print( std::cerr );
+                                        std::cerr << std::endl;
+                                )
+                                if ( ! unify( (*formal)->get_type(), *actual, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                        return false;
+                                }
+                                formal++;
+                        }
+                }
+                // Handling of default values
+                while ( formal != formals.end() ) {
+                        if ( ObjectDecl *od = dynamic_cast<ObjectDecl *>( *formal ) )
+                                if ( SingleInit *si = dynamic_cast<SingleInit *>( od->get_init() ))
+                                        // so far, only constant expressions are accepted as default values
+                                        if ( ConstantExpr *cnstexpr = dynamic_cast<ConstantExpr *>( si->get_value()) )
+                                                if ( Constant *cnst = dynamic_cast<Constant *>( cnstexpr->get_constant() ) )
+                                                        if ( unify( (*formal)->get_type(), cnst->get_type(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                                                // XXX Don't know if this is right
+                                                                actuals.push_back( Alternative( cnstexpr->clone(), env, Cost::zero ) );
+                                                                formal++;
+                                                                if ( formal == formals.end()) break;
+                                                        }
+                        return false;
                 }
                 return true;
@@ -556 +500 @@
                                 //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
                                 Expression *varExpr = new VariableExpr( candDecl );
-                                delete varExpr->get_result();
-                                varExpr->set_result( adjType->clone() );
+                                deleteAll( varExpr->get_results() );
+                                varExpr->get_results().clear();
+                                varExpr->get_results().push_front( adjType->clone() );
                                 PRINT(
                                         std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
@@ -600 +545 @@
 
         template< typename OutputIterator >
-        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const AltList &actualAlt, OutputIterator out ) {
+        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, AltList &actualAlt, OutputIterator out ) {
                 OpenVarSet openVars;
                 AssertionSet resultNeed, resultHave;
                 TypeEnvironment resultEnv;
                 makeUnifiableVars( funcType, openVars, resultNeed );
-                AltList instantiatedActuals; // filled by instantiate function
-                if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave, instantiatedActuals ) ) {
+                if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave ) ) {
                         ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
-                        Alternative newAlt( appExpr, resultEnv, sumCost( instantiatedActuals ) );
-                        makeExprList( instantiatedActuals, appExpr->get_args() );
+                        Alternative newAlt( appExpr, resultEnv, sumCost( actualAlt ) );
+                        makeExprList( actualAlt, appExpr->get_args() );
                         PRINT(
                                 std::cerr << "need assertions:" << std::endl;
@@ -630 +574 @@
                                 PointerType pt( Type::Qualifiers(), v.clone() );
                                 UntypedExpr *vexpr = untypedExpr->clone();
-                                vexpr->set_result( pt.clone() );
+                                vexpr->get_results().push_front( pt.clone() );
                                 alternatives.push_back( Alternative( vexpr, env, Cost()) );
                                 return;
@@ -643 +587 @@
                 combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
 
-                // take care of possible tuple assignments
-                // if not tuple assignment, assignment is taken care of as a normal function call
-                Tuples::handleTupleAssignment( *this, untypedExpr, possibilities );
+                Tuples::TupleAssignSpotter tassign( this );
+                if ( tassign.isTupleAssignment( untypedExpr, possibilities ) ) {
+                        // take care of possible tuple assignments, or discard expression
+                        return;
+                } // else ...
 
                 AltList candidates;
@@ -658 +604 @@
                                 // check if the type is pointer to function
                                 PointerType *pointer;
-                                if ( ( pointer = dynamic_cast< PointerType* >( func->expr->get_result() ) ) ) {
+                                if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
@@ -694 +640 @@
                                                 // check if the type is pointer to function
                                                 PointerType *pointer;
-                                                if ( ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result() ) ) ) {
+                                                if ( funcOp->expr->get_results().size() == 1
+                                                        && ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_results().front() ) ) ) {
                                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
                                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
@@ -718 +665 @@
 
                         PRINT(
-                                ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( withFunc->expr );
-                                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
-                                FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                                ApplicationExpr *appExpr = dynamic_cast< ApplicationExpr* >( withFunc->expr );
+                                assert( appExpr );
+                                PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
+                                assert( pointer );
+                                FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+                                assert( function );
                                 std::cerr << "Case +++++++++++++" << std::endl;
                                 std::cerr << "formals are:" << std::endl;
@@ -742 +692 @@
 
         bool isLvalue( Expression *expr ) {
-                // xxx - recurse into tuples?
-                return expr->has_result() && expr->get_result()->get_isLvalue();
+                for ( std::list< Type* >::const_iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
+                        if ( !(*i)->get_isLvalue() ) return false;
+                } // for
+                return true;
         }
 
@@ -757 +709 @@
 
         void AlternativeFinder::visit( CastExpr *castExpr ) {
-                Type *& toType = castExpr->get_result();
-                toType = resolveTypeof( toType, indexer );
-                SymTab::validateType( toType, &indexer );
-                adjustExprType( toType, env, indexer );
+                for ( std::list< Type* >::iterator i = castExpr->get_results().begin(); i != castExpr->get_results().end(); ++i ) {
+                        *i = resolveTypeof( *i, indexer );
+                        SymTab::validateType( *i, &indexer );
+                        adjustExprType( *i, env, indexer );
+                } // for
 
                 AlternativeFinder finder( indexer, env );
@@ -774 +727 @@
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
-                        int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
+                        int discardedValues = (*i).expr->get_results().size() - castExpr->get_results().size();
                         if ( discardedValues < 0 ) continue;
-                        // xxx - may need to go into tuple types and extract relavent types and use unifyList
+                        std::list< Type* >::iterator candidate_end = (*i).expr->get_results().begin();
+                        std::advance( candidate_end, castExpr->get_results().size() );
                         // unification run for side-effects
-                        unify( castExpr->get_result(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
-                        Cost thisCost = castCost( (*i).expr->get_result(), castExpr->get_result(), indexer, i->env );
+                        unifyList( castExpr->get_results().begin(), castExpr->get_results().end(),
+                                           (*i).expr->get_results().begin(), candidate_end,
+                                   i->env, needAssertions, haveAssertions, openVars, indexer );
+                        Cost thisCost = castCostList( (*i).expr->get_results().begin(), candidate_end,
+                                                                                  castExpr->get_results().begin(), castExpr->get_results().end(),
+                                                                                  indexer, i->env );
                         if ( thisCost != Cost::infinity ) {
                                 // count one safe conversion for each value that is thrown away
@@ -802 +760 @@
 
                 for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
-                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
-                                addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
-                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) {
-                                addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
-                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( agg->expr->get_result() ) ) {
-                                addTupleMembers( tupleType, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        if ( agg->expr->get_results().size() == 1 ) {
+                                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
+                                        addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
+                                        addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                                } // if
                         } // if
                 } // for
@@ -833 +791 @@
                         renameTypes( alternatives.back().expr );
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
-                                NameExpr nameExpr( "" );
-                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
+                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
-                                NameExpr nameExpr( "" );
-                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
+                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
                         } // if
                 } // for
@@ -938 +894 @@
                         alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
                         for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
-                                alternatives.back().expr->set_result( (*i)->get_type()->clone() );
+                                alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
                         } // for
                 } // if
@@ -961 +917 @@
                                                         finder.find( attrExpr->get_expr() );
                                                         for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
-                                                                if ( choice->expr->get_result()->size() == 1 ) {
-                                                                        resolveAttr(*i, function, choice->expr->get_result(), choice->env );
+                                                                if ( choice->expr->get_results().size() == 1 ) {
+                                                                        resolveAttr(*i, function, choice->expr->get_results().front(), choice->env );
                                                                 } // fi
                                                         } // for
@@ -1004 +960 @@
                                         AssertionSet needAssertions, haveAssertions;
                                         Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );
-                                        Type* commonType;
-                                        if ( unify( second->expr->get_result(), third->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
+                                        std::list< Type* > commonTypes;
+                                        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 ) ) {
                                                 ConditionalExpr *newExpr = new ConditionalExpr( first->expr->clone(), second->expr->clone(), third->expr->clone() );
-                                                newExpr->set_result( commonType ? commonType : second->expr->get_result()->clone() );
+                                                std::list< Type* >::const_iterator original = second->expr->get_results().begin();
+                                                std::list< Type* >::const_iterator commonType = commonTypes.begin();
+                                                for ( ; original != second->expr->get_results().end() && commonType != commonTypes.end(); ++original, ++commonType ) {
+                                                        if ( *commonType ) {
+                                                                newExpr->get_results().push_back( *commonType );
+                                                        } else {
+                                                                newExpr->get_results().push_back( (*original)->clone() );
+                                                        } // if
+                                                } // for
                                                 newAlt.expr = newExpr;
                                                 inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );
@@ -1035 +999 @@
                         TupleExpr *newExpr = new TupleExpr;
                         makeExprList( *i, newExpr->get_exprs() );
-                        newExpr->set_result( Tuples::makeTupleType( newExpr->get_exprs() ) );
+                        for ( std::list< Expression* >::const_iterator resultExpr = newExpr->get_exprs().begin(); resultExpr != newExpr->get_exprs().end(); ++resultExpr ) {
+                                for ( std::list< Type* >::const_iterator resultType = (*resultExpr)->get_results().begin(); resultType != (*resultExpr)->get_results().end(); ++resultType ) {
+                                        newExpr->get_results().push_back( (*resultType)->clone() );
+                                } // for
+                        } // for
 
                         TypeEnvironment compositeEnv;
@@ -1056 +1024 @@
                 }
         }
-
-        void AlternativeFinder::visit( TupleIndexExpr *tupleExpr ) {
-                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
-        }
-
-        void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) {
-                alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
-        }
-
-        void AlternativeFinder::visit( UniqueExpr *unqExpr ) {
-                AlternativeFinder finder( indexer, env );
-                finder.findWithAdjustment( unqExpr->get_expr() );
-                for ( Alternative & alt : finder.alternatives ) {
-                        // ensure that the id is passed on to the UniqueExpr alternative so that the expressions are "linked"
-                        UniqueExpr * newUnqExpr = new UniqueExpr( alt.expr->clone(), unqExpr->get_id() );
-                        alternatives.push_back( Alternative( newUnqExpr, alt.env, alt.cost ) );
-                }
-        }
-
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.h

@@ -67 +67 @@
                 virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
                 virtual void visit( ConstructorExpr * ctorExpr );
-                virtual void visit( TupleIndexExpr *tupleExpr );
-                virtual void visit( TupleAssignExpr *tupleExpr );
-                virtual void visit( UniqueExpr *unqExpr );
-                /// Runs a new alternative finder on each element in [begin, end)
-                /// and writes each alternative finder to out.
+          public:  // xxx - temporary hack - should make Tuples::TupleAssignment a friend
                 template< typename InputIterator, typename OutputIterator >
                 void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
 
+          private:
                 /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
-                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
-                /// Adds alternatives for member expressions where the left side has tuple type
-                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
+                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name );
                 /// Adds alternatives for offsetof expressions, given the base type and name of the member
                 template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
-                bool instantiateFunction( std::list< DeclarationWithType* >& formals, const AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave, AltList & out );
+                bool instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave );
                 template< typename OutputIterator >
-                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const AltList &actualAlt, OutputIterator out );
+                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, AltList &actualAlt, OutputIterator out );
                 template< typename OutputIterator >
                 void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
@@ -94 +89 @@
 
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
-
-        template< typename InputIterator, typename OutputIterator >
-        void findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
-                AltList alternatives;
-
-                // select the alternatives that have the minimum parameter cost
-                Cost minCost = Cost::infinity;
-                for ( InputIterator i = begin; i != end; ++i ) {
-                        if ( i->cost < minCost ) {
-                                minCost = i->cost;
-                                i->cost = i->cvtCost;
-                                alternatives.clear();
-                                alternatives.push_back( *i );
-                        } else if ( i->cost == minCost ) {
-                                i->cost = i->cvtCost;
-                                alternatives.push_back( *i );
-                        }
-                }
-                std::copy( alternatives.begin(), alternatives.end(), out );
-        }
-
-        Cost sumCost( const AltList &in );
-
-        template< typename InputIterator >
-        void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
-                while ( begin != end ) {
-                        result.simpleCombine( (*begin++).env );
-                }
-        }
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativePrinter.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// AlternativePrinter.cc --
+// AlternativePrinter.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -33 +33 @@
                 for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
                         os << "Alternative " << count++ << " ==============" << std::endl;
-                        i->expr->get_result()->print( os );
+                        printAll( i->expr->get_results(), os );
                         //    i->print( os );
                         os << std::endl;

src/ResolvExpr/ConversionCost.cc

@@ -240 +240 @@
                         std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
                         std::list< Type* >::const_iterator destIt = destAsTuple->get_types().begin();
-                        while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
+                        while ( srcIt != tupleType->get_types().end() ) {
                                 Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
                                 if ( newCost == Cost::infinity ) {

src/ResolvExpr/FindOpenVars.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FindOpenVars.cc --
+// FindOpenVars.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -47 +47 @@
         void FindOpenVars::common_action( Type *type ) {
                 if ( nextIsOpen ) {
-                        for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( std::list< TypeDecl* >::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 openVars[ (*i)->get_name() ] = (*i)->get_kind();
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {
@@ -56 +56 @@
                         }
                 } else {
-                        for ( Type::ForallList::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( std::list< TypeDecl* >::const_iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 closedVars[ (*i)->get_name() ] = (*i)->get_kind();
                                 for ( std::list< DeclarationWithType* >::const_iterator assert = (*i)->get_assertions().begin(); assert != (*i)->get_assertions().end(); ++assert ) {

src/ResolvExpr/RenameVars.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// RenameVars.cc --
+// RenameVars.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -125 +125 @@
                         mapStack.push_front( mapStack.front() );
                         // renames all "forall" type names to `_${level}_${name}'
-                        for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 std::ostringstream output;
                                 output << "_" << level << "_" << (*i)->get_name();

src/ResolvExpr/ResolveTypeof.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ResolveTypeof.cc --
+// ResolveTypeof.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -58 +58 @@
                 if ( typeofType->get_expr() ) {
                         Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer );
-                        assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
-                        Type *newType = newExpr->get_result();
+                        assert( newExpr->get_results().size() > 0 );
+                        Type *newType;
+                        if ( newExpr->get_results().size() > 1 ) {
+                                TupleType *tupleType = new TupleType( Type::Qualifiers() );
+                                cloneAll( newExpr->get_results(), tupleType->get_types() );
+                                newType = tupleType;
+                        } else {
+                                newType = newExpr->get_results().front()->clone();
+                        } // if
                         delete typeofType;
                         return newType;

src/ResolvExpr/Resolver.cc

@@ -19 +19 @@
 #include "RenameVars.h"
 #include "ResolveTypeof.h"
-#include "typeops.h"
 #include "SynTree/Statement.h"
 #include "SynTree/Type.h"
@@ -69 +68 @@
           void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator & );
           void fallbackInit( ConstructorInit * ctorInit );
-
-                Type * functionReturn = nullptr;
-                Type *initContext = nullptr;
-                Type *switchType = nullptr;
+                std::list< Type * > functionReturn;
+                Type *initContext;
                 bool inEnumDecl = false;
         };
@@ -160 +157 @@
                         const TypeEnvironment *newEnv = 0;
                         for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) {
+                                if ( i->expr->get_results().size() == 1 && isIntegralType( i->expr->get_results().front() ) ) {
                                         if ( newExpr ) {
                                                 throw SemanticError( "Too many interpretations for case control expression", untyped );
@@ -237 +234 @@
                 Type *new_type = resolveTypeof( functionDecl->get_type(), *this );
                 functionDecl->set_type( new_type );
-                ValueGuard< Type * > oldFunctionReturn( functionReturn );
-                functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
+                std::list< Type * > oldFunctionReturn = functionReturn;
+                functionReturn.clear();
+                for ( std::list< DeclarationWithType * >::const_iterator i = functionDecl->get_functionType()->get_returnVals().begin(); i != functionDecl->get_functionType()->get_returnVals().end(); ++i ) {
+                        functionReturn.push_back( (*i)->get_type() );
+                } // for
                 SymTab::Indexer::visit( functionDecl );
+                functionReturn = oldFunctionReturn;
         }
 
@@ -337 +338 @@
         void Resolver::visit( ReturnStmt *returnStmt ) {
                 if ( returnStmt->get_expr() ) {
-                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr(), functionReturn->clone() );
+                        CastExpr *castExpr = new CastExpr( returnStmt->get_expr() );
+                        cloneAll( functionReturn, castExpr->get_results() );
                         Expression *newExpr = findSingleExpression( castExpr, *this );
                         delete castExpr;
@@ -382 +384 @@
                                 if ( isCharType( at->get_base() ) ) {
                                         // check if the resolved type is char *
-                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
+                                        if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_results().front() ) ) {
                                                 if ( isCharType( pt->get_base() ) ) {
                                                         // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
@@ -444 +446 @@
                                 (*iter)->accept( *this );
                         } // for
-                } else if ( TupleType * tt = dynamic_cast< TupleType * > ( initContext ) ) {
-                        for ( Type * t : *tt ) {
-                                if ( iter == end ) break;
-                                initContext = t;
-                                (*iter++)->accept( *this );
-                        }
                 } else if ( StructInstType * st = dynamic_cast< StructInstType * >( initContext ) ) {
                         resolveAggrInit( st->get_baseStruct(), iter, end );

src/ResolvExpr/TypeEnvironment.cc

@@ -158 +158 @@
         }
 
-        void TypeEnvironment::add( const Type::ForallList &tyDecls ) {
-                for ( Type::ForallList::const_iterator i = tyDecls.begin(); i != tyDecls.end(); ++i ) {
+        void TypeEnvironment::add( const std::list< TypeDecl* > &tyDecls ) {
+                for ( std::list< TypeDecl* >::const_iterator i = tyDecls.begin(); i != tyDecls.end(); ++i ) {
                         EqvClass newClass;
                         newClass.vars.insert( (*i)->get_name() );

src/ResolvExpr/TypeEnvironment.h

@@ -55 +55 @@
                 bool lookup( const std::string &var, EqvClass &eqvClass ) const;
                 void add( const EqvClass &eqvClass );
-                void add( const Type::ForallList &tyDecls );
+                void add( const std::list< TypeDecl* > &tyDecls );
                 template< typename SynTreeClass > int apply( SynTreeClass *&type ) const;
                 template< typename SynTreeClass > int applyFree( SynTreeClass *&type ) const;

src/ResolvExpr/Unify.cc

@@ -597 +597 @@
         }
 
-        // xxx - compute once and store in the FunctionType?
-        Type * extractResultType( FunctionType * function ) {
-                if ( function->get_returnVals().size() == 0 ) {
-                        return new VoidType( Type::Qualifiers() );
-                } else if ( function->get_returnVals().size() == 1 ) {
-                        return function->get_returnVals().front()->get_type()->clone();
-                } else {
-                        TupleType * tupleType = new TupleType( Type::Qualifiers() );
-                        for ( DeclarationWithType * decl : function->get_returnVals() ) {
-                                tupleType->get_types().push_back( decl->get_type()->clone() );
-                        } // for
-                        return tupleType;
-                }
-        }
 } // namespace ResolvExpr
 

src/ResolvExpr/typeops.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// typeops.h --
+// typeops.h -- 
 //
 // Author           : Richard C. Bilson
@@ -30 +30 @@
                 typedef typename InputIterator::value_type SetType;
                 typedef typename std::list< typename SetType::value_type > ListType;
-
+  
                 if ( begin == end )     {
                         *out++ = ListType();
                         return;
                 } // if
-
+  
                 InputIterator current = begin;
                 begin++;
@@ -41 +41 @@
                 std::list< ListType > recursiveResult;
                 combos( begin, end, back_inserter( recursiveResult ) );
-
+  
                 for ( typename std::list< ListType >::const_iterator i = recursiveResult.begin(); i != recursiveResult.end(); ++i ) {
                         for ( typename ListType::const_iterator j = current->begin(); j != current->end(); ++j ) {
@@ -52 +52 @@
                 } // for
         }
-
+  
         // in AdjustExprType.cc
         /// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
@@ -144 +144 @@
         }
 
-        /// creates the type represented by the list of returnVals in a FunctionType. The caller owns the return value.
-        Type * extractResultType( FunctionType * functionType );
-
         // in CommonType.cc
         Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
@@ -155 +152 @@
         // in Occurs.cc
         bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
-
-        // flatten tuple type into list of types
-        template< typename OutputIterator >
-        void flatten( Type * type, OutputIterator out ) {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
-                        for ( Type * t : tupleType->get_types() ) {
-                                flatten( t, out );
-                        }
-                } else {
-                        *out++ = type;
-                }
-        }
 } // namespace ResolvExpr
 

src/SymTab/Autogen.cc

@@ -116 +116 @@
                 // This happens before function pointer type conversion, so need to do it manually here
                 VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
-                Type * assignVarExprType = assignVarExpr->get_result();
+                Type *& assignVarExprType = assignVarExpr->get_results().front();
                 assignVarExprType = new PointerType( Type::Qualifiers(), assignVarExprType );
-                assignVarExpr->set_result( assignVarExprType );
                 ApplicationExpr * assignExpr = new ApplicationExpr( assignVarExpr );
                 assignExpr->get_args().push_back( new VariableExpr( dstParam ) );

src/SymTab/Indexer.cc

@@ -40 +40 @@
 
 namespace SymTab {
-        template< typename TreeType, typename VisitorType >
-        inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
+        template< typename Container, typename VisitorType >
+        inline void acceptAllNewScope( Container &container, VisitorType &visitor ) {
                 visitor.enterScope();
-                maybeAccept( tree, visitor );
+                acceptAll( container, visitor );
                 visitor.leaveScope();
         }
@@ -143 +143 @@
                 for ( DeclarationWithType * decl : copy ) {
                         if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl ) ) {
-                                std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
+                                std::list< DeclarationWithType * > params = function->get_functionType()->get_parameters();
                                 assert( ! params.empty() );
                                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
@@ -337 +337 @@
 
         void Indexer::visit( ApplicationExpr *applicationExpr ) {
-                acceptNewScope( applicationExpr->get_result(), *this );
+                acceptAllNewScope( applicationExpr->get_results(), *this );
                 maybeAccept( applicationExpr->get_function(), *this );
                 acceptAll( applicationExpr->get_args(), *this );
@@ -343 +343 @@
 
         void Indexer::visit( UntypedExpr *untypedExpr ) {
-                acceptNewScope( untypedExpr->get_result(), *this );
+                acceptAllNewScope( untypedExpr->get_results(), *this );
                 acceptAll( untypedExpr->get_args(), *this );
         }
 
         void Indexer::visit( NameExpr *nameExpr ) {
-                acceptNewScope( nameExpr->get_result(), *this );
+                acceptAllNewScope( nameExpr->get_results(), *this );
         }
 
         void Indexer::visit( AddressExpr *addressExpr ) {
-                acceptNewScope( addressExpr->get_result(), *this );
+                acceptAllNewScope( addressExpr->get_results(), *this );
                 maybeAccept( addressExpr->get_arg(), *this );
         }
 
         void Indexer::visit( LabelAddressExpr *labAddressExpr ) {
-                acceptNewScope( labAddressExpr->get_result(), *this );
+                acceptAllNewScope( labAddressExpr->get_results(), *this );
                 maybeAccept( labAddressExpr->get_arg(), *this );
         }
 
         void Indexer::visit( CastExpr *castExpr ) {
-                acceptNewScope( castExpr->get_result(), *this );
+                acceptAllNewScope( castExpr->get_results(), *this );
                 maybeAccept( castExpr->get_arg(), *this );
         }
 
         void Indexer::visit( UntypedMemberExpr *memberExpr ) {
-                acceptNewScope( memberExpr->get_result(), *this );
+                acceptAllNewScope( memberExpr->get_results(), *this );
                 maybeAccept( memberExpr->get_aggregate(), *this );
         }
 
         void Indexer::visit( MemberExpr *memberExpr ) {
-                acceptNewScope( memberExpr->get_result(), *this );
+                acceptAllNewScope( memberExpr->get_results(), *this );
                 maybeAccept( memberExpr->get_aggregate(), *this );
         }
 
         void Indexer::visit( VariableExpr *variableExpr ) {
-                acceptNewScope( variableExpr->get_result(), *this );
+                acceptAllNewScope( variableExpr->get_results(), *this );
         }
 
         void Indexer::visit( ConstantExpr *constantExpr ) {
-                acceptNewScope( constantExpr->get_result(), *this );
+                acceptAllNewScope( constantExpr->get_results(), *this );
                 maybeAccept( constantExpr->get_constant(), *this );
         }
 
         void Indexer::visit( SizeofExpr *sizeofExpr ) {
-                acceptNewScope( sizeofExpr->get_result(), *this );
+                acceptAllNewScope( sizeofExpr->get_results(), *this );
                 if ( sizeofExpr->get_isType() ) {
                         maybeAccept( sizeofExpr->get_type(), *this );
@@ -395 +395 @@
 
         void Indexer::visit( AlignofExpr *alignofExpr ) {
-                acceptNewScope( alignofExpr->get_result(), *this );
+                acceptAllNewScope( alignofExpr->get_results(), *this );
                 if ( alignofExpr->get_isType() ) {
                         maybeAccept( alignofExpr->get_type(), *this );
@@ -404 +404 @@
 
         void Indexer::visit( UntypedOffsetofExpr *offsetofExpr ) {
-                acceptNewScope( offsetofExpr->get_result(), *this );
+                acceptAllNewScope( offsetofExpr->get_results(), *this );
                 maybeAccept( offsetofExpr->get_type(), *this );
         }
 
         void Indexer::visit( OffsetofExpr *offsetofExpr ) {
-                acceptNewScope( offsetofExpr->get_result(), *this );
+                acceptAllNewScope( offsetofExpr->get_results(), *this );
                 maybeAccept( offsetofExpr->get_type(), *this );
                 maybeAccept( offsetofExpr->get_member(), *this );
@@ -415 +415 @@
 
         void Indexer::visit( OffsetPackExpr *offsetPackExpr ) {
-                acceptNewScope( offsetPackExpr->get_result(), *this );
+                acceptAllNewScope( offsetPackExpr->get_results(), *this );
                 maybeAccept( offsetPackExpr->get_type(), *this );
         }
 
         void Indexer::visit( AttrExpr *attrExpr ) {
-                acceptNewScope( attrExpr->get_result(), *this );
+                acceptAllNewScope( attrExpr->get_results(), *this );
                 if ( attrExpr->get_isType() ) {
                         maybeAccept( attrExpr->get_type(), *this );
@@ -429 +429 @@
 
         void Indexer::visit( LogicalExpr *logicalExpr ) {
-                acceptNewScope( logicalExpr->get_result(), *this );
+                acceptAllNewScope( logicalExpr->get_results(), *this );
                 maybeAccept( logicalExpr->get_arg1(), *this );
                 maybeAccept( logicalExpr->get_arg2(), *this );
@@ -435 +435 @@
 
         void Indexer::visit( ConditionalExpr *conditionalExpr ) {
-                acceptNewScope( conditionalExpr->get_result(), *this );
+                acceptAllNewScope( conditionalExpr->get_results(), *this );
                 maybeAccept( conditionalExpr->get_arg1(), *this );
                 maybeAccept( conditionalExpr->get_arg2(), *this );
@@ -442 +442 @@
 
         void Indexer::visit( CommaExpr *commaExpr ) {
-                acceptNewScope( commaExpr->get_result(), *this );
+                acceptAllNewScope( commaExpr->get_results(), *this );
                 maybeAccept( commaExpr->get_arg1(), *this );
                 maybeAccept( commaExpr->get_arg2(), *this );
@@ -448 +448 @@
 
         void Indexer::visit( TupleExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
+                acceptAllNewScope( tupleExpr->get_results(), *this );
                 acceptAll( tupleExpr->get_exprs(), *this );
         }
 
-        void Indexer::visit( TupleAssignExpr *tupleExpr ) {
-                acceptNewScope( tupleExpr->get_result(), *this );
-                enterScope();
-                acceptAll( tupleExpr->get_tempDecls(), *this );
-                acceptAll( tupleExpr->get_assigns(), *this );
-                leaveScope();
+        void Indexer::visit( SolvedTupleExpr *tupleExpr ) {
+                acceptAllNewScope( tupleExpr->get_results(), *this );
+                acceptAll( tupleExpr->get_exprs(), *this );
         }
 
         void Indexer::visit( TypeExpr *typeExpr ) {
-                acceptNewScope( typeExpr->get_result(), *this );
+                acceptAllNewScope( typeExpr->get_results(), *this );
                 maybeAccept( typeExpr->get_type(), *this );
         }
@@ -472 +469 @@
 
         void Indexer::visit( UntypedValofExpr *valofExpr ) {
-                acceptNewScope( valofExpr->get_result(), *this );
+                acceptAllNewScope( valofExpr->get_results(), *this );
                 maybeAccept( valofExpr->get_body(), *this );
         }

src/SymTab/Indexer.h

@@ -64 +64 @@
                 virtual void visit( ConditionalExpr *conditionalExpr );
                 virtual void visit( CommaExpr *commaExpr );
+                virtual void visit( TupleExpr *tupleExpr );
+                virtual void visit( SolvedTupleExpr *tupleExpr );
                 virtual void visit( TypeExpr *typeExpr );
                 virtual void visit( AsmExpr *asmExpr );
                 virtual void visit( UntypedValofExpr *valofExpr );
-                virtual void visit( TupleExpr *tupleExpr );
-                virtual void visit( TupleAssignExpr *tupleExpr );
 
                 virtual void visit( TraitInstType *contextInst );

src/SymTab/Mangler.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Mangler.cc --
+// Mangler.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -35 +35 @@
                 return mangler.get_mangleName();
         }
-
+        
         Mangler::Mangler( bool mangleOverridable, bool typeMode )
                 : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {}
-
+                
         Mangler::Mangler( const Mangler &rhs ) : mangleName() {
                 varNums = rhs.varNums;
@@ -115 +115 @@
                         "Ir",   // LongDoubleImaginary
                 };
-
+  
                 printQualifiers( basicType );
                 mangleName << btLetter[ basicType->get_kind() ];
@@ -253 +253 @@
                 // skip if not including qualifiers
                 if ( typeMode ) return;
-
+                
                 if ( ! type->get_forall().empty() ) {
                         std::list< std::string > assertionNames;
                         int tcount = 0, dcount = 0, fcount = 0;
                         mangleName << "A";
-                        for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                        for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 switch ( (*i)->get_kind() ) {
                                   case TypeDecl::Any:

src/SymTab/Validate.cc

@@ -23 +23 @@
 // - All enumeration constants have type EnumInstType.
 //
-// - The type "void" never occurs in lists of function parameter or return types.  A function
-//   taking no arguments has no argument types.
+// - The type "void" never occurs in lists of function parameter or return types; neither do tuple types.  A function
+//   taking no arguments has no argument types, and tuples are flattened.
 //
 // - No context instances exist; they are all replaced by the set of declarations signified by the context, instantiated
@@ -243 +243 @@
                 return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
         }
-        // xxx - shouldn't this be declsToAddBefore?
+
         template< typename AggDecl >
         void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
@@ -431 +431 @@
         /// Fix up assertions
         void forallFixer( Type *func ) {
-                for ( Type::ForallList::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
+                for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
                         std::list< DeclarationWithType * > toBeDone, nextRound;
                         toBeDone.splice( toBeDone.end(), (*type )->get_assertions() );

src/SynTree/AddressExpr.cc

@@ -19 +19 @@
 
 AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
-        if ( arg->has_result() ) {
-                set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
-        }
+        for ( std::list< Type* >::const_iterator i = arg->get_results().begin(); i != arg->get_results().end(); ++i ) {
+                get_results().push_back( new PointerType( Type::Qualifiers(), (*i)->clone() ) );
+        } // for
 }
 
@@ -35 +35 @@
         if ( arg ) {
                 os << std::string( indent+2, ' ' );
-                arg->print( os, indent+2 );
+    arg->print( os, indent+2 );
         } // if
 }

src/SynTree/ApplicationExpr.cc

@@ -21 +21 @@
 #include "TypeSubstitution.h"
 #include "Common/utility.h"
-#include "ResolvExpr/typeops.h"
+
 
 ParamEntry::ParamEntry( const ParamEntry &other ) :
@@ -43 +43 @@
 
 ApplicationExpr::ApplicationExpr( Expression *funcExpr ) : function( funcExpr ) {
-        PointerType *pointer = safe_dynamic_cast< PointerType* >( funcExpr->get_result() );
-        FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+        PointerType *pointer = dynamic_cast< PointerType* >( funcExpr->get_results().front() );
+        assert( pointer );
+        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+        assert( function );
 
-        set_result( ResolvExpr::extractResultType( function ) );
-
-        assert( has_result() );
+        for ( std::list< DeclarationWithType* >::const_iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
+                get_results().push_back( (*i)->get_type()->clone() );
+        } // for
 }
 

src/SynTree/CommaExpr.cc

@@ -23 +23 @@
         // to false on all result types. Actually doing this causes some strange things
         // to happen in later passes (particularly, Specialize, Lvalue, and Box). This needs to be looked into.
-        set_result( maybeClone( arg2->get_result() ) );
-        // get_type->set_isLvalue( false );
+        cloneAll( arg2->get_results(), get_results() );
+        // for ( Type *& type : get_results() ) {
+        //      type->set_isLvalue( false );
+        // }
 }
 

src/SynTree/CompoundStmt.cc

@@ -20 +20 @@
 #include "Expression.h"
 #include "Declaration.h"
-#include "SynTree/VarExprReplacer.h"
 
 using std::string;
 using std::endl;
+
+class VarExprReplacer : public Visitor {
+public:
+  typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
+private:
+  const DeclMap & declMap;
+public:
+  VarExprReplacer( const DeclMap & declMap ) : declMap( declMap ) {}
+
+  // replace variable with new node from decl map
+  virtual void visit( VariableExpr * varExpr ) {
+    if ( declMap.count( varExpr->get_var() ) ) {
+      varExpr->set_var( declMap.at( varExpr->get_var() ) );
+    }
+  }
+};
+
 
 CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
@@ -31 +47 @@
         cloneAll( other.kids, kids );
 
-        // when cloning a compound statement, we may end up cloning declarations which
-        // are referred to by VariableExprs throughout the block. Cloning a VariableExpr
-        // does a shallow copy, so the VariableExpr will end up pointing to the original
-        // declaration. If the original declaration is deleted, e.g. because the original
-        // CompoundStmt is deleted, then we have a dangling pointer. To avoid this case,
-        // find all DeclarationWithType nodes (since a VariableExpr must point to a
-        // DeclarationWithType) in the original CompoundStmt and map them to the cloned
-        // node in the new CompoundStmt ('this'), then replace the Declarations referred to
-        // by each VariableExpr according to the constructed map. Note that only the declarations
-        // in the current level are collected into the map, because child CompoundStmts will
-        // recursively execute this routine. There may be more efficient ways of doing
-        // this.
-        VarExprReplacer::DeclMap declMap;
-        std::list< Statement * >::const_iterator origit = other.kids.begin();
-        for ( Statement * s : kids ) {
-                assert( origit != other.kids.end() );
-                Statement * origStmt = *origit++;
-                if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
-                        DeclStmt * origDeclStmt = dynamic_cast< DeclStmt * >( origStmt );
-                        assert( origDeclStmt );
-                        if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
-                                DeclarationWithType * origdwt = dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
-                                assert( origdwt );
-                                assert( dwt->get_name() == origdwt->get_name() );
-                                declMap[ origdwt ] = dwt;
-                        }
-                }
-        }
-        if ( ! declMap.empty() ) {
-                VarExprReplacer replacer( declMap );
-                accept( replacer );
-        }
+  // when cloning a compound statement, we may end up cloning declarations which
+  // are referred to by VariableExprs throughout the block. Cloning a VariableExpr
+  // does a shallow copy, so the VariableExpr will end up pointing to the original
+  // declaration. If the original declaration is deleted, e.g. because the original
+  // CompoundStmt is deleted, then we have a dangling pointer. To avoid this case,
+  // find all DeclarationWithType nodes (since a VariableExpr must point to a
+  // DeclarationWithType) in the original CompoundStmt and map them to the cloned
+  // node in the new CompoundStmt ('this'), then replace the Declarations referred to
+  // by each VariableExpr according to the constructed map. Note that only the declarations
+  // in the current level are collected into the map, because child CompoundStmts will
+  // recursively execute this routine. There may be more efficient ways of doing
+  // this.
+  VarExprReplacer::DeclMap declMap;
+  std::list< Statement * >::const_iterator origit = other.kids.begin();
+  for ( Statement * s : kids ) {
+    assert( origit != other.kids.end() );
+    if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
+      DeclStmt * origDeclStmt = dynamic_cast< DeclStmt * >( *origit );
+      assert( origDeclStmt );
+      if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
+        DeclarationWithType * origdwt = dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
+        assert( origdwt );
+        declMap[ origdwt ] = dwt;
+      }
+    }
+  }
+  if ( ! declMap.empty() ) {
+    VarExprReplacer replacer( declMap );
+    accept( replacer );
+  }
 }
 

src/SynTree/Expression.cc

@@ -31 +31 @@
 
 
-Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
-
-Expression::Expression( const Expression &other ) : result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
+Expression::Expression( Expression *_aname ) : env( 0 ), argName( _aname ) {}
+
+Expression::Expression( const Expression &other ) : env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
+        cloneAll( other.results, results );
 }
 
@@ -39 +40 @@
         delete env;
         delete argName; // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
-        delete result;
+        deleteAll( results );
+}
+
+void Expression::add_result( Type *t ) {
+        if ( TupleType *tuple = dynamic_cast< TupleType* >( t ) ) {
+                std::copy( tuple->get_types().begin(), tuple->get_types().end(), back_inserter( results ) );
+        } else {
+                results.push_back(t);
+        } // if
 }
 
@@ -59 +68 @@
 
 ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
-        set_result( constant.get_type()->clone() );
+        add_result( constant.get_type()->clone() );
 }
 
@@ -76 +85 @@
         assert( var );
         assert( var->get_type() );
-        Type * type = var->get_type()->clone();
-        type->set_isLvalue( true );
-        set_result( type );
+        add_result( var->get_type()->clone() );
+        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
+                (*i)->set_isLvalue( true );
+        } // for
 }
 
@@ -100 +110 @@
 SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
 SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -131 +141 @@
 AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
                 Expression( _aname ), expr(expr_), type(0), isType(false) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
 AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
                 Expression( _aname ), expr(0), type(type_), isType(true) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -162 +172 @@
 UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type_, const std::string &member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -187 +197 @@
 OffsetofExpr::OffsetofExpr( Type *type_, DeclarationWithType *member_, Expression *_aname ) :
                 Expression( _aname ), type(type_), member(member_) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
@@ -219 +229 @@
 
 OffsetPackExpr::OffsetPackExpr( StructInstType *type_, Expression *aname_ ) : Expression( aname_ ), type( type_ ) {
-        set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
+        add_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
 }
 
@@ -274 +284 @@
 
 CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
-        set_result(toType);
+        add_result(toType);
 }
 
 CastExpr::CastExpr( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
-        set_result( new VoidType( Type::Qualifiers() ) );
 }
 
@@ -294 +303 @@
         arg->print(os, indent+2);
         os << std::endl << std::string( indent, ' ' ) << "to:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        if ( result->isVoid() ) {
-                os << "nothing";
+        if ( results.empty() ) {
+                os << std::string( indent+2, ' ' ) << "nothing" << std::endl;
         } else {
-                result->print( os, indent+2 );
+                printAll(results, os, indent+2);
         } // if
-        os << std::endl;
-        Expression::print( os, indent );
-}
-
-UntypedMemberExpr::UntypedMemberExpr( Expression * _member, Expression *_aggregate, Expression *_aname ) :
+        Expression::print( os, indent );
+}
+
+UntypedMemberExpr::UntypedMemberExpr( std::string _member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {}
 
 UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
-                Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
+                Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
 }
 
 UntypedMemberExpr::~UntypedMemberExpr() {
         delete aggregate;
-        delete member;
 }
 
 void UntypedMemberExpr::print( std::ostream &os, int indent ) const {
-        os << "Untyped Member Expression, with field: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        get_member()->print(os, indent+4);
-        os << std::string( indent+2, ' ' );
+        os << "Untyped Member Expression, with field: " << get_member();
 
         Expression *agg = get_aggregate();
-        os << "from aggregate: " << std::endl;
+        os << ", from aggregate: ";
         if (agg != 0) {
-                os << std::string( indent + 4, ' ' );
-                agg->print(os, indent + 4);
+                os << std::string( indent + 2, ' ' );
+                agg->print(os, indent + 2);
         }
         os << std::string( indent+2, ' ' );
@@ -335 +338 @@
 MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
                 Expression( _aname ), member(_member), aggregate(_aggregate) {
-        set_result( member->get_type()->clone() );
-        get_result()->set_isLvalue( true );
+        add_result( member->get_type()->clone() );
+        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
+                (*i)->set_isLvalue( true );
+        } // for
 }
 
@@ -367 +372 @@
 }
 
-UntypedExpr::UntypedExpr( Expression *_function, const std::list<Expression *> &_args, Expression *_aname ) :
-                Expression( _aname ), function(_function), args(_args) {}
+
+UntypedExpr::UntypedExpr( Expression *_function, Expression *_aname ) : Expression( _aname ), function( _function ) {}
 
 UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
@@ -375 +380 @@
 }
 
+UntypedExpr::UntypedExpr( Expression *_function, std::list<Expression *> &_args, Expression *_aname ) :
+                Expression( _aname ), function(_function), args(_args) {}
+
 UntypedExpr::~UntypedExpr() {
         delete function;
         deleteAll( args );
 }
-
-UntypedExpr * UntypedExpr::createDeref( Expression * expr ) {
-        UntypedExpr * ret = new UntypedExpr( new NameExpr("*?"), std::list< Expression * >{ expr } );
-        if ( Type * type = expr->get_result() ) {
-                Type * base = InitTweak::getPointerBase( type );
-                if ( ! base ) {
-                        std::cerr << type << std::endl;
-                }
-                assertf( base, "expected pointer type in dereference\n" );
-                ret->set_result( maybeClone( base ) );
-        }
-        return ret;
-}
-
-UntypedExpr * UntypedExpr::createAssign( Expression * arg1, Expression * arg2 ) {
-        assert( arg1 && arg2 );
-        UntypedExpr * ret = new UntypedExpr( new NameExpr( "?=?" ), std::list< Expression * >{ arg1, arg2 } );
-        if ( arg1->get_result() && arg2->get_result() ) {
-                // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
-                // so the result is the type of the RHS
-                ret->set_result( arg2->get_result()->clone() );
-        }
-        return ret;
-}
-
 
 void UntypedExpr::print( std::ostream &os, int indent ) const {
@@ -436 +419 @@
 LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
                 Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
-        set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+        add_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
 }
 
@@ -471 +454 @@
 
 void ConditionalExpr::print( std::ostream &os, int indent ) const {
-        os << "Conditional expression on: " << std::endl;
-        os << std::string( indent+2, ' ' );
+        os << std::string( indent, ' ' ) << "Conditional expression on: " << std::endl;
         arg1->print( os, indent+2 );
         os << std::string( indent, ' ' ) << "First alternative:" << std::endl;
-        os << std::string( indent+2, ' ' );
         arg2->print( os, indent+2 );
         os << std::string( indent, ' ' ) << "Second alternative:" << std::endl;
-        os << std::string( indent+2, ' ' );
         arg3->print( os, indent+2 );
         os << std::endl;
@@ -497 +477 @@
 ImplicitCopyCtorExpr::ImplicitCopyCtorExpr( ApplicationExpr * callExpr ) : callExpr( callExpr ) {
         assert( callExpr );
-        assert( callExpr->has_result() );
-        set_result( callExpr->get_result()->clone() );
+        cloneAll( callExpr->get_results(), results );
 }
 
@@ -531 +510 @@
         Expression * arg = InitTweak::getCallArg( callExpr, 0 );
         assert( arg );
-        set_result( maybeClone( arg->get_result() ) );
+        cloneAll( arg->get_results(), results );
 }
 
@@ -551 +530 @@
 
 CompoundLiteralExpr::CompoundLiteralExpr( Type * type, Initializer * initializer ) : type( type ), initializer( initializer ) {
-        assert( type && initializer );
-        set_result( type->clone() );
-}
-
-CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( other.type->clone() ), initializer( other.initializer->clone() ) {}
+        add_result( type->clone() );
+}
+
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), type( maybeClone( other.type ) ), initializer( maybeClone( other.initializer ) ) {}
 
 CompoundLiteralExpr::~CompoundLiteralExpr() {
@@ -564 +542 @@
 void CompoundLiteralExpr::print( std::ostream &os, int indent ) const {
         os << "Compound Literal Expression: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        type->print( os, indent + 2 );
-        os << std::string( indent+2, ' ' );
-        initializer->print( os, indent + 2 );
+        if ( type ) type->print( os, indent + 2 );
+        if ( initializer ) initializer->print( os, indent + 2 );
 }
 
@@ -581 +557 @@
 
 RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
-RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
+RangeExpr::RangeExpr( const RangeExpr &other ) : low( other.low->clone() ), high( other.high->clone() ) {}
 void RangeExpr::print( std::ostream &os, int indent ) const {
-        os << "Range Expression: ";
+        os << std::string( indent, ' ' ) << "Range Expression: ";
         low->print( os, indent );
         os << " ... ";
         high->print( os, indent );
-}
-
-StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
-        assert( statements );
-        std::list< Statement * > & body = statements->get_kids();
-        if ( ! body.empty() ) {
-                if ( ExprStmt * exprStmt = dynamic_cast< ExprStmt * >( body.back() ) ) {
-                        set_result( maybeClone( exprStmt->get_expr()->get_result() ) );
-                }
-        }
-}
-StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {}
-StmtExpr::~StmtExpr() {
-        delete statements;
-}
-void StmtExpr::print( std::ostream &os, int indent ) const {
-        os << "Statement Expression: " << std::endl << std::string( indent, ' ' );
-        statements->print( os, indent+2 );
-}
-
-
-long long UniqueExpr::count = 0;
-UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
-        assert( expr );
-        assert( count != -1 );
-        if ( id == -1 ) id = count++;
-        if ( expr->get_result() ) {
-                set_result( expr->get_result()->clone() );
-        }
-}
-UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
-}
-UniqueExpr::~UniqueExpr() {
-        delete expr;
-        delete object;
-        delete var;
-}
-void UniqueExpr::print( std::ostream &os, int indent ) const {
-        os << "Unique Expression with id:" << id << std::endl << std::string( indent+2, ' ' );
-        get_expr()->print( os, indent+2 );
-        if ( get_object() ) {
-                os << " with decl: ";
-                get_object()->printShort( os, indent+2 );
-        }
 }
 

src/SynTree/Expression.h

@@ -32 +32 @@
         virtual ~Expression();
 
-        Type *& get_result() { return result; }
-        void set_result( Type *newValue ) { result = newValue; }
-        bool has_result() const { return result != nullptr; }
+        std::list<Type *>& get_results() { return results; }
+        void add_result( Type *t );
 
         TypeSubstitution *get_env() const { return env; }
@@ -48 +47 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   protected:
-        Type * result;
+        std::list<Type *> results;
         TypeSubstitution *env;
         Expression* argName; // if expression is used as an argument, it can be "designated" by this name
@@ -99 +98 @@
 class UntypedExpr : public Expression {
   public:
-        UntypedExpr( Expression *function, const std::list<Expression *> &args = std::list< Expression * >(), Expression *_aname = nullptr );
+        UntypedExpr( Expression *function, Expression *_aname = nullptr );
         UntypedExpr( const UntypedExpr &other );
+        UntypedExpr( Expression *function, std::list<Expression *> &args, Expression *_aname = nullptr );
         virtual ~UntypedExpr();
 
@@ -111 +111 @@
         std::list<Expression*>& get_args() { return args; }
 
-        static UntypedExpr * createDeref( Expression * arg );
-        static UntypedExpr * createAssign( Expression * arg1, Expression * arg2 );
-
         virtual UntypedExpr *clone() const { return new UntypedExpr( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
@@ -203 +200 @@
 class UntypedMemberExpr : public Expression {
   public:
-        UntypedMemberExpr( Expression *member, Expression *aggregate, Expression *_aname = nullptr );
+        UntypedMemberExpr( std::string member, Expression *aggregate, Expression *_aname = nullptr );
         UntypedMemberExpr( const UntypedMemberExpr &other );
         virtual ~UntypedMemberExpr();
 
-        Expression * get_member() const { return member; }
-        void set_member( Expression * newValue ) { member = newValue; }
+        std::string get_member() const { return member; }
+        void set_member( const std::string &newValue ) { member = newValue; }
         Expression *get_aggregate() const { return aggregate; }
         void set_aggregate( Expression *newValue ) { aggregate = newValue; }
@@ -217 +214 @@
         virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
-        Expression *member;
+        std::string member;
         Expression *aggregate;
 };
@@ -486 +483 @@
 };
 
+/// TupleExpr represents a tuple expression ( [a, b, c] )
+class TupleExpr : public Expression {
+  public:
+        TupleExpr( Expression *_aname = nullptr );
+        TupleExpr( const TupleExpr &other );
+        virtual ~TupleExpr();
+
+        void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
+        std::list<Expression*>& get_exprs() { return exprs; }
+
+        virtual TupleExpr *clone() const { return new TupleExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::list<Expression*> exprs;
+};
+
+/// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
+class SolvedTupleExpr : public Expression {
+  public:
+        SolvedTupleExpr( Expression *_aname = nullptr ) : Expression( _aname ) {}
+        SolvedTupleExpr( std::list<Expression *> &, Expression *_aname = nullptr );
+        SolvedTupleExpr( const SolvedTupleExpr &other );
+        virtual ~SolvedTupleExpr() {}
+
+        std::list<Expression*> &get_exprs() { return exprs; }
+
+        virtual SolvedTupleExpr *clone() const { return new SolvedTupleExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::list<Expression*> exprs;
+};
+
 /// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
 class TypeExpr : public Expression {
@@ -585 +618 @@
         CompoundLiteralExpr( Type * type, Initializer * initializer );
         CompoundLiteralExpr( const CompoundLiteralExpr &other );
-        virtual ~CompoundLiteralExpr();
+        ~CompoundLiteralExpr();
 
         Type * get_type() const { return type; }
@@ -637 +670 @@
   private:
         Expression *low, *high;
-};
-
-/// TupleExpr represents a tuple expression ( [a, b, c] )
-class TupleExpr : public Expression {
-  public:
-        TupleExpr( const std::list< Expression * > & exprs = std::list< Expression * >(), Expression *_aname = nullptr );
-        TupleExpr( const TupleExpr &other );
-        virtual ~TupleExpr();
-
-        void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
-        std::list<Expression*>& get_exprs() { return exprs; }
-
-        virtual TupleExpr *clone() const { return new TupleExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        std::list<Expression*> exprs;
-};
-
-/// TupleIndexExpr represents an element selection operation on a tuple value, e.g. t.3 after processing by the expression analyzer
-class TupleIndexExpr : public Expression {
-  public:
-        TupleIndexExpr( Expression * tuple, unsigned int index );
-        TupleIndexExpr( const TupleIndexExpr &other );
-        virtual ~TupleIndexExpr();
-
-        Expression * get_tuple() const { return tuple; }
-        int get_index() const { return index; }
-        TupleIndexExpr * set_tuple( Expression *newValue ) { tuple = newValue; return this; }
-        TupleIndexExpr * set_index( unsigned int newValue ) { index = newValue; return this; }
-
-        virtual TupleIndexExpr *clone() const { return new TupleIndexExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Expression * tuple;
-        unsigned int index;
-};
-
-/// MemberTupleExpr represents a tuple member selection operation on a struct type, e.g. s.[a, b, c] after processing by the expression analyzer
-class MemberTupleExpr : public Expression {
-  public:
-        MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname = nullptr );
-        MemberTupleExpr( const MemberTupleExpr &other );
-        virtual ~MemberTupleExpr();
-
-        Expression * get_member() const { return member; }
-        Expression * get_aggregate() const { return aggregate; }
-        MemberTupleExpr * set_member( Expression *newValue ) { member = newValue; return this; }
-        MemberTupleExpr * set_aggregate( Expression *newValue ) { aggregate = newValue; return this; }
-
-        virtual MemberTupleExpr *clone() const { return new MemberTupleExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        Expression * member;
-        Expression * aggregate;
-};
-
-/// 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
-class TupleAssignExpr : public Expression {
-  public:
-        TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname = nullptr );
-        TupleAssignExpr( const TupleAssignExpr &other );
-        virtual ~TupleAssignExpr();
-
-        std::list< Expression * > & get_assigns() { return assigns; }
-        std::list< ObjectDecl * > & get_tempDecls() { return tempDecls; }
-
-        virtual TupleAssignExpr *clone() const { return new TupleAssignExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-  private:
-        std::list< Expression * > assigns; // assignment expressions that use tempDecls
-        std::list< ObjectDecl * > tempDecls; // temporaries for address of lhs exprs
-};
-
-/// StmtExpr represents a GCC 'statement expression', e.g. ({ int x = 5; x; })
-class StmtExpr : public Expression {
-public:
-        StmtExpr( CompoundStmt *statements );
-        StmtExpr( const StmtExpr & other );
-        virtual ~StmtExpr();
-
-        CompoundStmt * get_statements() const { return statements; }
-        StmtExpr * set_statements( CompoundStmt * newValue ) { statements = newValue; return this; }
-
-        virtual StmtExpr *clone() const { return new StmtExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-private:
-        CompoundStmt * statements;
-};
-
-class UniqueExpr : public Expression {
-public:
-        UniqueExpr( Expression * expr, long long idVal = -1 );
-        UniqueExpr( const UniqueExpr & other );
-        ~UniqueExpr();
-
-        Expression * get_expr() const { return expr; }
-        UniqueExpr * set_expr( Expression * newValue ) { expr = newValue; return this; }
-
-        ObjectDecl * get_object() const { return object; }
-        UniqueExpr * set_object( ObjectDecl * newValue ) { object = newValue; return this; }
-
-        VariableExpr * get_var() const { return var; }
-        UniqueExpr * set_var( VariableExpr * newValue ) { var = newValue; return this; }
-
-        int get_id() const { return id; }
-
-        virtual UniqueExpr *clone() const { return new UniqueExpr( *this ); }
-        virtual void accept( Visitor &v ) { v.visit( this ); }
-        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
-        virtual void print( std::ostream &os, int indent = 0 ) const;
-private:
-        Expression * expr;
-        ObjectDecl * object;
-        VariableExpr * var;
-        int id;
-        static long long count;
 };
 

src/SynTree/Initializer.h

@@ -23 +23 @@
 
 #include <cassert>
-
-const std::list<Expression*> noDesignators;
 
 // Initializer: base class for object initializers (provide default values)

src/SynTree/Mutator.cc

@@ -178 +178 @@
 
 Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
-        applicationExpr->set_result( maybeMutate( applicationExpr->get_result(), *this ) );
+        mutateAll( applicationExpr->get_results(), *this );
         applicationExpr->set_function( maybeMutate( applicationExpr->get_function(), *this ) );
         mutateAll( applicationExpr->get_args(), *this );
@@ -185 +185 @@
 
 Expression *Mutator::mutate( UntypedExpr *untypedExpr ) {
-        untypedExpr->set_result( maybeMutate( untypedExpr->get_result(), *this ) );
+        mutateAll( untypedExpr->get_results(), *this );
         mutateAll( untypedExpr->get_args(), *this );
         return untypedExpr;
@@ -191 +191 @@
 
 Expression *Mutator::mutate( NameExpr *nameExpr ) {
-        nameExpr->set_result( maybeMutate( nameExpr->get_result(), *this ) );
+        mutateAll( nameExpr->get_results(), *this );
         return nameExpr;
 }
 
 Expression *Mutator::mutate( AddressExpr *addressExpr ) {
-        addressExpr->set_result( maybeMutate( addressExpr->get_result(), *this ) );
+        mutateAll( addressExpr->get_results(), *this );
         addressExpr->set_arg( maybeMutate( addressExpr->get_arg(), *this ) );
         return addressExpr;
@@ -202 +202 @@
 
 Expression *Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
-        labelAddressExpr->set_result( maybeMutate( labelAddressExpr->get_result(), *this ) );
+        mutateAll( labelAddressExpr->get_results(), *this );
         labelAddressExpr->set_arg( maybeMutate( labelAddressExpr->get_arg(), *this ) );
         return labelAddressExpr;
@@ -208 +208 @@
 
 Expression *Mutator::mutate( CastExpr *castExpr ) {
-        castExpr->set_result( maybeMutate( castExpr->get_result(), *this ) );
+        mutateAll( castExpr->get_results(), *this );
         castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
         return castExpr;
@@ -214 +214 @@
 
 Expression *Mutator::mutate( UntypedMemberExpr *memberExpr ) {
-        memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
-        memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
-        memberExpr->set_member( maybeMutate( memberExpr->get_member(), *this ) );
-        return memberExpr;
-}
-
-Expression *Mutator::mutate( MemberExpr *memberExpr ) {
-        memberExpr->set_result( maybeMutate( memberExpr->get_result(), *this ) );
+        mutateAll( memberExpr->get_results(), *this );
         memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
         return memberExpr;
 }
 
+Expression *Mutator::mutate( MemberExpr *memberExpr ) {
+        mutateAll( memberExpr->get_results(), *this );
+        memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
+        return memberExpr;
+}
+
 Expression *Mutator::mutate( VariableExpr *variableExpr ) {
-        variableExpr->set_result( maybeMutate( variableExpr->get_result(), *this ) );
+        mutateAll( variableExpr->get_results(), *this );
         return variableExpr;
 }
 
 Expression *Mutator::mutate( ConstantExpr *constantExpr ) {
-        constantExpr->set_result( maybeMutate( constantExpr->get_result(), *this ) );
+        mutateAll( constantExpr->get_results(), *this );
 //  maybeMutate( constantExpr->get_constant(), *this )
         return constantExpr;
@@ -238 +237 @@
 
 Expression *Mutator::mutate( SizeofExpr *sizeofExpr ) {
-        sizeofExpr->set_result( maybeMutate( sizeofExpr->get_result(), *this ) );
+        mutateAll( sizeofExpr->get_results(), *this );
         if ( sizeofExpr->get_isType() ) {
                 sizeofExpr->set_type( maybeMutate( sizeofExpr->get_type(), *this ) );
@@ -248 +247 @@
 
 Expression *Mutator::mutate( AlignofExpr *alignofExpr ) {
-        alignofExpr->set_result( maybeMutate( alignofExpr->get_result(), *this ) );
+        mutateAll( alignofExpr->get_results(), *this );
         if ( alignofExpr->get_isType() ) {
                 alignofExpr->set_type( maybeMutate( alignofExpr->get_type(), *this ) );
@@ -258 +257 @@
 
 Expression *Mutator::mutate( UntypedOffsetofExpr *offsetofExpr ) {
-        offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
+        mutateAll( offsetofExpr->get_results(), *this );
         offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
         return offsetofExpr;
@@ -264 +263 @@
 
 Expression *Mutator::mutate( OffsetofExpr *offsetofExpr ) {
-        offsetofExpr->set_result( maybeMutate( offsetofExpr->get_result(), *this ) );
+        mutateAll( offsetofExpr->get_results(), *this );
         offsetofExpr->set_type( maybeMutate( offsetofExpr->get_type(), *this ) );
         offsetofExpr->set_member( maybeMutate( offsetofExpr->get_member(), *this ) );
@@ -271 +270 @@
 
 Expression *Mutator::mutate( OffsetPackExpr *offsetPackExpr ) {
-        offsetPackExpr->set_result( maybeMutate( offsetPackExpr->get_result(), *this ) );
+        mutateAll( offsetPackExpr->get_results(), *this );
         offsetPackExpr->set_type( maybeMutate( offsetPackExpr->get_type(), *this ) );
         return offsetPackExpr;
@@ -277 +276 @@
 
 Expression *Mutator::mutate( AttrExpr *attrExpr ) {
-        attrExpr->set_result( maybeMutate( attrExpr->get_result(), *this ) );
+        mutateAll( attrExpr->get_results(), *this );
         if ( attrExpr->get_isType() ) {
                 attrExpr->set_type( maybeMutate( attrExpr->get_type(), *this ) );
@@ -287 +286 @@
 
 Expression *Mutator::mutate( LogicalExpr *logicalExpr ) {
-        logicalExpr->set_result( maybeMutate( logicalExpr->get_result(), *this ) );
+        mutateAll( logicalExpr->get_results(), *this );
         logicalExpr->set_arg1( maybeMutate( logicalExpr->get_arg1(), *this ) );
         logicalExpr->set_arg2( maybeMutate( logicalExpr->get_arg2(), *this ) );
@@ -294 +293 @@
 
 Expression *Mutator::mutate( ConditionalExpr *conditionalExpr ) {
-        conditionalExpr->set_result( maybeMutate( conditionalExpr->get_result(), *this ) );
+        mutateAll( conditionalExpr->get_results(), *this );
         conditionalExpr->set_arg1( maybeMutate( conditionalExpr->get_arg1(), *this ) );
         conditionalExpr->set_arg2( maybeMutate( conditionalExpr->get_arg2(), *this ) );
@@ -302 +301 @@
 
 Expression *Mutator::mutate( CommaExpr *commaExpr ) {
-        commaExpr->set_result( maybeMutate( commaExpr->get_result(), *this ) );
+        mutateAll( commaExpr->get_results(), *this );
         commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
         commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
@@ -308 +307 @@
 }
 
+Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
+        mutateAll( tupleExpr->get_results(), *this );
+        mutateAll( tupleExpr->get_exprs(), *this );
+        return tupleExpr;
+}
+
+Expression *Mutator::mutate( SolvedTupleExpr *tupleExpr ) {
+        mutateAll( tupleExpr->get_results(), *this );
+        mutateAll( tupleExpr->get_exprs(), *this );
+        return tupleExpr;
+}
+
 Expression *Mutator::mutate( TypeExpr *typeExpr ) {
-        typeExpr->set_result( maybeMutate( typeExpr->get_result(), *this ) );
+        mutateAll( typeExpr->get_results(), *this );
         typeExpr->set_type( maybeMutate( typeExpr->get_type(), *this ) );
         return typeExpr;
@@ -329 +340 @@
 
 Expression* Mutator::mutate( ConstructorExpr *ctorExpr ) {
-        ctorExpr->set_result( maybeMutate( ctorExpr->get_result(), *this ) );
+        mutateAll( ctorExpr->get_results(), *this );
         ctorExpr->set_callExpr( maybeMutate( ctorExpr->get_callExpr(), *this ) );
         return ctorExpr;
@@ -335 +346 @@
 
 Expression *Mutator::mutate( CompoundLiteralExpr *compLitExpr ) {
-        compLitExpr->set_result( maybeMutate( compLitExpr->get_result(), *this ) );
+        mutateAll( compLitExpr->get_results(), *this );
         compLitExpr->set_type( maybeMutate( compLitExpr->get_type(), *this ) );
         compLitExpr->set_initializer( maybeMutate( compLitExpr->get_initializer(), *this ) );
@@ -342 +353 @@
 
 Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
-        valofExpr->set_result( maybeMutate( valofExpr->get_result(), *this ) );
+        mutateAll( valofExpr->get_results(), *this );
         return valofExpr;
 }
@@ -350 +361 @@
         rangeExpr->set_high( maybeMutate( rangeExpr->get_high(), *this ) );
         return rangeExpr;
-}
-
-Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
-        mutateAll( tupleExpr->get_exprs(), *this );
-        return tupleExpr;
-}
-
-Expression *Mutator::mutate( TupleIndexExpr *tupleExpr ) {
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
-        tupleExpr->set_tuple( maybeMutate( tupleExpr->get_tuple(), *this ) );
-        return tupleExpr;
-}
-
-Expression *Mutator::mutate( MemberTupleExpr *tupleExpr ) {
-        tupleExpr->set_result( maybeMutate( tupleExpr->get_result(), *this ) );
-        tupleExpr->set_member( maybeMutate( tupleExpr->get_member(), *this ) );
-        tupleExpr->set_aggregate( maybeMutate( tupleExpr->get_aggregate(), *this ) );
-        return tupleExpr;
-}
-
-Expression *Mutator::mutate( TupleAssignExpr *assignExpr ) {
-        assignExpr->set_result( maybeMutate( assignExpr->get_result(), *this ) );
-        mutateAll( assignExpr->get_tempDecls(), *this );
-        mutateAll( assignExpr->get_assigns(), *this );
-        return assignExpr;
-}
-
-Expression *Mutator::mutate( StmtExpr *stmtExpr ) {
-        stmtExpr->set_result( maybeMutate( stmtExpr->get_result(), *this ) );
-        stmtExpr->set_statements( maybeMutate( stmtExpr->get_statements(), *this ) );
-        return stmtExpr;
-}
-
-Expression *Mutator::mutate( UniqueExpr *uniqueExpr ) {
-        uniqueExpr->set_result( maybeMutate( uniqueExpr->get_result(), *this ) );
-        uniqueExpr->set_expr( maybeMutate( uniqueExpr->get_expr(), *this ) );
-        return uniqueExpr;
 }
 

src/SynTree/Mutator.h

@@ -71 +71 @@
         virtual Expression* mutate( ConditionalExpr *conditionalExpr );
         virtual Expression* mutate( CommaExpr *commaExpr );
+        virtual Expression* mutate( TupleExpr *tupleExpr );
+        virtual Expression* mutate( SolvedTupleExpr *tupleExpr );
         virtual Expression* mutate( TypeExpr *typeExpr );
         virtual Expression* mutate( AsmExpr *asmExpr );
@@ -78 +80 @@
         virtual Expression* mutate( UntypedValofExpr *valofExpr );
         virtual Expression* mutate( RangeExpr *rangeExpr );
-        virtual Expression* mutate( TupleExpr *tupleExpr );
-        virtual Expression* mutate( TupleIndexExpr *tupleExpr );
-        virtual Expression* mutate( MemberTupleExpr *tupleExpr );
-        virtual Expression* mutate( TupleAssignExpr *assignExpr );
-        virtual Expression* mutate( StmtExpr * stmtExpr );
-        virtual Expression* mutate( UniqueExpr * uniqueExpr );
 
         virtual Type* mutate( VoidType *basicType );

src/SynTree/ReferenceToType.cc

@@ -56 +56 @@
         }
 } // namespace
-
-StructInstType::StructInstType( const Type::Qualifiers & tq, StructDecl * baseStruct ) : Parent( tq, baseStruct->get_name() ), baseStruct( baseStruct ) {}
 
 std::string StructInstType::typeString() const { return "struct"; }

src/SynTree/SynTree.h

@@ -76 +76 @@
 class ConditionalExpr;
 class CommaExpr;
+class TupleExpr;
+class SolvedTupleExpr;
 class TypeExpr;
 class AsmExpr;
@@ -83 +85 @@
 class UntypedValofExpr;
 class RangeExpr;
-class TupleExpr;
-class TupleIndexExpr;
-class MemberTupleExpr;
-class TupleAssignExpr;
-class StmtExpr;
-class UniqueExpr;
 
 class Type;

src/SynTree/TupleExpr.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TupleExpr.cc --
+// TupleExpr.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -16 +16 @@
 #include "Expression.h"
 #include "Common/utility.h"
-#include "Type.h"
-#include "Declaration.h"
-#include "Tuples/Tuples.h"
-#include "VarExprReplacer.h"
 
-TupleExpr::TupleExpr( const std::list< Expression * > & exprs, Expression *_aname ) : Expression( _aname ), exprs( exprs ) {
-        if ( ! exprs.empty() ) {
-                if ( std::all_of( exprs.begin(), exprs.end(), [](Expression * expr) { return expr->get_result(); } ) ) {
-                        set_result( Tuples::makeTupleType( exprs ) );
-                }
-        }
+TupleExpr::TupleExpr( Expression *_aname ) : Expression( _aname ) {
 }
 
@@ -38 +29 @@
 
 void TupleExpr::print( std::ostream &os, int indent ) const {
-        os << "Tuple:" << std::endl;
+        os << std::string( indent, ' ' ) << "Tuple:" << std::endl;
         printAll( exprs, os, indent+2 );
         Expression::print( os, indent );
 }
 
-TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) : tuple( tuple ), index( index )  {
-        TupleType * type = safe_dynamic_cast< TupleType * >( tuple->get_result() );
-        assert( type->size() > index );
-        set_result( (*std::next( type->get_types().begin(), index ))->clone() );
-        get_result()->set_isLvalue( type->get_isLvalue() );
+SolvedTupleExpr::SolvedTupleExpr( std::list<Expression *> &_exprs, Expression *_aname ) : Expression( _aname ) {
+        std::copy(_exprs.begin(), _exprs.end(), back_inserter(exprs));
 }
 
-TupleIndexExpr::TupleIndexExpr( const TupleIndexExpr &other ) : Expression( other ), tuple( other.tuple->clone() ), index( other.index ) {
+SolvedTupleExpr::SolvedTupleExpr( const SolvedTupleExpr &other ) : Expression( other ) {
+        cloneAll( other.exprs, exprs );
 }
 
-TupleIndexExpr::~TupleIndexExpr() {
-        delete tuple;
-}
-
-void TupleIndexExpr::print( std::ostream &os, int indent ) const {
-        os << "Tuple Index Expression, with tuple:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        tuple->print( os, indent+2 );
-        os << std::string( indent+2, ' ' ) << "with index: " << index << std::endl;
+void SolvedTupleExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Solved Tuple:" << std::endl;
+        printAll( exprs, os, indent+2 );
         Expression::print( os, indent );
 }
-
-MemberTupleExpr::MemberTupleExpr( Expression * member, Expression * aggregate, Expression * _aname ) : Expression( _aname ) {
-        set_result( maybeClone( member->get_result() ) ); // xxx - ???
-}
-
-MemberTupleExpr::MemberTupleExpr( const MemberTupleExpr &other ) : Expression( other ), member( other.member->clone() ), aggregate( other.aggregate->clone() ) {
-}
-
-MemberTupleExpr::~MemberTupleExpr() {
-        delete member;
-        delete aggregate;
-}
-
-void MemberTupleExpr::print( std::ostream &os, int indent ) const {
-        os << "Member Tuple Expression, with aggregate:" << std::endl;
-        os << std::string( indent+2, ' ' );
-        aggregate->print( os, indent+2 );
-        os << std::string( indent+2, ' ' ) << "with member: " << std::endl;
-        os << std::string( indent+2, ' ' );
-        member->print( os, indent+2 );
-        Expression::print( os, indent );
-}
-
-
-TupleAssignExpr::TupleAssignExpr( const std::list< Expression * > & assigns, const std::list< ObjectDecl * > & tempDecls, Expression * _aname ) : Expression( _aname ), assigns( assigns ), tempDecls( tempDecls ) {
-        set_result( Tuples::makeTupleType( assigns ) );
-}
-
-TupleAssignExpr::TupleAssignExpr( const TupleAssignExpr &other ) : Expression( other ) {
-        cloneAll( other.assigns, assigns );
-        cloneAll( other.tempDecls, tempDecls );
-
-        // clone needs to go into assigns and replace tempDecls
-        VarExprReplacer::DeclMap declMap;
-        std::list< ObjectDecl * >::const_iterator origit = other.tempDecls.begin();
-        for ( ObjectDecl * temp : tempDecls ) {
-                assert( origit != other.tempDecls.end() );
-                ObjectDecl * origTemp = *origit++;
-                assert( origTemp );
-                assert( temp->get_name() == origTemp->get_name() );
-                declMap[ origTemp ] = temp;
-        }
-        if ( ! declMap.empty() ) {
-                VarExprReplacer replacer( declMap );
-                for ( Expression * assn : assigns ) {
-                        assn->accept( replacer );
-                }
-        }
-}
-
-TupleAssignExpr::~TupleAssignExpr() {
-        deleteAll( assigns );
-        // deleteAll( tempDecls );
-}
-
-void TupleAssignExpr::print( std::ostream &os, int indent ) const {
-        os << "Tuple Assignment Expression, with temporaries:" << std::endl;
-        printAll( tempDecls, os, indent+4 );
-        os << std::string( indent+2, ' ' ) << "with assignments: " << std::endl;
-        printAll( assigns, os, indent+4 );
-        Expression::print( os, indent );
-}
-
-
 
 // Local Variables: //

src/SynTree/TupleType.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// TupleType.cc --
+// TupleType.cc -- 
 //
 // Author           : Richard C. Bilson
@@ -17 +17 @@
 #include "Common/utility.h"
 
-TupleType::TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types ) : Type( tq ), types( types ) {
+TupleType::TupleType( const Type::Qualifiers &tq ) : Type( tq ) {
 }
 

src/SynTree/Type.h

@@ -20 +20 @@
 #include "Visitor.h"
 #include "Mutator.h"
-#include "Common/utility.h"
 
 class Type {
@@ -28 +27 @@
                 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 ) {}
 
-                Qualifiers &operator&=( const Qualifiers &other );
                 Qualifiers &operator+=( const Qualifiers &other );
                 Qualifiers &operator-=( const Qualifiers &other );
@@ -65 +63 @@
         void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
         void set_isAttribute( bool newValue ) { tq.isAttribute = newValue; }
-
-        typedef std::list<TypeDecl *> ForallList;
-        ForallList& get_forall() { return forall; }
-
-        /// How many elemental types are represented by this type
-        virtual unsigned size() const { return 1; };
-        virtual bool isVoid() const { return size() == 0; }
+        std::list<TypeDecl*>& get_forall() { return forall; }
 
         virtual Type *clone() const = 0;
@@ -79 +71 @@
   private:
         Qualifiers tq;
-        ForallList forall;
+        std::list<TypeDecl*> forall;
 };
 
@@ -85 +77 @@
   public:
         VoidType( const Type::Qualifiers &tq );
-
-        virtual unsigned size() const { return 0; };
 
         virtual VoidType *clone() const { return new VoidType( *this ); }
@@ -244 +234 @@
   public:
         StructInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseStruct( 0 ) {}
-        StructInstType( const Type::Qualifiers &tq, StructDecl * baseStruct );
         StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
 
@@ -359 +348 @@
 class TupleType : public Type {
   public:
-        TupleType( const Type::Qualifiers &tq, const std::list< Type * > & types = std::list< Type * >() );
+        TupleType( const Type::Qualifiers &tq );
         TupleType( const TupleType& );
         virtual ~TupleType();
 
-        typedef std::list<Type*> value_type;
-        typedef value_type::iterator iterator;
-
         std::list<Type*>& get_types() { return types; }
-        virtual unsigned size() const { return types.size(); };
-
-        iterator begin() { return types.begin(); }
-        iterator end() { return types.end(); }
 
         virtual TupleType *clone() const { return new TupleType( *this ); }
@@ -460 +442 @@
 };
 
-inline Type::Qualifiers &Type::Qualifiers::operator&=( const Type::Qualifiers &other ) {
-        isConst &= other.isConst;
-        isVolatile &= other.isVolatile;
-        isRestrict &= other.isRestrict;
-        isLvalue &= other.isLvalue;
-        isAtomic &= other.isAtomic;
-        return *this;
-}
-
 inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
         isConst |= other.isConst;

src/SynTree/TypeSubstitution.cc

@@ -72 +72 @@
 Type *TypeSubstitution::lookup( std::string formalType ) const {
         TypeEnvType::const_iterator i = typeEnv.find( formalType );
-
+        
         // break on not in substitution set
         if ( i == typeEnv.end() ) return 0;
-
+        
         // attempt to transitively follow TypeInstType links.
         while ( TypeInstType *actualType = dynamic_cast< TypeInstType* >( i->second ) ) {
                 const std::string& typeName = actualType->get_name();
-
+                
                 // break cycles in the transitive follow
                 if ( formalType == typeName ) break;
-
+                
                 // Look for the type this maps to, returning previous mapping if none-such
                 i = typeEnv.find( typeName );
                 if ( i == typeEnv.end() ) return actualType;
         }
-
+        
         // return type from substitution set
         return i->second;
-
+        
 #if 0
         if ( i == typeEnv.end() ) {
@@ -149 +149 @@
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
+                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
                         boundVars.insert( (*tyvar )->get_name() );
                 } // for
@@ -163 +163 @@
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
+                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
                         boundVars.insert( (*tyvar )->get_name() );
                 } // for

src/SynTree/Visitor.cc

@@ -150 +150 @@
 
 void Visitor::visit( ApplicationExpr *applicationExpr ) {
-        maybeAccept( applicationExpr->get_result(), *this );
+        acceptAll( applicationExpr->get_results(), *this );
         maybeAccept( applicationExpr->get_function(), *this );
         acceptAll( applicationExpr->get_args(), *this );
@@ -156 +156 @@
 
 void Visitor::visit( UntypedExpr *untypedExpr ) {
-        maybeAccept( untypedExpr->get_result(), *this );
+        acceptAll( untypedExpr->get_results(), *this );
         acceptAll( untypedExpr->get_args(), *this );
 }
 
 void Visitor::visit( NameExpr *nameExpr ) {
-        maybeAccept( nameExpr->get_result(), *this );
+        acceptAll( nameExpr->get_results(), *this );
 }
 
 void Visitor::visit( AddressExpr *addressExpr ) {
-        maybeAccept( addressExpr->get_result(), *this );
+        acceptAll( addressExpr->get_results(), *this );
         maybeAccept( addressExpr->get_arg(), *this );
 }
 
 void Visitor::visit( LabelAddressExpr *labAddressExpr ) {
-        maybeAccept( labAddressExpr->get_result(), *this );
+        acceptAll( labAddressExpr->get_results(), *this );
         maybeAccept( labAddressExpr->get_arg(), *this );
 }
 
 void Visitor::visit( CastExpr *castExpr ) {
-        maybeAccept( castExpr->get_result(), *this );
+        acceptAll( castExpr->get_results(), *this );
         maybeAccept( castExpr->get_arg(), *this );
 }
 
 void Visitor::visit( UntypedMemberExpr *memberExpr ) {
-        maybeAccept( memberExpr->get_result(), *this );
+        acceptAll( memberExpr->get_results(), *this );
         maybeAccept( memberExpr->get_aggregate(), *this );
-        maybeAccept( memberExpr->get_member(), *this );
 }
 
 void Visitor::visit( MemberExpr *memberExpr ) {
-        maybeAccept( memberExpr->get_result(), *this );
+        acceptAll( memberExpr->get_results(), *this );
         maybeAccept( memberExpr->get_aggregate(), *this );
 }
 
 void Visitor::visit( VariableExpr *variableExpr ) {
-        maybeAccept( variableExpr->get_result(), *this );
+        acceptAll( variableExpr->get_results(), *this );
 }
 
 void Visitor::visit( ConstantExpr *constantExpr ) {
-        maybeAccept( constantExpr->get_result(), *this );
+        acceptAll( constantExpr->get_results(), *this );
         maybeAccept( constantExpr->get_constant(), *this );
 }
 
 void Visitor::visit( SizeofExpr *sizeofExpr ) {
-        maybeAccept( sizeofExpr->get_result(), *this );
+        acceptAll( sizeofExpr->get_results(), *this );
         if ( sizeofExpr->get_isType() ) {
                 maybeAccept( sizeofExpr->get_type(), *this );
@@ -209 +208 @@
 
 void Visitor::visit( AlignofExpr *alignofExpr ) {
-        maybeAccept( alignofExpr->get_result(), *this );
+        acceptAll( alignofExpr->get_results(), *this );
         if ( alignofExpr->get_isType() ) {
                 maybeAccept( alignofExpr->get_type(), *this );
@@ -218 +217 @@
 
 void Visitor::visit( UntypedOffsetofExpr *offsetofExpr ) {
-        maybeAccept( offsetofExpr->get_result(), *this );
+        acceptAll( offsetofExpr->get_results(), *this );
         maybeAccept( offsetofExpr->get_type(), *this );
 }
 
 void Visitor::visit( OffsetofExpr *offsetofExpr ) {
-        maybeAccept( offsetofExpr->get_result(), *this );
+        acceptAll( offsetofExpr->get_results(), *this );
         maybeAccept( offsetofExpr->get_type(), *this );
         maybeAccept( offsetofExpr->get_member(), *this );
@@ -229 +228 @@
 
 void Visitor::visit( OffsetPackExpr *offsetPackExpr ) {
-        maybeAccept( offsetPackExpr->get_result(), *this );
+        acceptAll( offsetPackExpr->get_results(), *this );
         maybeAccept( offsetPackExpr->get_type(), *this );
 }
 
 void Visitor::visit( AttrExpr *attrExpr ) {
-        maybeAccept( attrExpr->get_result(), *this );
+        acceptAll( attrExpr->get_results(), *this );
         if ( attrExpr->get_isType() ) {
                 maybeAccept( attrExpr->get_type(), *this );
@@ -243 +242 @@
 
 void Visitor::visit( LogicalExpr *logicalExpr ) {
-        maybeAccept( logicalExpr->get_result(), *this );
+        acceptAll( logicalExpr->get_results(), *this );
         maybeAccept( logicalExpr->get_arg1(), *this );
         maybeAccept( logicalExpr->get_arg2(), *this );
@@ -249 +248 @@
 
 void Visitor::visit( ConditionalExpr *conditionalExpr ) {
-        maybeAccept( conditionalExpr->get_result(), *this );
+        acceptAll( conditionalExpr->get_results(), *this );
         maybeAccept( conditionalExpr->get_arg1(), *this );
         maybeAccept( conditionalExpr->get_arg2(), *this );
@@ -256 +255 @@
 
 void Visitor::visit( CommaExpr *commaExpr ) {
-        maybeAccept( commaExpr->get_result(), *this );
+        acceptAll( commaExpr->get_results(), *this );
         maybeAccept( commaExpr->get_arg1(), *this );
         maybeAccept( commaExpr->get_arg2(), *this );
 }
 
+void Visitor::visit( TupleExpr *tupleExpr ) {
+        acceptAll( tupleExpr->get_results(), *this );
+        acceptAll( tupleExpr->get_exprs(), *this );
+}
+
+void Visitor::visit( SolvedTupleExpr *tupleExpr ) {
+        acceptAll( tupleExpr->get_results(), *this );
+        acceptAll( tupleExpr->get_exprs(), *this );
+}
+
 void Visitor::visit( TypeExpr *typeExpr ) {
-        maybeAccept( typeExpr->get_result(), *this );
+        acceptAll( typeExpr->get_results(), *this );
         maybeAccept( typeExpr->get_type(), *this );
 }
@@ -279 +288 @@
 
 void Visitor::visit( ConstructorExpr * ctorExpr ) {
-        maybeAccept( ctorExpr->get_result(), *this );
+        acceptAll( ctorExpr->get_results(), *this );
         maybeAccept( ctorExpr->get_callExpr(), *this );
 }
 
 void Visitor::visit( CompoundLiteralExpr *compLitExpr ) {
-        maybeAccept( compLitExpr->get_result(), *this );
+        acceptAll( compLitExpr->get_results(), *this );
         maybeAccept( compLitExpr->get_type(), *this );
         maybeAccept( compLitExpr->get_initializer(), *this );
@@ -290 +299 @@
 
 void Visitor::visit( UntypedValofExpr *valofExpr ) {
-        maybeAccept( valofExpr->get_result(), *this );
+        acceptAll( valofExpr->get_results(), *this );
         maybeAccept( valofExpr->get_body(), *this );
 }
@@ -297 +306 @@
         maybeAccept( rangeExpr->get_low(), *this );
         maybeAccept( rangeExpr->get_high(), *this );
-}
-
-void Visitor::visit( TupleExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
-        acceptAll( tupleExpr->get_exprs(), *this );
-}
-
-void Visitor::visit( TupleIndexExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
-        maybeAccept( tupleExpr->get_tuple(), *this );
-}
-
-void Visitor::visit( MemberTupleExpr *tupleExpr ) {
-        maybeAccept( tupleExpr->get_result(), *this );
-        maybeAccept( tupleExpr->get_member(), *this );
-        maybeAccept( tupleExpr->get_aggregate(), *this );
-}
-
-void Visitor::visit( TupleAssignExpr *assignExpr ) {
-        maybeAccept( assignExpr->get_result(), *this );
-        acceptAll( assignExpr->get_tempDecls(), *this );
-        acceptAll( assignExpr->get_assigns(), *this );
-}
-
-void Visitor::visit( StmtExpr *stmtExpr ) {
-        maybeAccept( stmtExpr->get_result(), *this );
-        maybeAccept( stmtExpr->get_statements(), *this );
-}
-
-void Visitor::visit( UniqueExpr *uniqueExpr ) {
-        maybeAccept( uniqueExpr->get_result(), *this );
-        maybeAccept( uniqueExpr->get_expr(), *this );
 }
 

src/SynTree/Visitor.h

@@ -71 +71 @@
         virtual void visit( ConditionalExpr *conditionalExpr );
         virtual void visit( CommaExpr *commaExpr );
+        virtual void visit( TupleExpr *tupleExpr );
+        virtual void visit( SolvedTupleExpr *tupleExpr );
         virtual void visit( TypeExpr *typeExpr );
         virtual void visit( AsmExpr *asmExpr );
@@ -78 +80 @@
         virtual void visit( UntypedValofExpr *valofExpr );
         virtual void visit( RangeExpr *rangeExpr );
-        virtual void visit( TupleExpr *tupleExpr );
-        virtual void visit( TupleIndexExpr *tupleExpr );
-        virtual void visit( MemberTupleExpr *tupleExpr );
-        virtual void visit( TupleAssignExpr *assignExpr );
-        virtual void visit( StmtExpr * stmtExpr );
-        virtual void visit( UniqueExpr * uniqueExpr );
 
         virtual void visit( VoidType *basicType );

src/SynTree/module.mk

@@ -49 +49 @@
        SynTree/AddStmtVisitor.cc \
        SynTree/TypeSubstitution.cc \
-       SynTree/Attribute.cc \
-       SynTree/VarExprReplacer.cc
+       SynTree/Attribute.cc
 

src/Tuples/TupleAssignment.cc

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Wed Nov 9 13:48:42 2016
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 15:02:53 2015
 // Update Count     : 2
 //
@@ -18 +18 @@
 #include "ResolvExpr/typeops.h"
 #include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
-#include "Tuples.h"
-#include "Explode.h"
+#include "TupleAssignment.h"
 #include "Common/SemanticError.h"
-#include "InitTweak/InitTweak.h"
 
 #include <functional>
@@ -30 +27 @@
 #include <cassert>
 #include <set>
-#include <unordered_set>
 
 namespace Tuples {
-        class TupleAssignSpotter {
-          public:
-                // dispatcher for Tuple (multiple and mass) assignment operations
-                TupleAssignSpotter( ResolvExpr::AlternativeFinder & );
-                void spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities );
-
-          private:
-                void match();
-
-                struct Matcher {
-                  public:
-                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts );
-                        virtual ~Matcher() {}
-                        virtual void match( std::list< Expression * > &out ) = 0;
-                        ResolvExpr::AltList lhs, rhs;
-                        TupleAssignSpotter &spotter;
-                        std::list< ObjectDecl * > tmpDecls;
-                };
-
-                struct MassAssignMatcher : public Matcher {
-                  public:
-                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts );
-                        virtual void match( std::list< Expression * > &out );
-                };
-
-                struct MultipleAssignMatcher : public Matcher {
-                  public:
-                        MultipleAssignMatcher( TupleAssignSpotter &spot, const ResolvExpr::AltList & alts );
-                        virtual void match( std::list< Expression * > &out );
-                };
-
-                ResolvExpr::AlternativeFinder &currentFinder;
-                std::string fname;
-                std::unique_ptr< Matcher > matcher;
-        };
-
-        /// true if expr is an expression of tuple type, i.e. a tuple expression, tuple variable, or MRV (multiple-return-value) function
-        bool isTuple( Expression *expr ) {
+        TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder *f )
+                : currentFinder(f), matcher(0), hasMatched( false ) {}
+
+        bool TupleAssignSpotter::pointsToTuple( Expression *expr ) {
+                // also check for function returning tuple of reference types
+                if (AddressExpr *addr = dynamic_cast<AddressExpr *>(expr) )
+                        if ( isTuple(addr->get_arg() ) )
+                                return true;
+                return false;
+        }
+
+        bool TupleAssignSpotter::isTupleVar( DeclarationWithType *decl ) {
+                if ( dynamic_cast<TupleType *>(decl->get_type()) )
+                        return true;
+                return false;
+        }
+
+        bool TupleAssignSpotter::isTuple( Expression *expr, bool isRight ) {
+                // true if `expr' is an expression returning a tuple: tuple, tuple variable or MRV function
                 if ( ! expr ) return false;
-                assert( expr->has_result() );
-                return dynamic_cast<TupleExpr *>(expr) || expr->get_result()->size() > 1;
-        }
-
-        template< typename AltIter >
-        bool isMultAssign( AltIter begin, AltIter end ) {
-                // multiple assignment if more than one alternative in the range or if
-                // the alternative is a tuple
-                if ( begin == end ) return false;
-                if ( isTuple( begin->expr ) ) return true;
-                return ++begin != end;
-        }
-
-        bool pointsToTuple( Expression *expr ) {
-                // also check for function returning tuple of reference types
-                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                        return pointsToTuple( castExpr->get_arg() );
-                } else if ( AddressExpr *addr = dynamic_cast< AddressExpr * >( expr) ) {
-                        return isTuple( addr->get_arg() );
-                }
-                return false;
-        }
-
-        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
-                TupleAssignSpotter spotter( currentFinder );
-                spotter.spot( expr, possibilities );
-        }
-
-        TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder &f )
-                : currentFinder(f) {}
-
-        void TupleAssignSpotter::spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
-                if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
-                        if ( InitTweak::isCtorDtorAssign( op->get_name() ) ) {
-                                fname = op->get_name();
-                                for ( std::list<ResolvExpr::AltList>::const_iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
-                                        if ( ali->size() == 0 ) continue; // AlternativeFinder will natrually handle this case, if it's legal
-                                        if ( ali->size() <= 1 && InitTweak::isAssignment( op->get_name() ) ) {
-                                                // what does it mean if an assignment takes 1 argument? maybe someone defined such a function, in which case AlternativeFinder will naturally handle it
-                                                continue;
-                                        }
-
-                                        assert( ! ali->empty() );
-                                        // grab args 2-N and group into a TupleExpr
-                                        const ResolvExpr::Alternative & alt1 = ali->front();
-                                        auto begin = std::next(ali->begin(), 1), end = ali->end();
-                                        if ( pointsToTuple(alt1.expr) ) {
-                                                if ( isMultAssign( begin, end ) ) {
-                                                        matcher.reset( new MultipleAssignMatcher( *this, *ali ) );
-                                                } else {
+
+                if ( dynamic_cast<TupleExpr *>(expr) )
+                        return true;
+                else if ( VariableExpr *var = dynamic_cast<VariableExpr *>(expr) ) {
+                        if ( isTupleVar(var->get_var()) )
+                                return true;
+                }
+
+                return false;
+        }
+
+        bool TupleAssignSpotter::match() {
+                assert ( matcher != 0 );
+
+                std::list< Expression * > new_assigns;
+                if ( ! matcher->match(new_assigns) )
+                        return false;
+
+                if ( new_assigns.empty() ) return false;
+                /*return */matcher->solve( new_assigns );
+                if ( dynamic_cast<TupleAssignSpotter::MultipleAssignMatcher *>( matcher ) ) {
+                        // now resolve new assignments
+                        std::list< Expression * > solved_assigns;
+                        ResolvExpr::AltList solved_alts;
+                        assert( currentFinder != 0 );
+
+                        ResolvExpr::AltList current;
+                        for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
+                                //try {
+                                ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
+                                finder.findWithAdjustment(*i);
+                                // prune expressions that don't coincide with
+                                ResolvExpr::AltList alts = finder.get_alternatives();
+                                assert( alts.size() == 1 );
+                                assert(alts.front().expr != 0 );
+                                current.push_back( finder.get_alternatives().front() );
+                                solved_assigns.push_back( alts.front().expr->clone() );
+                                //solved_assigns.back()->print(std::cerr);
+                                /*} catch( ... ) {
+                                  continue; // no reasonable alternative found
+                                  }*/
+                        }
+                        options.add_option( current );
+
+                        return true;
+                } else { // mass assignment
+                        //if ( new_assigns.empty() ) return false;
+                        std::list< Expression * > solved_assigns;
+                        ResolvExpr::AltList solved_alts;
+                        assert( currentFinder != 0 );
+
+                        ResolvExpr::AltList current;
+                        if ( optMass.empty() ) {
+                                for ( std::list< Expression * >::size_type i = 0; i != new_assigns.size(); ++i )
+                                        optMass.push_back( ResolvExpr::AltList() );
+                        }
+                        int cnt = 0;
+                        for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i, cnt++ ) {
+
+                                ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
+                                finder.findWithAdjustment(*i);
+                                ResolvExpr::AltList alts = finder.get_alternatives();
+                                assert( alts.size() == 1 );
+                                assert(alts.front().expr != 0 );
+                                current.push_back( finder.get_alternatives().front() );
+                                optMass[cnt].push_back( finder.get_alternatives().front() );
+                                solved_assigns.push_back( alts.front().expr->clone() );
+                        }
+
+                        return true;
+                }
+
+                return false;
+        }
+
+        bool TupleAssignSpotter::isMVR( Expression *expr ) {
+                if ( expr->get_results().size() > 1 ) {
+                        // MVR processing
+                        return true;
+                }
+                return false;
+        }
+
+        bool TupleAssignSpotter::isTupleAssignment( UntypedExpr * expr, std::list<ResolvExpr::AltList> &possibilities ) {
+                if (  NameExpr *assgnop = dynamic_cast< NameExpr * >(expr->get_function()) ) {
+
+                        if ( assgnop->get_name() == std::string("?=?") ) {
+
+                                for ( std::list<ResolvExpr::AltList>::iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
+                                        assert( ali->size() == 2 );
+                                        ResolvExpr::AltList::iterator opit = ali->begin();
+                                        ResolvExpr::Alternative op1 = *opit, op2 = *(++opit);
+
+                                        if ( pointsToTuple(op1.expr) ) { // also handles tuple vars
+                                                if ( isTuple( op2.expr, true ) )
+                                                        matcher = new MultipleAssignMatcher(op1.expr, op2.expr);
+                                                else if ( isMVR( op2.expr ) ) {
+                                                        // handle MVR differently
+                                                } else
                                                         // mass assignment
-                                                        matcher.reset( new MassAssignMatcher( *this,  *ali ) );
+                                                        matcher = new MassAssignMatcher(op1.expr, op2.expr);
+
+                                                std::list< ResolvExpr::AltList > options;
+                                                if ( match() )
+                                                        /*
+                                                          if ( hasMatched ) {
+                                                          // throw SemanticError("Ambiguous tuple assignment");
+                                                          } else {*/
+                                                        // Matched for the first time
+                                                        hasMatched = true;
+                                                /*} */
+                                        } /* else if ( isTuple( op2 ) )
+                                                 throw SemanticError("Inapplicable tuple assignment.");
+                                          */
+                                }
+
+                                if ( hasMatched ) {
+                                        if ( dynamic_cast<TupleAssignSpotter::MultipleAssignMatcher *>( matcher ) ) {
+                                                //options.print( std::cerr );
+                                                std::list< ResolvExpr::AltList >best = options.get_best();
+                                                if ( best.size() == 1 ) {
+                                                        std::list<Expression *> solved_assigns;
+                                                        for ( ResolvExpr::AltList::iterator i = best.front().begin(); i != best.front().end(); ++i ) {
+                                                                solved_assigns.push_back( i->expr );
+                                                        }
+                                                        /* assigning cost zero? */
+                                                        currentFinder->get_alternatives().push_front( ResolvExpr::Alternative(new SolvedTupleExpr(solved_assigns/*, SolvedTupleExpr::MULTIPLE*/), currentFinder->get_environ(), ResolvExpr::Cost() ) );
                                                 }
-                                                match();
+                                        } else {
+                                                assert( ! optMass.empty() );
+                                                ResolvExpr::AltList winners;
+                                                for ( std::vector< ResolvExpr::AltList >::iterator i = optMass.begin(); i != optMass.end(); ++i )
+                                                        findMinCostAlt( i->begin(), i->end(), back_inserter(winners) );
+
+                                                std::list< Expression *> solved_assigns;
+                                                for ( ResolvExpr::AltList::iterator i = winners.begin(); i != winners.end(); ++i )
+                                                        solved_assigns.push_back( i->expr );
+                                                currentFinder->get_alternatives().push_front( ResolvExpr::Alternative(new SolvedTupleExpr(solved_assigns/*, SolvedTupleExpr::MASS*/), currentFinder->get_environ(), ResolvExpr::Cost() ) );
                                         }
                                 }
                         }
                 }
-        }
-
-        void TupleAssignSpotter::match() {
-                assert ( matcher != 0 );
-
-                std::list< Expression * > new_assigns;
-                matcher->match( new_assigns );
-
-                if ( new_assigns.empty() ) return;
-                ResolvExpr::AltList current;
-                // now resolve new assignments
-                for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
-                        ResolvExpr::AlternativeFinder finder( currentFinder.get_indexer(), currentFinder.get_environ() );
-                        try {
-                                finder.findWithAdjustment(*i);
-                        } catch (...) {
-                                return; // xxx - no match should not mean failure, it just means this particular tuple assignment isn't valid
+                return hasMatched;
+        }
+
+        void TupleAssignSpotter::Matcher::init( Expression *_lhs, Expression *_rhs ) {
+                lhs.clear();
+                if (AddressExpr *addr = dynamic_cast<AddressExpr *>(_lhs) )
+                        if ( TupleExpr *tuple = dynamic_cast<TupleExpr *>(addr->get_arg()) )
+                                std::copy( tuple->get_exprs().begin(), tuple->get_exprs().end(), back_inserter(lhs) );
+
+                rhs.clear();
+        }
+
+        TupleAssignSpotter::Matcher::Matcher( /*TupleAssignSpotter &spot,*/ Expression *_lhs, Expression *_rhs ) /*: own_spotter(spot) */{
+                init(_lhs,_rhs);
+        }
+
+        TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( Expression *_lhs, Expression *_rhs )/* : own_spotter(spot) */{
+                init(_lhs,_rhs);
+
+                if ( TupleExpr *tuple = dynamic_cast<TupleExpr *>(_rhs) )
+                        std::copy( tuple->get_exprs().begin(), tuple->get_exprs().end(), back_inserter(rhs) );
+        }
+
+        UntypedExpr *TupleAssignSpotter::Matcher::createAssgn( Expression *left, Expression *right ) {
+                if ( left && right ) {
+                        std::list< Expression * > args;
+                        args.push_back(new AddressExpr(left->clone()));  args.push_back(right->clone());
+                        return new UntypedExpr(new NameExpr("?=?"), args);
+                } else
+                        throw 0; // xxx - diagnose the problem
+        }
+
+        bool TupleAssignSpotter::MassAssignMatcher::match( std::list< Expression * > &out ) {
+                if ( lhs.empty() || (rhs.size() != 1) ) return false;
+
+                for ( std::list< Expression * >::iterator l = lhs.begin(); l != lhs.end(); l++ ) {
+                        std::list< Expression * > args;
+                        args.push_back( new AddressExpr(*l) );
+                        args.push_back( rhs.front() );
+                        out.push_back( new UntypedExpr(new NameExpr("?=?"), args) );
+                }
+
+                return true;
+        }
+
+        bool TupleAssignSpotter::MassAssignMatcher::solve( std::list< Expression * > &assigns ) {
+                /*
+                  std::list< Expression * > solved_assigns;
+                  ResolvExpr::AltList solved_alts;
+                  assert( currentFinder != 0 );
+
+                  ResolvExpr::AltList current;
+                  if ( optMass.empty() ) {
+                  for ( std::list< Expression * >::size_type i = 0; i != new_assigns.size(); ++i )
+                  optMass.push_back( ResolvExpr::AltList() );
+                  }
+                  int cnt = 0;
+                  for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i, cnt++ ) {
+
+                  ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
+                  finder.findWithAdjustment(*i);
+                  ResolvExpr::AltList alts = finder.get_alternatives();
+                  assert( alts.size() == 1 );
+                  assert(alts.front().expr != 0 );
+                  current.push_back( finder.get_alternatives().front() );
+                  optMass[cnt].push_back( finder.get_alternatives().front() );
+                  solved_assigns.push_back( alts.front().expr->clone() );
+                  }
+                */
+                return true;
+        }
+
+        bool TupleAssignSpotter::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
+                // need more complicated matching
+                if ( lhs.size() == rhs.size() ) {
+                        zipWith( lhs.begin(), lhs.end(), rhs.begin(), rhs.end(), back_inserter(out), TupleAssignSpotter::Matcher::createAssgn );
+                        return true;
+                } //else
+                //std::cerr << "The length of (left, right) is: (" << lhs.size() << "," << rhs.size() << ")" << std::endl;*/
+                return false;
+        }
+
+        bool TupleAssignSpotter::MultipleAssignMatcher::solve( std::list< Expression * > &assigns ) {
+                /*
+                  std::list< Expression * > solved_assigns;
+                  ResolvExpr::AltList solved_alts;
+                  assert( currentFinder != 0 );
+
+                  ResolvExpr::AltList current;
+                  for ( std::list< Expression * >::iterator i = new_assigns.begin(); i != new_assigns.end(); ++i ) {
+                  //try {
+                  ResolvExpr::AlternativeFinder finder( currentFinder->get_indexer(), currentFinder->get_environ() );
+                  finder.findWithAdjustment(*i);
+                  // prune expressions that don't coincide with
+                  ResolvExpr::AltList alts = finder.get_alternatives();
+                  assert( alts.size() == 1 );
+                  assert(alts.front().expr != 0 );
+                  current.push_back( finder.get_alternatives().front() );
+                  solved_assigns.push_back( alts.front().expr->clone() );
+                  //solved_assigns.back()->print(std::cerr);
+                  //} catch( ... ) {
+                  //continue; // no reasonable alternative found
+                  //}
+                  }
+                  options.add_option( current );
+                */
+
+                return true;
+        }
+
+        void TupleAssignSpotter::Options::add_option( ResolvExpr::AltList &opt ) {
+                using namespace std;
+
+                options.push_back( opt );
+                /*
+                  vector< Cost > costs;
+                  costs.reserve( opt.size() );
+                  transform( opt.begin(), opt.end(), back_inserter(costs), ptr_fun(extract_cost) );
+                */
+                // transpose matrix
+                if ( costMatrix.empty() )
+                        for ( unsigned int i = 0; i< opt.size(); ++i)
+                                costMatrix.push_back( vector<ResolvExpr::Cost>() );
+
+                int cnt = 0;
+                for ( ResolvExpr::AltList::iterator i = opt.begin(); i != opt.end(); ++i, cnt++ )
+                        costMatrix[cnt].push_back( i->cost );
+
+                return;
+        }
+
+        std::list< ResolvExpr::AltList > TupleAssignSpotter::Options::get_best() {
+                using namespace std;
+                using namespace ResolvExpr;
+                list< ResolvExpr::AltList > ret;
+                list< multiset<int> > solns;
+                for ( vector< vector<Cost> >::iterator i = costMatrix.begin(); i != costMatrix.end(); ++i ) {
+                        list<int> current;
+                        findMinCost( i->begin(), i->end(), back_inserter(current) );
+                        solns.push_back( multiset<int>(current.begin(), current.end()) );
+                }
+                // need to combine
+                multiset<int> result;
+                lift_intersection( solns.begin(), solns.end(), inserter( result, result.begin() ) );
+                if ( result.size() != 1 )
+                        throw SemanticError("Ambiguous tuple expression");
+                ret.push_back(get_option( *(result.begin() )));
+                return ret;
+        }
+
+        void TupleAssignSpotter::Options::print( std::ostream &ostr ) {
+                using namespace std;
+
+                for ( vector< vector < ResolvExpr::Cost > >::iterator i = costMatrix.begin(); i != costMatrix.end(); ++i ) {
+                        for ( vector < ResolvExpr::Cost >::iterator j = i->begin(); j != i->end(); ++j )
+                                ostr << *j << " " ;
+                        ostr << std::endl;
+                } // for
+                return;
+        }
+
+        ResolvExpr::Cost extract_cost( ResolvExpr::Alternative &alt ) {
+                return alt.cost;
+        }
+
+        template< typename InputIterator, typename OutputIterator >
+        void TupleAssignSpotter::Options::findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
+                using namespace ResolvExpr;
+                std::list<int> alternatives;
+
+                // select the alternatives that have the minimum parameter cost
+                Cost minCost = Cost::infinity;
+                unsigned int index = 0;
+                for ( InputIterator i = begin; i != end; ++i, index++ ) {
+                        if ( *i < minCost ) {
+                                minCost = *i;
+                                alternatives.clear();
+                                alternatives.push_back( index );
+                        } else if ( *i == minCost ) {
+                                alternatives.push_back( index );
                         }
-                        // prune expressions that don't coincide with
-                        ResolvExpr::AltList alts = finder.get_alternatives();
-                        assert( alts.size() == 1 );
-                        assert( alts.front().expr != 0 );
-                        current.push_back( alts.front() );
-                }
-
-                // extract expressions from the assignment alternatives to produce a list of assignments that
-                // together form a single alternative
-                std::list< Expression *> solved_assigns;
-                for ( ResolvExpr::Alternative & alt : current ) {
-                        solved_assigns.push_back( alt.expr->clone() );
-                }
-                // xxx - need to do this??
-                ResolvExpr::TypeEnvironment compositeEnv;
-                simpleCombineEnvironments( current.begin(), current.end(), compositeEnv );
-                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(new TupleAssignExpr(solved_assigns, matcher->tmpDecls), compositeEnv, ResolvExpr::sumCost( current ) ) );
-        }
-
-        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList &alts ) : spotter(spotter) {
-                assert( ! alts.empty() );
-                ResolvExpr::Alternative lhsAlt = alts.front();
-                // peel off the cast that exists on ctor/dtor expressions
-                bool isCast = false;
-                if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( lhsAlt.expr ) ) {
-                        lhsAlt.expr = castExpr->get_arg();
-                        castExpr->set_arg( nullptr );
-                        delete castExpr;
-                        isCast = true;
-                }
-
-                // explode the lhs so that each field of the tuple-valued-expr is assigned.
-                explode( lhsAlt, spotter.currentFinder.get_indexer(), back_inserter(lhs) );
-
-                // and finally, re-add the cast to each lhs expr, so that qualified tuple fields can be constructed
-                if ( isCast ) {
-                        for ( ResolvExpr::Alternative & alt : lhs ) {
-                                Expression *& expr = alt.expr;
-                                Type * castType = expr->get_result()->clone();
-                                Type * type = InitTweak::getPointerBase( castType );
-                                assert( type );
-                                type->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
-                                type->set_isLvalue( true ); // xxx - might not need this
-                                expr = new CastExpr( expr, castType );
-                        }
-                }
-        }
-
-        TupleAssignSpotter::MassAssignMatcher::MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
-                assert( alts.size() == 1 || alts.size() == 2 );
-                if ( alts.size() == 2 ) {
-                        rhs.push_back( alts.back() );
-                }
-        }
-
-        TupleAssignSpotter::MultipleAssignMatcher::MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList & alts ) : Matcher( spotter, alts ) {
-                // explode the rhs so that each field of the tuple-valued-expr is assigned.
-                explode( std::next(alts.begin(), 1), alts.end(), spotter.currentFinder.get_indexer(), back_inserter(rhs) );
-        }
-
-        UntypedExpr * createFunc( const std::string &fname, ObjectDecl *left, ObjectDecl *right ) {
-                assert( left );
-                std::list< Expression * > args;
-                args.push_back( new AddressExpr( UntypedExpr::createDeref( new VariableExpr( left ) ) ) );
-                // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
-                if ( right ) args.push_back( new VariableExpr( right ) );
-                return new UntypedExpr( new NameExpr( fname ), args );
-        }
-
-        ObjectDecl * newObject( UniqueName & namer, Expression * expr ) {
-                assert( expr->has_result() && ! expr->get_result()->isVoid() );
-                return new ObjectDecl( namer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
-        }
-
-        void TupleAssignSpotter::MassAssignMatcher::match( std::list< Expression * > &out ) {
-                static UniqueName lhsNamer( "__massassign_L" );
-                static UniqueName rhsNamer( "__massassign_R" );
-                assert ( ! lhs.empty() && rhs.size() <= 1);
-
-                ObjectDecl * rtmp = rhs.size() == 1 ? newObject( rhsNamer, rhs.front().expr ) : nullptr;
-                for ( ResolvExpr::Alternative & lhsAlt : lhs ) {
-                        ObjectDecl * ltmp = newObject( lhsNamer, lhsAlt.expr );
-                        out.push_back( createFunc( spotter.fname, ltmp, rtmp ) );
-                        tmpDecls.push_back( ltmp );
-                }
-                if ( rtmp ) tmpDecls.push_back( rtmp );
-        }
-
-        void TupleAssignSpotter::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
-                static UniqueName lhsNamer( "__multassign_L" );
-                static UniqueName rhsNamer( "__multassign_R" );
-
-                // xxx - need more complicated matching?
-                if ( lhs.size() == rhs.size() ) {
-                        std::list< ObjectDecl * > ltmp;
-                        std::list< ObjectDecl * > rtmp;
-                        std::transform( lhs.begin(), lhs.end(), back_inserter( ltmp ), []( ResolvExpr::Alternative & alt ){
-                                return newObject( lhsNamer, alt.expr );
-                        });
-                        std::transform( rhs.begin(), rhs.end(), back_inserter( rtmp ), []( ResolvExpr::Alternative & alt ){
-                                return newObject( rhsNamer, alt.expr );
-                        });
-                        zipWith( ltmp.begin(), ltmp.end(), rtmp.begin(), rtmp.end(), back_inserter(out), [&](ObjectDecl * obj1, ObjectDecl * obj2 ) { return createFunc(spotter.fname, obj1, obj2); } );
-                        tmpDecls.splice( tmpDecls.end(), ltmp );
-                        tmpDecls.splice( tmpDecls.end(), rtmp );
-                }
+                }
+                std::copy( alternatives.begin(), alternatives.end(), out );
+        }
+
+        template< class InputIterator, class OutputIterator >
+        void TupleAssignSpotter::Options::lift_intersection( InputIterator begin, InputIterator end, OutputIterator out ) {
+                if ( begin == end ) return;
+                InputIterator test = begin;
+
+                if (++test == end)
+                        { copy(begin->begin(), begin->end(), out); return; }
+
+
+                std::multiset<int> cur; // InputIterator::value_type::value_type
+                copy( begin->begin(), begin->end(), inserter( cur, cur.begin() ) );
+
+                while ( test != end ) {
+                        std::multiset<int> temp;
+                        set_intersection( cur.begin(), cur.end(), test->begin(), test->end(), inserter(temp,temp.begin()) );
+                        cur.clear();
+                        copy( temp.begin(), temp.end(), inserter(cur,cur.begin()));
+                        ++test;
+                }
+
+                copy( cur.begin(), cur.end(), out );
+                return;
+        }
+
+        ResolvExpr::AltList TupleAssignSpotter::Options::get_option( std::list< ResolvExpr::AltList >::size_type index ) {
+                if ( index >= options.size() )
+                        throw 0; // XXX
+                std::list< ResolvExpr::AltList >::iterator it = options.begin();
+                for ( std::list< ResolvExpr::AltList >::size_type i = 0; i < index; ++i, ++it );
+                return *it;
         }
 } // namespace Tuples

src/Tuples/module.mk

@@ -6 +6 @@
 ## file "LICENCE" distributed with Cforall.
 ##
-## module.mk --
+## module.mk -- 
 ##
 ## Author           : Richard C. Bilson
@@ -16 +16 @@
 
 SRC +=  Tuples/TupleAssignment.cc \
-        Tuples/TupleExpansion.cc \
-        Tuples/Explode.cc
+        Tuples/NameMatcher.cc

src/main.cc

@@ -43 +43 @@
 #include "Common/UnimplementedError.h"
 #include "../config.h"
-#include "Tuples/Tuples.h"
 
 using namespace std;
@@ -237 +236 @@
                 OPTPRINT( "tweakInit" )
                 InitTweak::genInit( translationUnit );
-                OPTPRINT( "expandMemberTuples" );
-                Tuples::expandMemberTuples( translationUnit );
+
                 if ( libcfap ) {
                         // generate the bodies of cfa library functions
@@ -263 +261 @@
                         return 0;
                 } // if
-
-                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 - needs to go after InitTweak::fix so that copy constructed return declarations are reused
-                Tuples::expandUniqueExpr( translationUnit );
 
                 OPTPRINT("instantiateGenerics")
@@ -282 +277 @@
                 OPTPRINT( "box" )
                 GenPoly::box( translationUnit );
-                OPTPRINT( "expandTuples" ); // xxx - is this the right place for this?
-                Tuples::expandTuples( translationUnit );
 
                 // print tree right before code generation