Changeset a32b204

Timestamp:

May 17, 2015, 1:19:35 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, string, with_gc

Children:

0dd3a2f

Parents:

b87a5ed

Message:

licencing: second groups of files

Location:

translator

Files:

• ArgTweak/FunctionFixer.cc (modified) (1 diff)
• CodeGen/CodeGenerator2.cc (modified) (2 diffs)
• CodeGen/CodeGenerator2.h (modified) (1 diff)
• CodeGen/FixNames.cc (modified) (1 diff)
• CodeGen/OperatorTable.cc (modified) (2 diffs)
• Common/utility.h (modified) (13 diffs)
• ControlStruct/CaseRangeMutator.cc (modified) (2 diffs)
• ControlStruct/MLEMutator.cc (modified) (2 diffs)
• GenPoly/Box.cc (modified) (18 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/PolyMutator.cc (modified) (5 diffs)
• GenPoly/ScrubTyVars.cc (modified) (1 diff)
• GenPoly/Specialize.cc (modified) (8 diffs)
• InitTweak/Association.h (modified) (9 diffs)
• InitTweak/BasicInit.cc (modified) (5 diffs)
• InitTweak/BasicInit.h (modified) (2 diffs)
• InitTweak/DeclarationHoister.cc (modified) (2 diffs)
• InitTweak/InitExpander.cc (modified) (1 diff)
• InitTweak/InitModel.cc (modified) (11 diffs)
• InitTweak/InitModel.h (modified) (1 diff)
• InitTweak/RemoveInit.cc (modified) (1 diff)
• InitTweak/diet_map.h (modified) (6 diffs)
• MakeLibCfa.cc (modified) (3 diffs)
• Parser/DeclarationNode.cc (modified) (7 diffs)
• Parser/ExpressionNode.cc (modified) (3 diffs)
• Parser/InitializerNode.cc (modified) (1 diff)
• Parser/ParseNode.cc (modified) (1 diff)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/StatementNode.cc (modified) (3 diffs)
• Parser/TypeData.cc (modified) (9 diffs)
• Parser/TypedefTable.cc (modified) (2 diffs)
• ResolvExpr/AdjustExprType.cc (modified) (2 diffs)
• ResolvExpr/Alternative.cc (modified) (2 diffs)
• ResolvExpr/Alternative.h (modified) (2 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (3 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (2 diffs)
• ResolvExpr/AlternativePrinter.cc (modified) (2 diffs)
• ResolvExpr/AlternativePrinter.h (modified) (2 diffs)
• ResolvExpr/CastCost.cc (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (2 diffs)
• ResolvExpr/ConversionCost.cc (modified) (3 diffs)
• ResolvExpr/ConversionCost.h (modified) (2 diffs)
• ResolvExpr/Cost.h (modified) (1 diff)
• ResolvExpr/FindOpenVars.cc (modified) (3 diffs)
• ResolvExpr/FindOpenVars.h (modified) (2 diffs)
• ResolvExpr/Occurs.cc (modified) (2 diffs)
• ResolvExpr/PolyCost.cc (modified) (2 diffs)
• ResolvExpr/PtrsAssignable.cc (modified) (4 diffs)
• ResolvExpr/PtrsCastable.cc (modified) (2 diffs)
• ResolvExpr/RenameVars.cc (modified) (2 diffs)
• ResolvExpr/RenameVars.h (modified) (2 diffs)
• ResolvExpr/ResolveTypeof.cc (modified) (3 diffs)
• ResolvExpr/ResolveTypeof.h (modified) (2 diffs)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• ResolvExpr/Resolver.h (modified) (2 diffs)
• ResolvExpr/TypeEnvironment.cc (modified) (2 diffs)
• ResolvExpr/TypeEnvironment.h (modified) (2 diffs)
• ResolvExpr/Unify.cc (modified) (4 diffs)
• ResolvExpr/Unify.h (modified) (2 diffs)
• ResolvExpr/typeops.h (modified) (2 diffs)
• SymTab/AddVisit.h (modified) (2 diffs)
• SymTab/AggregateTable.h (modified) (1 diff)
• SymTab/IdTable.cc (modified) (9 diffs)
• SymTab/ImplementationType.cc (modified) (4 diffs)
• SymTab/ImplementationType.h (modified) (1 diff)
• SymTab/Mangler.cc (modified) (1 diff)
• SymTab/StackTable.cc (modified) (4 diffs)
• SymTab/TypeTable.h (modified) (1 diff)
• SynTree/AddressExpr.cc (modified) (2 diffs)
• SynTree/AggregateDecl.cc (modified) (2 diffs)
• SynTree/ApplicationExpr.cc (modified) (3 diffs)
• SynTree/ArrayType.cc (modified) (2 diffs)
• SynTree/AttrType.cc (modified) (1 diff)
• SynTree/BasicType.cc (modified) (1 diff)
• SynTree/CodeGenVisitor.cc (modified) (2 diffs)
• SynTree/Constant.cc (modified) (1 diff)
• SynTree/DeclStmt.cc (modified) (1 diff)
• SynTree/Declaration.cc (modified) (2 diffs)
• SynTree/Expression.cc (modified) (10 diffs)
• SynTree/FunctionDecl.cc (modified) (1 diff)
• SynTree/Initializer.cc (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/NamedTypeDecl.cc (modified) (2 diffs)
• SynTree/PointerType.cc (modified) (1 diff)
• SynTree/ReferenceToType.cc (modified) (3 diffs)
• SynTree/Statement.cc (modified) (13 diffs)
• SynTree/Type.cc (modified) (1 diff)
• SynTree/TypeExpr.cc (modified) (1 diff)
• SynTree/TypeSubstitution.cc (modified) (12 diffs)
• SynTree/TypeSubstitution.h (modified) (4 diffs)
• SynTree/TypeofType.cc (modified) (1 diff)
• SynTree/Visitor.h (modified) (2 diffs)
• Tests/ResolvExpr/Statement.c (modified) (1 diff)
• Tests/Syntax/Expression.c (modified) (1 diff)
• Tests/gcc/920409-2.c (modified) (1 diff)
• Tests/gcc/920410-2.c (modified) (1 diff)
• Tuples/AssignExpand.cc (modified) (5 diffs)
• Tuples/FunctionChecker.cc (modified) (5 diffs)
• Tuples/FunctionFixer.cc (modified) (4 diffs)
• Tuples/MultRet.cc (modified) (6 diffs)
• Tuples/NameMatcher.cc (modified) (4 diffs)
• Tuples/TupleAssignment.cc (modified) (26 diffs)
• Tuples/TupleAssignment.h (modified) (1 diff)
• examples/iostream.c (modified) (1 diff)
• examples/iterator.c (modified) (1 diff)
• examples/iterator.h (modified) (1 diff)
• examples/simplePoly.c (modified) (1 diff)
• examples/test.c (deleted)

translator/ArgTweak/FunctionFixer.cc

@@ -56 +56 @@
                                                 if ( ( candidateExists = align( f->get_parameters(), untypedExpr->get_args(), Matcher() ) ) ) break;
 
-                                        if ( !candidateExists ) throw SemanticError("Error in function call");
+                                        if ( ! candidateExists ) throw SemanticError("Error in function call");
                                 } // if
                         } // for

translator/CodeGen/CodeGenerator2.cc

@@ -553 +553 @@
             before << "do" ;
         else {
-            before << "while(" ;
+            before << "while (" ;
             whileStmt->get_condition()->accept(*this );
             after += ")";
@@ -565 +565 @@
 
         if ( whileStmt->get_isDoWhile() ) {
-            before << " while(" ;
+            before << " while (" ;
             whileStmt->get_condition()->accept(*this );
             after += ");";

translator/CodeGen/CodeGenerator2.h

@@ -97 +97 @@
     inline bool doSemicolon( Declaration* decl ) {
         if ( FunctionDecl* func = dynamic_cast< FunctionDecl* >( decl ) ) {
-            return !func->get_statements();
+            return ! func->get_statements();
         }
         return true;

translator/CodeGen/FixNames.cc

@@ -32 +32 @@
 fixDWT( DeclarationWithType *dwt )
 {
-  if( dwt->get_name() != "" ) {
-    if( LinkageSpec::isDecoratable( dwt->get_linkage() ) ) {
+  if ( dwt->get_name() != "" ) {
+    if ( LinkageSpec::isDecoratable( dwt->get_linkage() ) ) {
       dwt->set_mangleName( SymTab::Mangler::mangle( dwt ) );
     }

translator/CodeGen/OperatorTable.cc

@@ -64 +64 @@
 initialize()
 {
-  for( int i = 0; i < numOps; ++i ) {
+  for ( int i = 0; i < numOps; ++i ) {
     table[ tableValues[i].inputName ] = tableValues[i];
   }
@@ -75 +75 @@
 {
   static bool init = false;
-  if( !init ) {
+  if ( ! init ) {
     initialize();
   }
   std::map< std::string, OperatorInfo >::const_iterator i = table.find( funcName );
-  if( i == table.end() ) {
+  if ( i == table.end() ) {
     return false;
   } else {

translator/Common/utility.h

@@ -22 +22 @@
 maybeClone( const T *orig )
 {
-  if( orig ) {
+  if ( orig ) {
     return orig->clone();
   } else {
@@ -33 +33 @@
 maybeBuild( const U *orig )
 {
-  if( orig ) {
+  if ( orig ) {
     return orig->build();
   } else {
@@ -44 +44 @@
 printEnums( Input_iterator begin, Input_iterator end, const char * const *name_array, std::ostream &os )
 {
-  for( Input_iterator i = begin; i != end; ++i ) {
+  for ( Input_iterator i = begin; i != end; ++i ) {
     os << name_array[ *i ] << ' ';
   }
@@ -53 +53 @@
 deleteAll( Container &container )
 {
-  for( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+  for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
     delete *i;
   }
@@ -62 +62 @@
 printAll( const Container &container, std::ostream &os, int indent = 0 )
 {
-  for( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) {
-    if( *i ) {
+  for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) {
+    if ( *i ) {
       os << std::string(indent,  ' ');
       (*i)->print( os, indent + 2 );
@@ -77 +77 @@
   typename SrcContainer::const_iterator in = src.begin();
   std::back_insert_iterator< DestContainer > out( dest );
-  while( in != src.end() ) {
+  while ( in != src.end() ) {
     *out++ = (*in++)->clone();
   }
@@ -87 +87 @@
 {
   int count = 0;
-  for( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) {
-    if( !(*i) ) {
+  for ( typename Container::const_iterator i = container.begin(); i != container.end(); ++i ) {
+    if ( !(*i) ) {
       std::cerr << count << " is null" << std::endl;
     }
@@ -97 +97 @@
 assign_strptr( std::string *str )
 {
-  if( str == 0 ) {
+  if ( str == 0 ) {
     return "";
   } else {
@@ -115 +115 @@
 std::list<T> tail( std::list<T> l )
 {
-  if(! l.empty()){
+  if (! l.empty()){
     std::list<T> ret(++(l.begin()), l.end());
     return ret;
@@ -127 +127 @@
   Ts ret;
 
-  switch( l.size() ){
+  switch ( l.size() ){
   case 0:
     return ret;
@@ -193 +193 @@
 {
   while ( begin++ != end )
-    if( pred(*begin) ) *out++ = *begin;
+    if ( pred(*begin) ) *out++ = *begin;
 
   return;
@@ -200 +200 @@
 template< class InputIterator1, class InputIterator2, class OutputIterator >
 void zip( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out ) {
-  while( b1 != e1 && b2 != e2 )
+  while ( b1 != e1 && b2 != e2 )
     *out++ = std::pair<typename InputIterator1::value_type, typename InputIterator2::value_type>(*b1++, *b2++);
 }
@@ -206 +206 @@
 template< class InputIterator1, class InputIterator2, class OutputIterator, class BinFunction >
 void zipWith( InputIterator1 b1, InputIterator1 e1, InputIterator2 b2, InputIterator2 e2, OutputIterator out, BinFunction func ) {
-  while( b1 != e1 && b2 != e2 )
+  while ( b1 != e1 && b2 != e2 )
     *out++ = func(*b1++, *b2++);
 }

translator/ControlStruct/CaseRangeMutator.cc

@@ -117 +117 @@
                         if ( ch_lo > ch_hi ) { char t=ch_lo; ch_lo=ch_hi; ch_hi=t; }
 
-                        for( char c = ch_lo; c <=  ch_hi; c++ ){
+                        for ( char c = ch_lo; c <=  ch_hi; c++ ){
                             Type::Qualifiers q;
                             Constant cnst( new BasicType(q, BasicType::Char),
@@ -154 +154 @@
                   if ( i_lo > i_hi ) { int t=i_lo; i_lo=i_hi; i_hi=t; }
 
-                  for( int c = i_lo; c <=  i_hi; c++ ){
+                  for ( int c = i_lo; c <=  i_hi; c++ ){
                       Type::Qualifiers q;
                       Constant cnst( new BasicType(q, ty_hi->get_kind()), // figure can't hurt (used to think in positives)

translator/ControlStruct/MLEMutator.cc

@@ -23 +23 @@
             *k = (*k)->acceptMutator(*this);
 
-            if ( !get_breakLabel().empty() ) {
+            if ( ! get_breakLabel().empty() ) {
                 std::list< Statement * >::iterator next = k; next++;
                 if ( next == kids.end() ) {
@@ -98 +98 @@
 
         Label newLabel;
-        switch( branchStmt->get_type() ) {
+        switch ( branchStmt->get_type() ) {
           case BranchStmt::Break:
             if ( check->get_breakExit() != "" )

translator/GenPoly/Box.cc

@@ -110 +110 @@
     void printAllNotBuiltin( const std::list< Declaration *>& translationUnit, std::ostream &os ) {
         for ( std::list< Declaration *>::const_iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
-            if ( !LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) {
+            if ( ! LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) {
                 (*i)->print( os );
                 os << std::endl;
@@ -135 +135 @@
         bool isPolyRet( FunctionType *function, std::string &name, const TyVarMap &otherTyVars ) {
             bool doTransform = false;
-            if ( !function->get_returnVals().empty() ) {
+            if ( ! function->get_returnVals().empty() ) {
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( function->get_returnVals().front()->get_type() ) ) {
     
@@ -146 +146 @@
                         } // if
                     } // for
-                    if ( !doTransform && otherTyVars.find( typeInst->get_name() ) != otherTyVars.end() ) {
+                    if ( ! doTransform && otherTyVars.find( typeInst->get_name() ) != otherTyVars.end() ) {
                         doTransform = true;
                     } // if
@@ -304 +304 @@
                 ObjectDecl *newObj = makeTemporary( retType->clone() );
                 Expression *paramExpr = new VariableExpr( newObj );
-                if ( !isPolyType( newObj->get_type(), env, scopeTyVars ) ) {
+                if ( ! isPolyType( newObj->get_type(), env, scopeTyVars ) ) {
                     paramExpr = new AddressExpr( paramExpr );
                 } // if
@@ -330 +330 @@
         Expression *Pass1::applyAdapter( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &tyVars ) {
             Expression *ret = appExpr;
-            if ( !function->get_returnVals().empty() && isPolyVal( function->get_returnVals().front()->get_type(), tyVars ) ) {
+            if ( ! function->get_returnVals().empty() && isPolyVal( function->get_returnVals().front()->get_type(), tyVars ) ) {
                 ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
             } // if
@@ -343 +343 @@
 
         void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-            assert( !arg->get_results().empty() );
-///   if ( !dynamic_cast< PointerType *>( arg->get_results().front() ) ) {
+            assert( ! arg->get_results().empty() );
+///   if ( ! dynamic_cast< PointerType *>( arg->get_results().front() ) ) {
             TypeInstType *typeInst = dynamic_cast< TypeInstType *>( param );
             if ( typeInst && exprTyVars.find( typeInst->get_name() ) != exprTyVars.end() ) {
@@ -373 +373 @@
             // any function mentioning a polymorphic type
             findAndReplaceFunction( newType, functions, tyVars, needsAdapter );
-            if ( !functions.empty() ) {
+            if ( ! functions.empty() ) {
                 actual = new CastExpr( actual, newType );
             } else {
@@ -422 +422 @@
             // actually make the adapter type
             FunctionType *adapter = adaptee->clone();
-            if ( !adapter->get_returnVals().empty() && isPolyVal( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
+            if ( ! adapter->get_returnVals().empty() && isPolyVal( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
                 makeRetParm( adapter );
             } // if
@@ -611 +611 @@
                 if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
                     if ( varExpr->get_var()->get_name() == "?[?]" ) {
-                        assert( !appExpr->get_results().empty() );
+                        assert( ! appExpr->get_results().empty() );
                         assert( appExpr->get_args().size() == 2 );
                         TypeInstType *typeInst1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), env, scopeTyVars );
                         TypeInstType *typeInst2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), env, scopeTyVars );
-                        assert( !typeInst1 || !typeInst2 );
+                        assert( ! typeInst1 || ! typeInst2 );
                         UntypedExpr *ret = 0;
                         if ( typeInst1 || typeInst2 ) {
@@ -644 +644 @@
                         } // if
                     } else if ( varExpr->get_var()->get_name() == "*?" ) {
-                        assert( !appExpr->get_results().empty() );
-                        assert( !appExpr->get_args().empty() );
+                        assert( ! appExpr->get_results().empty() );
+                        assert( ! appExpr->get_args().empty() );
                         if ( isPolyType( appExpr->get_results().front(), env, scopeTyVars ) ) {
                             Expression *ret = appExpr->get_args().front();
@@ -659 +659 @@
                         } // if
                     } else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
-                        assert( !appExpr->get_results().empty() );
+                        assert( ! appExpr->get_results().empty() );
                         assert( appExpr->get_args().size() == 1 );
                         if ( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
@@ -679 +679 @@
                         } // if
                     } else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
-                        assert( !appExpr->get_results().empty() );
+                        assert( ! appExpr->get_results().empty() );
                         assert( appExpr->get_args().size() == 1 );
                         if ( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
@@ -685 +685 @@
                         } // if
                     } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
-                        assert( !appExpr->get_results().empty() );
+                        assert( ! appExpr->get_results().empty() );
                         assert( appExpr->get_args().size() == 2 );
                         TypeInstType *typeInst1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), env, scopeTyVars );
@@ -711 +711 @@
                         } // if
                     } else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
-                        assert( !appExpr->get_results().empty() );
+                        assert( ! appExpr->get_results().empty() );
                         assert( appExpr->get_args().size() == 2 );
                         TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars );
@@ -739 +739 @@
             useRetval = oldUseRetval;
   
-            assert( !appExpr->get_function()->get_results().empty() );
+            assert( ! appExpr->get_function()->get_results().empty() );
             PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
             assert( pointer );
@@ -784 +784 @@
 
         Expression *Pass1::mutate( UntypedExpr *expr ) {
-            if ( !expr->get_results().empty() && isPolyType( expr->get_results().front(), env, scopeTyVars ) ) {
+            if ( ! expr->get_results().empty() && isPolyType( expr->get_results().front(), env, scopeTyVars ) ) {
                 if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
                     if ( name->get_name() == "*?" ) {
@@ -798 +798 @@
 
         Expression *Pass1::mutate( AddressExpr *addrExpr ) {
-            assert( !addrExpr->get_arg()->get_results().empty() );
+            assert( ! addrExpr->get_arg()->get_results().empty() );
             addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
             if ( isPolyType( addrExpr->get_arg()->get_results().front(), env, scopeTyVars ) ) {
@@ -823 +823 @@
             }
             if ( retval && retStmt->get_expr() ) {
-                assert( !retStmt->get_expr()->get_results().empty() );
+                assert( ! retStmt->get_expr()->get_results().empty() );
                 if ( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
 ///       retStmt->set_expr( mutateExpression( retStmt->get_expr() ) );

translator/GenPoly/CopyParams.cc

@@ -46 +46 @@
                     } // if
                 } // for
-                for( std::list< DeclarationWithType* >::iterator param = funcDecl->get_functionType()->get_parameters().begin(); param != funcDecl->get_functionType()->get_parameters().end(); ++param ) {
+                for ( std::list< DeclarationWithType* >::iterator param = funcDecl->get_functionType()->get_parameters().begin(); param != funcDecl->get_functionType()->get_parameters().end(); ++param ) {
                     std::set< UniqueId >::const_iterator var = modVars.find( (*param)->get_uniqueId() );
                     if ( var != modVars.end() ) {

translator/GenPoly/FindFunction.cc

@@ -52 +52 @@
 FindFunction::handleForall( const std::list< TypeDecl* > &forall )
 {
-  for( std::list< TypeDecl* >::const_iterator i = forall.begin(); i != forall.end(); ++i ) {
+  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() ) {
+    if ( var != tyVars.end() ) {
       tyVars.erase( var );
     }
@@ -67 +67 @@
   mutateAll( functionType->get_returnVals(), *this );
   Type *ret = functionType;
-  if( predicate( functionType, tyVars ) ) {
+  if ( predicate( functionType, tyVars ) ) {
     functions.push_back( functionType );
-    if( replaceMode ) {
+    if ( replaceMode ) {
       ret = new FunctionType( Type::Qualifiers(), true );
     }

translator/GenPoly/GenPoly.cc

@@ -26 +26 @@
 isPolyVal( Type *type, const TyVarMap &tyVars, bool considerAllTyVars )
 {
-  if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
-    if( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
+  if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
+    if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
       return true;
     }
@@ -41 +41 @@
 {
   bool needsAdapter = false;
-  if( !adaptee->get_returnVals().empty() && isPolyVal( adaptee->get_returnVals().front()->get_type(), tyVars, considerAllTyVars ) ) {
+  if ( ! adaptee->get_returnVals().empty() && isPolyVal( adaptee->get_returnVals().front()->get_type(), tyVars, considerAllTyVars ) ) {
     needsAdapter = true;
   }
-  for( std::list< DeclarationWithType* >::const_iterator innerArg = adaptee->get_parameters().begin(); !needsAdapter && innerArg != adaptee->get_parameters().end(); ++innerArg ) {
-    if( isPolyVal( (*innerArg)->get_type(), tyVars, considerAllTyVars ) ) {
+  for ( std::list< DeclarationWithType* >::const_iterator innerArg = adaptee->get_parameters().begin(); ! needsAdapter && innerArg != adaptee->get_parameters().end(); ++innerArg ) {
+    if ( isPolyVal( (*innerArg)->get_type(), tyVars, considerAllTyVars ) ) {
       needsAdapter = true;
     }
@@ -56 +56 @@
 printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap )
 {
-  for( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {
+  for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {
     os << i->first << " (" << i->second << ") ";
   }

translator/GenPoly/Lvalue.cc

@@ -67 +67 @@
 isLvalueRet( FunctionType *function )
 {
-  if( !function->get_returnVals().empty() ) {
+  if ( ! function->get_returnVals().empty() ) {
     return function->get_returnVals().front()->get_type()->get_isLvalue();
   } else {
@@ -77 +77 @@
 isIntrinsicApp( ApplicationExpr *appExpr )
 {
-  if( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( appExpr->get_function() ) ) {
+  if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( appExpr->get_function() ) ) {
     return varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic;
   } else {
@@ -91 +91 @@
 Pass1::mutate( FunctionDecl *funcDecl )
 {
-  if( funcDecl->get_statements() ) {
+  if ( funcDecl->get_statements() ) {
     DeclarationWithType* oldRetval = retval;
     retval = 0;
-    if( !LinkageSpec::isBuiltin( funcDecl->get_linkage() ) && isLvalueRet( funcDecl->get_functionType() ) ) {
+    if ( ! LinkageSpec::isBuiltin( funcDecl->get_linkage() ) && isLvalueRet( funcDecl->get_functionType() ) ) {
       retval = funcDecl->get_functionType()->get_returnVals().front();
     }
@@ -110 +110 @@
   mutateAll( appExpr->get_args(), *this );
   
-  assert( !appExpr->get_function()->get_results().empty() );
+  assert( ! appExpr->get_function()->get_results().empty() );
 
   PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
@@ -118 +118 @@
 
   std::string typeName;
-  if( isLvalueRet( function ) && !isIntrinsicApp( appExpr ) ) {
+  if ( isLvalueRet( function ) && ! isIntrinsicApp( appExpr ) ) {
     UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
     deref->get_results().push_back( appExpr->get_results().front() );
@@ -132 +132 @@
 Pass1::mutate(ReturnStmt *retStmt)
 {
-  if( retval && retStmt->get_expr() ) {
-    assert( !retStmt->get_expr()->get_results().empty() );
-    while( CastExpr *castExpr = dynamic_cast< CastExpr* >( retStmt->get_expr() ) ) {
+  if ( retval && retStmt->get_expr() ) {
+    assert( ! retStmt->get_expr()->get_results().empty() );
+    while ( CastExpr *castExpr = dynamic_cast< CastExpr* >( retStmt->get_expr() ) ) {
       retStmt->set_expr( castExpr->get_arg() );
       retStmt->get_expr()->set_env( castExpr->get_env() );
@@ -141 +141 @@
       delete castExpr;
     }
-    if( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
+    if ( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
       retStmt->set_expr( new AddressExpr( retStmt->get_expr()->acceptMutator( *this ) ) );
     } else {
@@ -154 +154 @@
 {
   std::string typeName;
-  if( isLvalueRet( funType ) ) {
+  if ( isLvalueRet( funType ) ) {
     DeclarationWithType *retParm = funType->get_returnVals().front();
     

translator/GenPoly/PolyMutator.cc

@@ -28 +28 @@
 PolyMutator::mutateStatementList( std::list< Statement* > &statements )
 {
-  for( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
-    if( !stmtsToAddAfter.empty() ) {
+  for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
+    if ( ! stmtsToAddAfter.empty() ) {
       statements.splice( i, stmtsToAddAfter );
     }
     *i = (*i)->acceptMutator( *this );
-    if( !stmtsToAdd.empty() ) {
+    if ( ! stmtsToAdd.empty() ) {
       statements.splice( i, stmtsToAdd );
     }
   }
-  if( !stmtsToAddAfter.empty() ) {
+  if ( ! stmtsToAddAfter.empty() ) {
     statements.splice( statements.end(), stmtsToAddAfter );
   }
@@ -46 +46 @@
 {
   Statement *newStmt = maybeMutate( stmt, *this );
-  if( !stmtsToAdd.empty() || !stmtsToAddAfter.empty() ) {
+  if ( ! stmtsToAdd.empty() || ! stmtsToAddAfter.empty() ) {
     CompoundStmt *compound = new CompoundStmt( noLabels );
     compound->get_kids().splice( compound->get_kids().end(), stmtsToAdd );
@@ -61 +61 @@
 PolyMutator::mutateExpression( Expression *expr )
 {
-  if( expr ) {
-    if( expr->get_env() ) {
+  if ( expr ) {
+    if ( expr->get_env() ) {
       env = expr->get_env();
     }
@@ -167 +167 @@
 PolyMutator::mutate(UntypedExpr *untypedExpr)
 {
-  for( std::list< Expression* >::iterator i = untypedExpr->get_args().begin(); i != untypedExpr->get_args().end(); ++i ) {
+  for ( std::list< Expression* >::iterator i = untypedExpr->get_args().begin(); i != untypedExpr->get_args().end(); ++i ) {
     *i = mutateExpression( *i );
   }
@@ -177 +177 @@
 PolyMutator::makeTyVarMap( Type *type, TyVarMap &tyVarMap )
 {
-  for( std::list< TypeDecl* >::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();
   }
-  if( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
+  if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
     makeTyVarMap( pointer->get_base(), tyVarMap );
   }

translator/GenPoly/ScrubTyVars.cc

@@ -11 +11 @@
         TyVarMap::const_iterator tyVar = tyVars.find( typeInst->get_name() );
         if ( doAll || tyVar != tyVars.end() ) {
-            switch( tyVar->second ) {
+            switch ( tyVar->second ) {
               case TypeDecl::Any:
               case TypeDecl::Dtype:

translator/GenPoly/Specialize.cc

@@ -61 +61 @@
 needsSpecialization( Type *formalType, Type *actualType, TypeSubstitution *env )
 {
-  if( env ) {
+  if ( env ) {
     using namespace ResolvExpr;
     OpenVarSet openVars, closedVars;
@@ -67 +67 @@
     findOpenVars( formalType, openVars, closedVars, need, have, false );
     findOpenVars( actualType, openVars, closedVars, need, have, true );
-    for( OpenVarSet::const_iterator openVar = openVars.begin(); openVar != openVars.end(); ++openVar ) {
+    for ( OpenVarSet::const_iterator openVar = openVars.begin(); openVar != openVars.end(); ++openVar ) {
       Type *boundType = env->lookup( openVar->first );
-      if( !boundType ) continue;
-      if( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( boundType ) ) {
-        if( closedVars.find( typeInst->get_name() ) == closedVars.end() ) {
+      if ( ! boundType ) continue;
+      if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( boundType ) ) {
+        if ( closedVars.find( typeInst->get_name() ) == closedVars.end() ) {
           return true;
         }
@@ -87 +87 @@
 Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams )
 {
-  if( needsSpecialization( formalType, actual->get_results().front(), env ) ) {
+  if ( needsSpecialization( formalType, actual->get_results().front(), env ) ) {
     PointerType *ptrType;
     FunctionType *funType;
-    if( ( ptrType = dynamic_cast< PointerType* >( formalType ) ) && ( funType = dynamic_cast< FunctionType* >( ptrType->get_base() ) ) ) {
+    if ( ( ptrType = dynamic_cast< PointerType* >( formalType ) ) && ( funType = dynamic_cast< FunctionType* >( ptrType->get_base() ) ) ) {
       FunctionType *newType = funType->clone();
-      if( env ) {
+      if ( env ) {
         TypeSubstitution newEnv( *env );
         // it is important to replace only occurrences of type variables that occur free in the
@@ -103 +103 @@
       UniqueName paramNamer( paramPrefix );
       ApplicationExpr *appExpr = new ApplicationExpr( actual );
-      for( std::list< DeclarationWithType* >::iterator param = thunkFunc->get_functionType()->get_parameters().begin(); param != thunkFunc->get_functionType()->get_parameters().end(); ++param ) {
+      for ( std::list< DeclarationWithType* >::iterator param = thunkFunc->get_functionType()->get_parameters().begin(); param != thunkFunc->get_functionType()->get_parameters().end(); ++param ) {
         (*param)->set_name( paramNamer.newName() );
         appExpr->get_args().push_back( new VariableExpr( *param ) );
       }
       appExpr->set_env( maybeClone( env ) );
-      if( inferParams ) {
+      if ( inferParams ) {
         appExpr->get_inferParams() = *inferParams;
       }
@@ -123 +123 @@
       
       Statement *appStmt;
-      if( funType->get_returnVals().empty() ) {
+      if ( funType->get_returnVals().empty() ) {
         appStmt = new ExprStmt( noLabels, appExpr );
       } else {
@@ -143 +143 @@
 {
   // create thunks for the explicit parameters
-  assert( !appExpr->get_function()->get_results().empty() );
+  assert( ! appExpr->get_function()->get_results().empty() );
   PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
   assert( pointer );
@@ -149 +149 @@
   std::list< DeclarationWithType* >::iterator formal;
   std::list< Expression* >::iterator actual;
-  for( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) {
+  for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) {
     *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->get_inferParams() );
   }
@@ -161 +161 @@
   
   // create thunks for the inferred parameters
-  for( InferredParams::iterator inferParam = appExpr->get_inferParams().begin(); inferParam != appExpr->get_inferParams().end(); ++inferParam ) {
+  for ( InferredParams::iterator inferParam = appExpr->get_inferParams().begin(); inferParam != appExpr->get_inferParams().end(); ++inferParam ) {
     inferParam->second.expr = doSpecialization( inferParam->second.formalType, inferParam->second.expr, &appExpr->get_inferParams() );
   }

translator/InitTweak/Association.h

@@ -70 +70 @@
 
   virtual long int add_single( long int idx, Expression *newExpr) {
-    if( expr == 0 ) //|| *expr == *newExpr )
+    if ( expr == 0 ) //|| *expr == *newExpr )
       expr = newExpr;
     return 0;
@@ -76 +76 @@
 
   virtual long int add_single( std::string str, Expression *newExpr) {
-    if( expr == 0 ) //|| *expr == *newExpr )
+    if ( expr == 0 ) //|| *expr == *newExpr )
       expr = newExpr;
     return 0;
@@ -114 +114 @@
     long int ret;
 
-    if( idx >= (long int)ordering.size() ) throw AssocException("extra (spurious) members");
+    if ( idx >= (long int)ordering.size() ) throw AssocException("extra (spurious) members");
 
     if ( ordering[ idx ] == "")
@@ -127 +127 @@
 
   virtual long int add_single( std::string idx, Expression *expr) {
-    if( idx == "" )
+    if ( idx == "" )
       std::cerr << "Checkpoint 1" << std::endl;
     else {
@@ -143 +143 @@
     if ( table.find( str ) != table.end() ) return;
     ordering.push_back( str );
-    if( str != "" ) {
+    if ( str != "" ) {
       std::pair<long int, Association *> p( ordering.size() - 1, 0 );
       table.insert( std::pair< std::string, std::pair<long int, Association *> >(str, p) );
@@ -151 +151 @@
 
   virtual void set_member( std::string str, Association *assoc ) {
-    if( str == "" )
+    if ( str == "" )
       anonym.push_back( assoc );
     else  if ( table.find( str ) == table.end() )
@@ -162 +162 @@
 
   virtual Association *operator[]( int idx ) {
-    if( ordering[idx] == "" ) {
+    if ( ordering[idx] == "" ) {
       std::cerr << "Error, anonymous members not implemented yet" << std::endl;
       throw 0;
@@ -187 +187 @@
   virtual void display( std::ostream &os ) {
     os << "Point association: " << std::endl;
-    for( map_type::iterator i = table.begin(); i != table.end(); i++ ) {
+    for ( map_type::iterator i = table.begin(); i != table.end(); i++ ) {
       os << "Member [" << i->first << ", index = " << i->second.first << "]";
       if ( i->second.second != 0 )
@@ -244 +244 @@
   diet::diet_tree<int> tree;
   /*
-  for( diet_tree<int>::iterator i = tree.begin(); i != tree.end(); i++ )
+  for ( diet_tree<int>::iterator i = tree.begin(); i != tree.end(); i++ )
     std::cout << "--(" << (*i).first << ", " << (*i).second << ")--" << std::endl;
   diet_tree<int> tree;

translator/InitTweak/BasicInit.cc

@@ -50 +50 @@
     ObjectDecl *odecl = 0;
 
-    if( ( odecl = dynamic_cast<ObjectDecl *>(declStmt->get_decl()) ) != 0 ){
+    if ( ( odecl = dynamic_cast<ObjectDecl *>(declStmt->get_decl()) ) != 0 ){
 
       Initializer *init = odecl->get_init();
@@ -133 +133 @@
 
     ReferenceToType *reftype;
-    if( (reftype = dynamic_cast< StructInstType * >( objdecl->get_type() )) != 0 ){
+    if ( (reftype = dynamic_cast< StructInstType * >( objdecl->get_type() )) != 0 ){
       StructDecl *strDecl = index->lookupStruct( reftype->get_name() );
       if ( strDecl != 0 ) {
@@ -169 +169 @@
 
       if ( li != 0 ) {
-        for( std::list<Initializer *>::iterator i = li->begin_initializers();
+        for ( std::list<Initializer *>::iterator i = li->begin_initializers();
                                                          i != li->end_initializers();
               i++) {
@@ -181 +181 @@
                             std::back_inserter( des ), cast_ptr<Expression, NameExpr > );
 
-            for( std::list<NameExpr *>::iterator j = des.begin(); j != des.end(); j++ ) {
+            for ( std::list<NameExpr *>::iterator j = des.begin(); j != des.end(); j++ ) {
               // check for existence of the element
 
@@ -230 +230 @@
     if ( col->isComposite() ) {
       VariousNames *vc = dynamic_cast< VariousNames * >( col ); 
-      for( VariousNames::key_iterator it = vc->keys_begin(); it != vc->keys_end(); it++ ) {
+      for ( VariousNames::key_iterator it = vc->keys_begin(); it != vc->keys_end(); it++ ) {
         prefix.push_back( *it );
         if ( (*assoc)[ *it ] != 0 )

translator/InitTweak/BasicInit.h

@@ -102 +102 @@
       std::list<Expression *> temp;
 
-      if( ( sinit=dynamic_cast< SingleInit * >(_init) ) != 0 ) {
+      if ( ( sinit=dynamic_cast< SingleInit * >(_init) ) != 0 ) {
         kind = SINGLE;
         temp = sinit->get_designators();
@@ -179 +179 @@
           blown_struct.push_front( me->get_member() );
           prfx = me->get_aggregate();
-        } while( prfx != 0 );
+        } while ( prfx != 0 );
 
         NameExpr *ne;

translator/InitTweak/DeclarationHoister.cc

@@ -24 +24 @@
 
     while ( result !=  kids.end() ) {
-      result = std::find_if(result, kids.end(), cast_ptr< Statement, DeclStmt > );
+      result = std::find_if (result, kids.end(), cast_ptr< Statement, DeclStmt > );
 
       if ( result != kids.end() ) {
@@ -32 +32 @@
     } 
 
-    for( std::list< stmt_it >::reverse_iterator i = decls.rbegin(); i!= decls.rend(); i++ ){
+    for ( std::list< stmt_it >::reverse_iterator i = decls.rbegin(); i!= decls.rend(); i++ ){
       kids.push_front( **i );
       kids.erase( *i );

translator/InitTweak/InitExpander.cc

@@ -18 +18 @@
     index.visit( objectDecl );
 
-    if( objectDecl->get_init() == 0 ) return objectDecl;
+    if ( objectDecl->get_init() == 0 ) return objectDecl;
 
     InitModelBuilder builder( objectDecl );

translator/InitTweak/InitModel.cc

@@ -16 +16 @@
 
     /* this to be replaced by dynamic dispatch */
-    if( dynamic_cast< BasicType * >(objectType) != 0 ) {
-      if( building == 0 ) building = new SingleName;
-    } else if( ReferenceToType *rt = dynamic_cast< ReferenceToType * >(objectType) ) {
+    if ( dynamic_cast< BasicType * >(objectType) != 0 ) {
+      if ( building == 0 ) building = new SingleName;
+    } else if ( ReferenceToType *rt = dynamic_cast< ReferenceToType * >(objectType) ) {
       rt->accept( *this );
-    } else if( ArrayType *at = dynamic_cast< ArrayType * >(objectType) ) {
+    } else if ( ArrayType *at = dynamic_cast< ArrayType * >(objectType) ) {
       at->accept( *this );
     } else // if (tuples)
@@ -28 +28 @@
   }
 
-  InitModelBuilder::~InitModelBuilder() { if( !taken ) { delete building; building = 0; } }
+  InitModelBuilder::~InitModelBuilder() { if ( ! taken ) { delete building; building = 0; } }
 
   void InitModelBuilder::init() {
@@ -37 +37 @@
   // Visitor interface
   void InitModelBuilder::visit( ArrayType *at ) {
-    if( building == 0 ) building = new RangeAssociation(interpretDimension( at->get_dimension() ));
+    if ( building == 0 ) building = new RangeAssociation(interpretDimension( at->get_dimension() ));
     decl = 0;
     return;
@@ -43 +43 @@
 
   void InitModelBuilder::visit( StructInstType *st ) {
-    if( building == 0 ) building = new PointAssociation;
+    if ( building == 0 ) building = new PointAssociation;
     decl = st->get_baseStruct();
     return;
@@ -59 +59 @@
     std::list< Declaration * > mem = aggregateDecl->get_members();
 
-    for( std::list<Declaration *>::iterator i = mem.begin(); i != mem.end(); i++ ) {
+    for ( std::list<Declaration *>::iterator i = mem.begin(); i != mem.end(); i++ ) {
       pa->add_member( (*i)->get_name() );
       InitModelBuilder rec(*i);
@@ -76 +76 @@
     assert (c != 0);
     if ( BasicType *bt = dynamic_cast<BasicType *>( c->get_type() ) ) {
-      if( bt->isInteger() ) {
+      if ( bt->isInteger() ) {
         // need more intelligence here, not necessarily base 10
         value = std::strtol( c->get_value().c_str(), NULL, 10 );
@@ -102 +102 @@
     std::list< Expression *> &des = singleInit->get_designators();
 
-    if( topLevel ) {
+    if ( topLevel ) {
       assert ( des.empty() );
       assert ( dynamic_cast< SingleName * >(model) != 0 );
@@ -113 +113 @@
     }
 
-    if( des.empty() ) {
+    if ( des.empty() ) {
       assert( model != 0 );
       try {
@@ -160 +160 @@
       for ( std::list<Expression *>::iterator i = des2.begin(); i != des2.end(); i++ ) {
         Association * newModel = 0;
-        if( NameExpr *n = dynamic_cast< NameExpr * >( *i ) )
+        if ( NameExpr *n = dynamic_cast< NameExpr * >( *i ) )
           try {
             newModel = (*model)[ n->get_name() ];
@@ -166 +166 @@
             std::cerr << "Didn't find member: " << e.get_what() << std::endl;
           }
-        else // if( RangeExpr *r = dynamic_cast< RangeExpr * >( *i ) )
+        else // if ( RangeExpr *r = dynamic_cast< RangeExpr * >( *i ) )
           std::cerr << "Invalid designator specification" << std::endl;
 
@@ -193 +193 @@
 
     std::list< Initializer * > contents;
-    for( int i = 0; i < pa->size(); i++ )
+    for ( int i = 0; i < pa->size(); i++ )
       if ( (*pa)[i] != 0 ) {
         InitUnspooler rec;

translator/InitTweak/InitModel.h

@@ -92 +92 @@
       public:
         InitUnspooler() : init(0), taken( false ) {}
-        virtual ~InitUnspooler() { if (!taken && (init != 0)) { delete init; init = 0; } }
+        virtual ~InitUnspooler() { if (! taken && (init != 0)) { delete init; init = 0; } }
         Initializer *get_initializer() { return init; }
         Initializer *grab_initializer() { taken = true; return init; }

translator/InitTweak/RemoveInit.cc

@@ -19 +19 @@
 
 void RemoveInit::mutateStatementList( std::list< Statement* > &statements ) {
-  for( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
-    if( !stmtsToAddAfter.empty() ) {
+  for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
+    if ( ! stmtsToAddAfter.empty() ) {
       statements.splice( i, stmtsToAddAfter );
     }
     *i = (*i)->acceptMutator( *this );
   }
-  if( !stmtsToAddAfter.empty() ) {
+  if ( ! stmtsToAddAfter.empty() ) {
     statements.splice( statements.end(), stmtsToAddAfter );
   }

translator/InitTweak/diet_map.h

@@ -34 +34 @@
     diet_tree() : root(0), left(0), right(0) {}
     ~diet_tree() {
-      if( root != 0 ) { delete root; root = 0; }
-      if( left != 0 ) { delete left; left = 0; }
-      if( right != 0 ) { delete right; right = 0; }
+      if ( root != 0 ) { delete root; root = 0; }
+      if ( left != 0 ) { delete left; left = 0; }
+      if ( right != 0 ) { delete right; right = 0; }
     }
 
@@ -45 +45 @@
       else {
         value_type lo = root->get_lo(), hi = root->get_hi();
-        if( _lo < lo ) {
-          if( _hi > hi ) {
+        if ( _lo < lo ) {
+          if ( _hi > hi ) {
             /* can either minimize the work or minimize the number of nodes.
                Let's minimize the work. */
@@ -54 +54 @@
             right->insert( _hi, hi );
             return;
-          } else if( _hi < lo ) {
+          } else if ( _hi < lo ) {
             if ( left == 0 ) left = new diet_tree<T>();
             left->insert( _lo, _hi );
-          } else if( _hi <= hi ) {
+          } else if ( _hi <= hi ) {
             if ( left == 0 ) left = new diet_tree<T>();
             left->insert( _lo, _hi );
@@ -65 +65 @@
           root->set_range(_lo,_hi);
         } else if ( _hi > hi) {
-          if( _lo > hi ) {
+          if ( _lo > hi ) {
             if ( right == 0 ) right = new diet_tree<T>();
             right->insert( _lo, _hi );
-          } else if( _lo < hi ) {
+          } else if ( _lo < hi ) {
             root->set_range(lo, _lo);
             if ( right == 0 ) right = new diet_tree<T>();
@@ -152 +152 @@
       assert(current != 0);
       if ( current->right == 0 )
-        if ( !st.empty() )
+        if ( ! st.empty() )
           { current = st.top(); st.pop(); }
         else
@@ -173 +173 @@
       assert(current != 0);
       diet_tree<T> *next = 0;
-      while( current->left != 0 ) {
+      while ( current->left != 0 ) {
         next = current->left; st.push( current ); current = next;
       }

translator/MakeLibCfa.cc

@@ -48 +48 @@
                 bool lookResult = CodeGen::operatorLookup( funcDecl->get_name(), opInfo );
                 assert( lookResult );
-                assert( !funcDecl->get_statements() );
+                assert( ! funcDecl->get_statements() );
                 UntypedExpr *newExpr = new UntypedExpr( new NameExpr( funcDecl->get_name() ) );
                 UniqueName paramNamer( "_p" );
@@ -59 +59 @@
                 } // if
 
-                switch( opInfo.type ) {
+                switch ( opInfo.type ) {
                   case CodeGen::OT_INDEX:
                   case CodeGen::OT_CALL:
@@ -97 +97 @@
   
                 ObjectDecl *objDecl = origObjDecl->clone();
-                assert( !objDecl->get_init() );
+                assert( ! objDecl->get_init() );
                 std::list< Expression* > noDesignators;
                 objDecl->set_init( new SingleInit( new NameExpr( objDecl->get_name() ), noDesignators ) );

translator/Parser/DeclarationNode.cc

@@ -531 +531 @@
                 TypeData *prevBase = type;
                 TypeData *curBase = type->base;
-                while( curBase != 0 ) {
+                while ( curBase != 0 ) {
                         prevBase = curBase;
                         curBase = curBase->base;
@@ -591 +591 @@
         assert( a );
         TypeData *cur = a;
-        while( cur->base ) {
+        while ( cur->base ) {
                 cur = cur->base;
         }
@@ -660 +660 @@
         DeclarationNode *newnode = new DeclarationNode;
         TypeData *srcType = type;
-        while( srcType->base ) {
+        while ( srcType->base ) {
                 srcType = srcType->base;
         }
@@ -686 +686 @@
                 if ( type ) {
                         TypeData *srcType = type;
-                        while( srcType->base ) {
+                        while ( srcType->base ) {
                                 srcType = srcType->base;
                         }
@@ -763 +763 @@
         std::back_insert_iterator< std::list< Declaration* > > out( outputList );
         const DeclarationNode *cur = firstNode;
-        while( cur ) {
+        while ( cur ) {
                 try {
                         if ( DeclarationNode *extr = cur->extractAggregate() ) {
@@ -790 +790 @@
         std::back_insert_iterator< std::list< DeclarationWithType* > > out( outputList );
         const DeclarationNode *cur = firstNode;
-        while( cur ) {
+        while ( cur ) {
                 try {
 ///       if ( DeclarationNode *extr = cur->extractAggregate() ) {
@@ -827 +827 @@
         std::back_insert_iterator< std::list< Type* > > out( outputList );
         const DeclarationNode *cur = firstNode;
-        while( cur ) {
+        while ( cur ) {
                 try {
                         *out++ = cur->buildType();

translator/Parser/ExpressionNode.cc

@@ -120 +120 @@
                         int i = str.length() - 1;
 
-                        while ( i >= 0 && !isxdigit( c = str.at( i--)) )
+                        while ( i >= 0 && ! isxdigit( c = str.at( i--)) )
                                 sfx += c;
 
@@ -371 +371 @@
                   case OperatorNode::OrAssn:
                         // the rewrite rules for these expressions specify that the first argument has its address taken
-                        assert( !args.empty() );
+                        assert( ! args.empty() );
                         args.front() = new AddressExpr( args.front() );
                         break;
@@ -490 +490 @@
                                 VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
                                 assert( var );
-                                if ( !get_args()->get_link() ) {
+                                if ( ! get_args()->get_link() ) {
                                         return new AttrExpr( var->build(), ( Expression*)0);
                                 } else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {

translator/Parser/InitializerNode.cc

@@ -56 +56 @@
                         os << "designated by: (";
                         ExpressionNode *curdes = designator;
-                        while( curdes != 0) {
+                        while ( curdes != 0) {
                                 curdes->printOneLine(os);
                                 curdes = (ExpressionNode *)(curdes->get_link());

translator/Parser/ParseNode.cc

@@ -50 +50 @@
     ParseNode *current = this;
 
-    while( current->get_link() != 0 )
+    while ( current->get_link() != 0 )
         current = current->get_link();
 

translator/Parser/ParseNode.h

@@ -493 +493 @@
                 cur = dynamic_cast< NodeType *>( cur->get_link() );
         } // while
-        if ( !errors.isEmpty() ) {
+        if ( ! errors.isEmpty() ) {
                 throw errors;
         } // if

translator/Parser/StatementNode.cc

@@ -171 +171 @@
 void StatementNode::print( std::ostream &os, int indent ) const {
         if ( labels != 0 )
-                if (!labels->empty()) {
+                if (! labels->empty()) {
                         std::list<std::string>::const_iterator i;
 
                         os << '\r' << string( indent, ' ');
-                        for( i = labels->begin(); i != labels->end(); i++ )
+                        for ( i = labels->begin(); i != labels->end(); i++ )
                                 os << *i << ":";
                         os << endl;
                 }
 
-        switch( type ) {
+        switch ( type ) {
           case Decl:
                 decl->print( os, indent );
@@ -232 +232 @@
         buildList<Statement, StatementNode>( get_block(), branches );
 
-        switch( type ) {
+        switch ( type ) {
           case Decl:
                 return new DeclStmt( labs, maybeBuild< Declaration >( decl ) );
@@ -251 +251 @@
                         thenb = branches.front();
                         branches.pop_front();
-                        if ( !branches.empty() ) {
+                        if ( ! branches.empty() ) {
                                 elseb = branches.front();
                                 branches.pop_front();

translator/Parser/TypeData.cc

@@ -405 +405 @@
         switch ( kind ) {
           case Aggregate:
-                if ( !toplevel && aggregate->members ) {
+                if ( ! toplevel && aggregate->members ) {
                         ret = clone();
                         ret->qualifiers.clear();
@@ -411 +411 @@
                 break;
           case Enum:
-                if ( !toplevel && enumeration->constants ) {
+                if ( ! toplevel && enumeration->constants ) {
                         ret = clone();
                         ret->qualifiers.clear();
@@ -556 +556 @@
 
         for ( std::list< DeclarationNode::BasicType >::const_iterator i = basic->typeSpec.begin(); i != basic->typeSpec.end(); ++i ) {
-                if ( !init ) {
+                if ( ! init ) {
                         init = true;
                         if ( *i == DeclarationNode::Void ) {
-                                if ( basic->typeSpec.size() != 1 || !basic->modifiers.empty() ) {
+                                if ( basic->typeSpec.size() != 1 || ! basic->modifiers.empty() ) {
                                         throw SemanticError( "invalid type specifier \"void\" in type: ", this );
                                 } else {
@@ -635 +635 @@
                 switch ( *i ) {
                   case DeclarationNode::Long:
-                        if ( !init ) {
+                        if ( ! init ) {
                                 init = true;
                                 ret = BasicType::LongSignedInt;
@@ -667 +667 @@
                         break;
                   case DeclarationNode::Short:
-                        if ( !init ) {
+                        if ( ! init ) {
                                 init = true;
                                 ret = BasicType::ShortSignedInt;
@@ -684 +684 @@
                         break;
                   case DeclarationNode::Signed:
-                        if ( !init ) {
+                        if ( ! init ) {
                                 init = true;
                                 ret = BasicType::SignedInt;
@@ -709 +709 @@
                         break;
                   case DeclarationNode::Unsigned:
-                        if ( !init ) {
+                        if ( ! init ) {
                                 init = true;
                                 ret = BasicType::UnsignedInt;
@@ -744 +744 @@
 
         BasicType *bt;
-        if ( !init ) {
+        if ( ! init ) {
                 bt = new BasicType( buildQualifiers(), BasicType::SignedInt );
         } else {
@@ -781 +781 @@
         assert( kind == Function );
         bool hasEllipsis = function->params ? function->params->get_hasEllipsis() : true;
-        if ( !function->params ) hasEllipsis = !function->newStyle;
+        if ( ! function->params ) hasEllipsis = ! function->newStyle;
         FunctionType *ft = new FunctionType( buildQualifiers(), hasEllipsis );
         buildList( function->params, ft->get_parameters() );

translator/Parser/TypedefTable.cc

@@ -64 +64 @@
                 } else {
                         list<Entry>::iterator listPos = (*curPos ).second.begin();
-                        while( listPos != (*curPos ).second.end() && listPos->scope > scope ) {
+                        while ( listPos != (*curPos ).second.end() && listPos->scope > scope ) {
                                 listPos++;
                         }
@@ -123 +123 @@
         for ( tableType::iterator i = table.begin(); i != table.end(); ) {
                 list<Entry> &declList = (*i ).second;
-                while (!declList.empty() && declList.front().scope == currentScope ) {
+                while (! declList.empty() && declList.front().scope == currentScope ) {
                         declList.pop_front();
                 }

translator/ResolvExpr/AdjustExprType.cc

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// AdjustExprType.cc -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Sat May 16 23:41:42 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 23:54:02 2015
+// Update Count     : 3
+// 
+
 #include "typeops.h"
 #include "SynTree/Type.h"
@@ -5 +20 @@
 
 namespace ResolvExpr {
-    class AdjustExprType : public Mutator {
-        typedef Mutator Parent;
-      public:
-        AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer );
-      private:
-        virtual Type* mutate(VoidType *voidType);
-        virtual Type* mutate(BasicType *basicType);
-        virtual Type* mutate(PointerType *pointerType);
-        virtual Type* mutate(ArrayType *arrayType);
-        virtual Type* mutate(FunctionType *functionType);
-        virtual Type* mutate(StructInstType *aggregateUseType);
-        virtual Type* mutate(UnionInstType *aggregateUseType);
-        virtual Type* mutate(EnumInstType *aggregateUseType);
-        virtual Type* mutate(ContextInstType *aggregateUseType);
-        virtual Type* mutate(TypeInstType *aggregateUseType);
-        virtual Type* mutate(TupleType *tupleType);
-  
-        const TypeEnvironment &env;
-        const SymTab::Indexer &indexer;
-    };
+        class AdjustExprType : public Mutator {
+                typedef Mutator Parent;
+          public:
+                AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer );
+          private:
+                virtual Type* mutate( VoidType *voidType );
+                virtual Type* mutate( BasicType *basicType );
+                virtual Type* mutate( PointerType *pointerType );
+                virtual Type* mutate( ArrayType *arrayType );
+                virtual Type* mutate( FunctionType *functionType );
+                virtual Type* mutate( StructInstType *aggregateUseType );
+                virtual Type* mutate( UnionInstType *aggregateUseType );
+                virtual Type* mutate( EnumInstType *aggregateUseType );
+                virtual Type* mutate( ContextInstType *aggregateUseType );
+                virtual Type* mutate( TypeInstType *aggregateUseType );
+                virtual Type* mutate( TupleType *tupleType );
 
-    void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
-        AdjustExprType adjuster( env, indexer );
-        Type *newType = type->acceptMutator( adjuster );
-        type = newType;
-    }
+                const TypeEnvironment &env;
+                const SymTab::Indexer &indexer;
+        };
 
-    AdjustExprType::AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer )
-        : env( env ), indexer( indexer ) {
-    }
+        void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
+                AdjustExprType adjuster( env, indexer );
+                Type *newType = type->acceptMutator( adjuster );
+                type = newType;
+        }
 
-    Type *AdjustExprType::mutate(VoidType *voidType) {
-        return voidType;
-    }
+        AdjustExprType::AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer )
+                : env( env ), indexer( indexer ) {
+        }
 
-    Type *AdjustExprType::mutate(BasicType *basicType) {
-        return basicType;
-    }
+        Type *AdjustExprType::mutate( VoidType *voidType ) {
+                return voidType;
+        }
 
-    Type *AdjustExprType::mutate(PointerType *pointerType) {
-        return pointerType;
-    }
+        Type *AdjustExprType::mutate( BasicType *basicType ) {
+                return basicType;
+        }
 
-    Type *AdjustExprType::mutate(ArrayType *arrayType) {
-        PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone() );
-        delete arrayType;
-        return pointerType;
-    }
+        Type *AdjustExprType::mutate( PointerType *pointerType ) {
+                return pointerType;
+        }
 
-    Type *AdjustExprType::mutate(FunctionType *functionType) {
-        PointerType *pointerType = new PointerType( Type::Qualifiers(), functionType );
-        return pointerType;
-    }
+        Type *AdjustExprType::mutate( ArrayType *arrayType ) {
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone() );
+                delete arrayType;
+                return pointerType;
+        }
 
-    Type *AdjustExprType::mutate(StructInstType *aggregateUseType) {
-        return aggregateUseType;
-    }
+        Type *AdjustExprType::mutate( FunctionType *functionType ) {
+                PointerType *pointerType = new PointerType( Type::Qualifiers(), functionType );
+                return pointerType;
+        }
 
-    Type *AdjustExprType::mutate(UnionInstType *aggregateUseType) {
-        return aggregateUseType;
-    }
+        Type *AdjustExprType::mutate( StructInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
 
-    Type *AdjustExprType::mutate(EnumInstType *aggregateUseType) {
-        return aggregateUseType;
-    }
+        Type *AdjustExprType::mutate( UnionInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
 
-    Type *AdjustExprType::mutate(ContextInstType *aggregateUseType) {
-        return aggregateUseType;
-    }
+        Type *AdjustExprType::mutate( EnumInstType *aggregateUseType ) {
+                return aggregateUseType;
+        }
 
-    Type *AdjustExprType::mutate(TypeInstType *typeInst) {
-        EqvClass eqvClass;
-        if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
-            if ( eqvClass.kind == TypeDecl::Ftype ) {
-                PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
-                return pointerType;
-            }
-        } else if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
-            if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
-                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
-                    PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
-                    return pointerType;
-                }
-            }
+        Type *AdjustExprType::mutate( ContextInstType *aggregateUseType ) {
+                return aggregateUseType;
         }
-        return typeInst;
-    }
 
-    Type *AdjustExprType::mutate(TupleType *tupleType) {
-        return tupleType;
-    }
+        Type *AdjustExprType::mutate( TypeInstType *typeInst ) {
+                EqvClass eqvClass;
+                if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
+                        if ( eqvClass.kind == TypeDecl::Ftype ) {
+                                PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
+                                return pointerType;
+                        }
+                } else if ( NamedTypeDecl *ntDecl = indexer.lookupType( typeInst->get_name() ) ) {
+                        if ( TypeDecl *tyDecl = dynamic_cast< TypeDecl* >( ntDecl ) ) {
+                                if ( tyDecl->get_kind() == TypeDecl::Ftype ) {
+                                        PointerType *pointerType = new PointerType( Type::Qualifiers(), typeInst );
+                                        return pointerType;
+                                } // if
+                        } // if
+                } // if
+                return typeInst;
+        }
+
+        Type *AdjustExprType::mutate( TupleType *tupleType ) {
+                return tupleType;
+        }
 } // namespace ResolvExpr
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/ResolvExpr/Alternative.cc

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Alternative.cc -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Sat May 16 23:44:23 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 23:54:23 2015
+// Update Count     : 2
+// 
+
 #include "Alternative.h"
 #include "SynTree/Type.h"
@@ -5 +20 @@
 
 namespace ResolvExpr {
-    Alternative::Alternative() : expr( 0 ) {}
+        Alternative::Alternative() : expr( 0 ) {}
 
-    Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost )
-        : cost( cost ), cvtCost( Cost::zero ), expr( expr ), env( env ) {}
+        Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost )
+                : cost( cost ), cvtCost( Cost::zero ), expr( expr ), env( env ) {}
 
-    Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost, const Cost &cvtCost )
-        : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ) {}
+        Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost, const Cost &cvtCost )
+                : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ) {}
 
-    Alternative::Alternative( const Alternative &other ) {
-        initialize( other, *this );
-    }
+        Alternative::Alternative( const Alternative &other ) {
+                initialize( other, *this );
+        }
 
-    Alternative &Alternative::operator=( const Alternative &other ) {
-        if ( &other == this ) return *this;
-        initialize( other, *this );
-        return *this;
-    }
+        Alternative &Alternative::operator=( const Alternative &other ) {
+                if ( &other == this ) return *this;
+                initialize( other, *this );
+                return *this;
+        }
 
-    void Alternative::initialize( const Alternative &src, Alternative &dest ) {
-        dest.cost = src.cost;
-        dest.cvtCost = src.cvtCost;
-        dest.expr = maybeClone( src.expr );
-        dest.env = src.env;
-    }
+        void Alternative::initialize( const Alternative &src, Alternative &dest ) {
+                dest.cost = src.cost;
+                dest.cvtCost = src.cvtCost;
+                dest.expr = maybeClone( src.expr );
+                dest.env = src.env;
+        }
 
-    Alternative::~Alternative() {
-        delete expr;
-    }
+        Alternative::~Alternative() {
+                delete expr;
+        }
 
-    void Alternative::print( std::ostream &os, int indent ) const {
-        os << std::string( indent, ' ' ) << "Cost " << cost << ": ";
-        if ( expr ) {
-            expr->print( os, indent );
-            os << "(types:" << std::endl;
-            printAll( expr->get_results(), os, indent + 4 );
-            os << ")" << std::endl;
-        } else {
-            os << "Null expression!" << std::endl;
+        void Alternative::print( std::ostream &os, int indent ) const {
+                os << std::string( indent, ' ' ) << "Cost " << cost << ": ";
+                if ( expr ) {
+                        expr->print( os, indent );
+                        os << "(types:" << std::endl;
+                        printAll( expr->get_results(), os, indent + 4 );
+                        os << ")" << std::endl;
+                } else {
+                        os << "Null expression!" << std::endl;
+                } // if
+                os << std::string( indent, ' ' ) << "Environment: ";
+                env.print( os, indent+2 );
+                os << std::endl;
         }
-        os << std::string( indent, ' ' ) << "Environment: ";
-        env.print( os, indent+2 );
-        os << std::endl;
-    }
 } // namespace ResolvExpr
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/ResolvExpr/Alternative.h

@@ -1 @@
-#ifndef RESOLVEXPR_ALTERNATIVE_H
-#define RESOLVEXPR_ALTERNATIVE_H
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Alternative.h -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Sat May 16 23:45:43 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 23:54:39 2015
+// Update Count     : 2
+// 
+
+#ifndef ALTERNATIVE_H
+#define ALTERNATIVE_H
 
 #include <list>
@@ -8 +23 @@
 
 namespace ResolvExpr {
-    struct Alternative;
-    typedef std::list< Alternative > AltList;
+        struct Alternative;
+        typedef std::list< Alternative > AltList;
 
-    struct Alternative {
-        Alternative();
-        Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost );
-        Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost, const Cost &cvtCost );
-        Alternative( const Alternative &other );
-        Alternative &operator=( const Alternative &other );
-        ~Alternative();
+        struct Alternative {
+                Alternative();
+                Alternative( Expression *expr, const TypeEnvironment &env, const Cost &cost );
+                Alternative( Expression *expr, const TypeEnvironment &env, const Cost &cost, const Cost &cvtCost );
+                Alternative( const Alternative &other );
+                Alternative &operator=( const Alternative &other );
+                ~Alternative();
   
-        void initialize( const Alternative &src, Alternative &dest );
+                void initialize( const Alternative &src, Alternative &dest );
   
-        void print( std::ostream &os, int indent = 0 ) const;
+                void print( std::ostream &os, int indent = 0 ) const;
   
-        Cost cost;
-        Cost cvtCost;
-        Expression *expr;
-        TypeEnvironment env;
-    };
+                Cost cost;
+                Cost cvtCost;
+                Expression *expr;
+                TypeEnvironment env;
+        };
 } // namespace ResolvExpr
 
-#endif // RESOLVEXPR_ALTERNATIVE_H
+#endif // ALTERNATIVE_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/ResolvExpr/AlternativeFinder.cc

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// AlternativeFinder.cc -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Sat May 16 23:52:08 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 23:55:30 2015
+// Update Count     : 3
+//
+
 #include <list>
 #include <iterator>
@@ -30 +45 @@
 
 namespace ResolvExpr {
-    Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) {
-        CastExpr *castToVoid = new CastExpr( expr );
-
-        AlternativeFinder finder( indexer, env );
-        finder.findWithAdjustment( castToVoid );
-
-        // it's a property of the language that a cast expression has either 1 or 0 interpretations; if it has 0
-        // interpretations, an exception has already been thrown.
-        assert( finder.get_alternatives().size() == 1 );
-        CastExpr *newExpr = dynamic_cast< CastExpr* >( finder.get_alternatives().front().expr );
-        assert( newExpr );
-        env = finder.get_alternatives().front().env;
-        return newExpr->get_arg()->clone();
-    }
-
-    namespace {
-        void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
-            for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
-                i->print( os, indent );
-                os << std::endl;
-            }
-        }
-
-        void makeExprList( const AltList &in, std::list< Expression* > &out ) {
-            for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
-                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;
-        }
-
-        struct PruneStruct {
-            bool isAmbiguous;
-            AltList::iterator candidate;
-            PruneStruct() {}
-            PruneStruct( AltList::iterator candidate ): isAmbiguous( false ), candidate( candidate ) {}
-        };
+        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) {
+                CastExpr *castToVoid = new CastExpr( expr );
+
+                AlternativeFinder finder( indexer, env );
+                finder.findWithAdjustment( castToVoid );
+
+                // it's a property of the language that a cast expression has either 1 or 0 interpretations; if it has 0
+                // interpretations, an exception has already been thrown.
+                assert( finder.get_alternatives().size() == 1 );
+                CastExpr *newExpr = dynamic_cast< CastExpr* >( finder.get_alternatives().front().expr );
+                assert( newExpr );
+                env = finder.get_alternatives().front().env;
+                return newExpr->get_arg()->clone();
+        }
+
+        namespace {
+                void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
+                        for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
+                                i->print( os, indent );
+                                os << std::endl;
+                        }
+                }
+
+                void makeExprList( const AltList &in, std::list< Expression* > &out ) {
+                        for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
+                                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;
+                }
+
+                struct PruneStruct {
+                        bool isAmbiguous;
+                        AltList::iterator candidate;
+                        PruneStruct() {}
+                        PruneStruct( AltList::iterator candidate ): isAmbiguous( false ), candidate( candidate ) {}
+                };
+
+                template< typename InputIterator, typename OutputIterator >
+                void pruneAlternatives( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer ) {
+                        // select the alternatives that have the minimum conversion cost for a particular set of result types
+                        std::map< std::string, PruneStruct > selected;
+                        for ( AltList::iterator candidate = begin; candidate != end; ++candidate ) {
+                                PruneStruct current( candidate );
+                                std::string mangleName;
+                                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 );
+                                        delete newType;
+                                }
+                                std::map< std::string, PruneStruct >::iterator mapPlace = selected.find( mangleName );
+                                if ( mapPlace != selected.end() ) {
+                                        if ( candidate->cost < mapPlace->second.candidate->cost ) {
+                                                PRINT(
+                                                        std::cout << "cost " << candidate->cost << " beats " << mapPlace->second.candidate->cost << std::endl;
+                                                        )
+                                                        selected[ mangleName ] = current;
+                                        } else if ( candidate->cost == mapPlace->second.candidate->cost ) {
+                                                PRINT(
+                                                        std::cout << "marking ambiguous" << std::endl;
+                                                        )
+                                                        mapPlace->second.isAmbiguous = true;
+                                        }
+                                } else {
+                                        selected[ mangleName ] = current;
+                                }
+                        }
+
+                        PRINT(
+                                std::cout << "there are " << selected.size() << " alternatives before elimination" << std::endl;
+                                )
+
+                                // accept the alternatives that were unambiguous
+                                for ( std::map< std::string, PruneStruct >::iterator target = selected.begin(); target != selected.end(); ++target ) {
+                                        if ( ! target->second.isAmbiguous ) {
+                                                Alternative &alt = *target->second.candidate;
+                                                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 ) {
+                        for ( std::list< Type* >::iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
+                                (*i)->accept( global_renamer );
+                        }
+                }
+        }
 
         template< typename InputIterator, typename OutputIterator >
-        void pruneAlternatives( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer ) {
-            // select the alternatives that have the minimum conversion cost for a particular set of result types
-            std::map< std::string, PruneStruct > selected;
-            for ( AltList::iterator candidate = begin; candidate != end; ++candidate ) {
-                PruneStruct current( candidate );
-                std::string mangleName;
-                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 );
-                    delete newType;
-                }
-                std::map< std::string, PruneStruct >::iterator mapPlace = selected.find( mangleName );
-                if ( mapPlace != selected.end() ) {
-                    if ( candidate->cost < mapPlace->second.candidate->cost ) {
+        void AlternativeFinder::findSubExprs( InputIterator begin, InputIterator end, OutputIterator out ) {
+                while ( begin != end ) {
+                        AlternativeFinder finder( indexer, env );
+                        finder.findWithAdjustment( *begin );
+                        // XXX  either this
+                        //Designators::fixDesignations( finder, (*begin++)->get_argName() );
+                        // or XXX this
+                        begin++;
                         PRINT(
-                            std::cout << "cost " << candidate->cost << " beats " << mapPlace->second.candidate->cost << std::endl;
-                            )
-                        selected[ mangleName ] = current;
-                    } else if ( candidate->cost == mapPlace->second.candidate->cost ) {
+                                std::cout << "findSubExprs" << std::endl;
+                                printAlts( finder.alternatives, std::cout );
+                                )
+                                *out++ = finder;
+                }
+        }
+
+        AlternativeFinder::AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env )
+                : indexer( indexer ), env( env ) {
+        }
+
+        void AlternativeFinder::find( Expression *expr, bool adjust ) {
+                expr->accept( *this );
+                if ( alternatives.empty() ) {
+                        throw SemanticError( "No reasonable alternatives for expression ", expr );
+                }
+                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
+                        if ( adjust ) {
+                                adjustExprTypeList( i->expr->get_results().begin(), i->expr->get_results().end(), i->env, indexer );
+                        }
+                }
+                PRINT(
+                        std::cout << "alternatives before prune:" << std::endl;
+                        printAlts( alternatives, std::cout );
+                        )
+                        AltList::iterator oldBegin = alternatives.begin();
+                pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
+                if ( alternatives.begin() == oldBegin ) {
+                        std::ostrstream stream;
+                        stream << "Can't choose between alternatives for expression ";
+                        expr->print( stream );
+                        stream << "Alternatives are:";
+                        AltList winners;
+                        findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
+                        printAlts( winners, stream, 8 );
+                        throw SemanticError( std::string( stream.str(), stream.pcount() ) );
+                }
+                alternatives.erase( oldBegin, alternatives.end() );
+                PRINT(
+                        std::cout << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
+                        )
+                        }
+
+        void AlternativeFinder::findWithAdjustment( Expression *expr ) {
+                find( expr, true );
+        }
+
+        template< typename StructOrUnionType >
+        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name ) {
+                std::list< Declaration* > members;
+                aggInst->lookup( name, members );
+                for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
+                        if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) {
+                                alternatives.push_back( Alternative( new MemberExpr( dwt->clone(), expr->clone() ), env, newCost ) );
+                                renameTypes( alternatives.back().expr );
+                        } else {
+                                assert( false );
+                        }
+                }
+        }
+
+        void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) {
+                alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
+        }
+
+        Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
+                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 );
+                std::list< DeclarationWithType* >& formals = function->get_parameters();
+                std::list< DeclarationWithType* >::iterator formal = formals.begin();
+                std::list< Expression* >& actuals = appExpr->get_args();
+                for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
                         PRINT(
-                            std::cout << "marking ambiguous" << std::endl;
-                            )
-                        mapPlace->second.isAmbiguous = true;
-                    }
-                } else {
-                    selected[ mangleName ] = current;
-                }
-            }
-
-            PRINT(
-                std::cout << "there are " << selected.size() << " alternatives before elimination" << std::endl;
-                )
-
-            // accept the alternatives that were unambiguous
-            for ( std::map< std::string, PruneStruct >::iterator target = selected.begin(); target != selected.end(); ++target ) {
-                if ( !target->second.isAmbiguous ) {
-                    Alternative &alt = *target->second.candidate;
-                    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 ) {
-            for ( std::list< Type* >::iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
-                (*i)->accept( global_renamer );
-            }
-        }
-    }
-
-    template< typename InputIterator, typename OutputIterator >
-    void AlternativeFinder::findSubExprs( InputIterator begin, InputIterator end, OutputIterator out ) {
-        while ( begin != end ) {
-            AlternativeFinder finder( indexer, env );
-            finder.findWithAdjustment( *begin );
-            // XXX  either this
-            //Designators::fixDesignations( finder, (*begin++)->get_argName() );
-            // or XXX this
-            begin++;
-            PRINT(
-                std::cout << "findSubExprs" << std::endl;
-                printAlts( finder.alternatives, std::cout );
-                )
-            *out++ = finder;
-        }
-    }
-
-    AlternativeFinder::AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env )
-        : indexer( indexer ), env( env ) {
-    }
-
-    void AlternativeFinder::find( Expression *expr, bool adjust ) {
-        expr->accept( *this );
-        if ( alternatives.empty() ) {
-            throw SemanticError( "No reasonable alternatives for expression ", expr );
-        }
-        for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
-            if ( adjust ) {
-                adjustExprTypeList( i->expr->get_results().begin(), i->expr->get_results().end(), i->env, indexer );
-            }
-        }
-        PRINT(
-            std::cout << "alternatives before prune:" << std::endl;
-            printAlts( alternatives, std::cout );
-            )
-        AltList::iterator oldBegin = alternatives.begin();
-        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
-        if ( alternatives.begin() == oldBegin ) {
-            std::ostrstream stream;
-            stream << "Can't choose between alternatives for expression ";
-            expr->print( stream );
-            stream << "Alternatives are:";
-            AltList winners;
-            findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
-            printAlts( winners, stream, 8 );
-            throw SemanticError( std::string( stream.str(), stream.pcount() ) );
-        }
-        alternatives.erase( oldBegin, alternatives.end() );
-        PRINT(
-            std::cout << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
-            )
-    }
-
-    void AlternativeFinder::findWithAdjustment( Expression *expr ) {
-        find( expr, true );
-    }
-
-    template< typename StructOrUnionType >
-    void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name ) {
-        std::list< Declaration* > members;
-        aggInst->lookup( name, members );
-        for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
-            if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) {
-                alternatives.push_back( Alternative( new MemberExpr( dwt->clone(), expr->clone() ), env, newCost ) );
-                renameTypes( alternatives.back().expr );
-            } else {
-                assert( false );
-            }
-        }
-    }
-
-    void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) {
-        alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
-    }
-
-    Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
-        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 );
-        std::list< DeclarationWithType* >& formals = function->get_parameters();
-        std::list< DeclarationWithType* >::iterator formal = formals.begin();
-        std::list< Expression* >& actuals = appExpr->get_args();
-        for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
-            PRINT(
-                std::cout << "actual expression:" << std::endl;
-                (*actualExpr)->print( std::cout, 8 );
-                std::cout << "--- results are" << std::endl;
-                printAll( (*actualExpr)->get_results(), std::cout, 8 );
-                )
-            std::list< DeclarationWithType* >::iterator startFormal = formal;
-            Cost actualCost;
-            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 {
+                                std::cout << "actual expression:" << std::endl;
+                                (*actualExpr)->print( std::cout, 8 );
+                                std::cout << "--- results are" << std::endl;
+                                printAll( (*actualExpr)->get_results(), std::cout, 8 );
+                                )
+                                std::list< DeclarationWithType* >::iterator startFormal = formal;
+                        Cost actualCost;
+                        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;
+                                        }
+                                }
+                                PRINT(
+                                        std::cout << std::endl << "converting ";
+                                        (*actual)->print( std::cout, 8 );
+                                        std::cout << std::endl << " to ";
+                                        (*formal)->get_type()->print( std::cout, 8 );
+                                        )
+                                        Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
+                                PRINT(
+                                        std::cout << std::endl << "cost is" << newCost << std::endl;
+                                        )
+
+                                        if ( newCost == Cost::infinity ) {
+                                                return newCost;
+                                        }
+                                convCost += newCost;
+                                actualCost += newCost;
+
+                                convCost += Cost( 0, polyCost( (*formal)->get_type(), alt.env, indexer ) + polyCost( *actual, alt.env, indexer ), 0 );
+
+                                formal++;
+                        }
+                        if ( actualCost != Cost( 0, 0, 0 ) ) {
+                                std::list< DeclarationWithType* >::iterator startFormalPlusOne = startFormal;
+                                startFormalPlusOne++;
+                                if ( formal == startFormalPlusOne ) {
+                                        // not a tuple type
+                                        Type *newType = (*startFormal)->get_type()->clone();
+                                        alt.env.apply( newType );
+                                        *actualExpr = new CastExpr( *actualExpr, newType );
+                                } else {
+                                        TupleType *newType = new TupleType( Type::Qualifiers() );
+                                        for ( std::list< DeclarationWithType* >::iterator i = startFormal; i != formal; ++i ) {
+                                                newType->get_types().push_back( (*i)->get_type()->clone() );
+                                        }
+                                        alt.env.apply( newType );
+                                        *actualExpr = new CastExpr( *actualExpr, newType );
+                                }
+                        }
+
+                }
+                if ( formal != formals.end() ) {
                         return Cost::infinity;
-                    }
-                }
+                }
+
+                for ( InferredParams::const_iterator assert = appExpr->get_inferParams().begin(); assert != appExpr->get_inferParams().end(); ++assert ) {
+                        PRINT(
+                                std::cout << std::endl << "converting ";
+                                assert->second.actualType->print( std::cout, 8 );
+                                std::cout << std::endl << " to ";
+                                assert->second.formalType->print( std::cout, 8 );
+                                )
+                                Cost newCost = conversionCost( assert->second.actualType, assert->second.formalType, indexer, alt.env );
+                        PRINT(
+                                std::cout << std::endl << "cost of conversion is " << newCost << std::endl;
+                                )
+                                if ( newCost == Cost::infinity ) {
+                                        return newCost;
+                                }
+                        convCost += newCost;
+
+                        convCost += Cost( 0, polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ), 0 );
+                }
+
+                return convCost;
+        }
+
+        void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
+                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 ) {
+                                needAssertions[ *assert ] = true;
+                        }
+///     needAssertions.insert( needAssertions.end(), (*tyvar)->get_assertions().begin(), (*tyvar)->get_assertions().end() );
+                }
+        }
+
+        bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave ) {
+                std::list< TypeEnvironment > toBeDone;
+                simpleCombineEnvironments( actuals.begin(), actuals.end(), resultEnv );
+                // make sure we don't widen any existing bindings
+                for ( TypeEnvironment::iterator i = resultEnv.begin(); i != resultEnv.end(); ++i ) {
+                        i->allowWidening = false;
+                }
+                resultEnv.extractOpenVars( openVars );
+
+                /*
+                  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;
+        }
+
+        static const int recursionLimit = 10;
+
+        void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
+                for ( AssertionSet::iterator i = assertSet.begin(); i != assertSet.end(); ++i ) {
+                        if ( i->second == true ) {
+                                i->first->accept( indexer );
+                        }
+                }
+        }
+
+        template< typename ForwardIterator, typename OutputIterator >
+        void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, int level, const SymTab::Indexer &indexer, OutputIterator out ) {
+                if ( begin == end ) {
+                        if ( newNeed.empty() ) {
+                                *out++ = newAlt;
+                                return;
+                        } else if ( level >= recursionLimit ) {
+                                throw SemanticError( "Too many recursive assertions" );
+                        } else {
+                                AssertionSet newerNeed;
+                                PRINT(
+                                        std::cerr << "recursing with new set:" << std::endl;
+                                        printAssertionSet( newNeed, std::cerr, 8 );
+                                        )
+                                        inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out );
+                                return;
+                        }
+                }
+
+                ForwardIterator cur = begin++;
+                if ( ! cur->second ) {
+                        inferRecursive( begin, end, newAlt, openVars, decls, newNeed, level, indexer, out );
+                }
+                DeclarationWithType *curDecl = cur->first;
                 PRINT(
-                    std::cout << std::endl << "converting ";
-                    (*actual)->print( std::cout, 8 );
-                    std::cout << std::endl << " to ";
-                    (*formal)->get_type()->print( std::cout, 8 );
-                    )
-                Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
-                PRINT(
-                    std::cout << std::endl << "cost is" << newCost << std::endl;
-                    )
-
-                if ( newCost == Cost::infinity ) {
-                    return newCost;
-                }
-                convCost += newCost;
-                actualCost += newCost;
-
-                convCost += Cost( 0, polyCost( (*formal)->get_type(), alt.env, indexer ) + polyCost( *actual, alt.env, indexer ), 0 );
-
-                formal++;
-            }
-            if ( actualCost != Cost( 0, 0, 0 ) ) {
-                std::list< DeclarationWithType* >::iterator startFormalPlusOne = startFormal;
-                startFormalPlusOne++;
-                if ( formal == startFormalPlusOne ) {
-                    // not a tuple type
-                    Type *newType = (*startFormal)->get_type()->clone();
-                    alt.env.apply( newType );
-                    *actualExpr = new CastExpr( *actualExpr, newType );
-                } else {
-                    TupleType *newType = new TupleType( Type::Qualifiers() );
-                    for ( std::list< DeclarationWithType* >::iterator i = startFormal; i != formal; ++i ) {
-                        newType->get_types().push_back( (*i)->get_type()->clone() );
-                    }
-                    alt.env.apply( newType );
-                    *actualExpr = new CastExpr( *actualExpr, newType );
-                }
-            }
-
-        }
-        if ( formal != formals.end() ) {
-            return Cost::infinity;
-        }
-
-        for ( InferredParams::const_iterator assert = appExpr->get_inferParams().begin(); assert != appExpr->get_inferParams().end(); ++assert ) {
-            PRINT(
-                std::cout << std::endl << "converting ";
-                assert->second.actualType->print( std::cout, 8 );
-                std::cout << std::endl << " to ";
-                assert->second.formalType->print( std::cout, 8 );
-                )
-            Cost newCost = conversionCost( assert->second.actualType, assert->second.formalType, indexer, alt.env );
-            PRINT(
-                std::cout << std::endl << "cost of conversion is " << newCost << std::endl;
-                )
-            if ( newCost == Cost::infinity ) {
-                return newCost;
-            }
-            convCost += newCost;
-
-            convCost += Cost( 0, polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ), 0 );
-        }
-
-        return convCost;
-    }
-
-    void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
-        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 ) {
-                needAssertions[ *assert ] = true;
-            }
-///     needAssertions.insert( needAssertions.end(), (*tyvar)->get_assertions().begin(), (*tyvar)->get_assertions().end() );
-        }
-    }
-
-    bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave ) {
-        std::list< TypeEnvironment > toBeDone;
-        simpleCombineEnvironments( actuals.begin(), actuals.end(), resultEnv );
-        // make sure we don't widen any existing bindings
-        for ( TypeEnvironment::iterator i = resultEnv.begin(); i != resultEnv.end(); ++i ) {
-            i->allowWidening  = false;
-        }
-        resultEnv.extractOpenVars( openVars );
-
-        /*
-          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;
-    }
-
-    static const int recursionLimit = 10;
-
-    void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
-        for ( AssertionSet::iterator i = assertSet.begin(); i != assertSet.end(); ++i ) {
-            if ( i->second == true ) {
-                i->first->accept( indexer );
-            }
-        }
-    }
-
-    template< typename ForwardIterator, typename OutputIterator >
-    void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, int level, const SymTab::Indexer &indexer, OutputIterator out ) {
-        if ( begin == end ) {
-            if ( newNeed.empty() ) {
-                *out++ = newAlt;
-                return;
-            } else if ( level >= recursionLimit ) {
-                throw SemanticError( "Too many recursive assertions" );
-            } else {
-                AssertionSet newerNeed;
-                PRINT(
-                    std::cerr << "recursing with new set:" << std::endl;
-                    printAssertionSet( newNeed, std::cerr, 8 );
-                    )
-                inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out );
-                return;
-            }
-        }
-
-        ForwardIterator cur = begin++;
-        if ( !cur->second ) {
-            inferRecursive( begin, end, newAlt, openVars, decls, newNeed, level, indexer, out );
-        }
-        DeclarationWithType *curDecl = cur->first;
-        PRINT(
-            std::cerr << "inferRecursive: assertion is ";
-            curDecl->print( std::cerr );
-            std::cerr << std::endl;
-            )
-        std::list< DeclarationWithType* > candidates;
-        decls.lookupId( curDecl->get_name(), candidates );
+                        std::cerr << "inferRecursive: assertion is ";
+                        curDecl->print( std::cerr );
+                        std::cerr << std::endl;
+                        )
+                        std::list< DeclarationWithType* > candidates;
+                decls.lookupId( curDecl->get_name(), candidates );
 ///   if ( candidates.empty() ) { std::cout << "no candidates!" << std::endl; }
-        for ( std::list< DeclarationWithType* >::const_iterator candidate = candidates.begin(); candidate != candidates.end(); ++candidate ) {
-            PRINT(
-                std::cout << "inferRecursive: candidate is ";
-                (*candidate)->print( std::cout );
-                std::cout << std::endl;
-                )
-            AssertionSet newHave, newerNeed( newNeed );
-            TypeEnvironment newEnv( newAlt.env );
-            OpenVarSet newOpenVars( openVars );
-            Type *adjType = (*candidate)->get_type()->clone();
-            adjustExprType( adjType, newEnv, indexer );
-            adjType->accept( global_renamer );
-            PRINT(
-                std::cerr << "unifying ";
-                curDecl->get_type()->print( std::cerr );
-                std::cerr << " with ";
-                adjType->print( std::cerr );
-                std::cerr << std::endl;
-                )
-            if ( unify( curDecl->get_type(), adjType, newEnv, newerNeed, newHave, newOpenVars, indexer ) ) {
-                PRINT(
-                    std::cerr << "success!" << std::endl;
-                    )
-                SymTab::Indexer newDecls( decls );
-                addToIndexer( newHave, newDecls );
-                Alternative newerAlt( newAlt );
-                newerAlt.env = newEnv;
-                assert( (*candidate)->get_uniqueId() );
-                Expression *varExpr = new VariableExpr( static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) ) );
-                deleteAll( varExpr->get_results() );
-                varExpr->get_results().clear();
-                varExpr->get_results().push_front( adjType->clone() );
-                PRINT(
-                    std::cout << "satisfying assertion " << curDecl->get_uniqueId() << " ";
-                    curDecl->print( std::cout );
-                    std::cout << " with declaration " << (*candidate)->get_uniqueId() << " ";
-                    (*candidate)->print( std::cout );
-                    std::cout << std::endl;
-                    )
-                ApplicationExpr *appExpr = static_cast< ApplicationExpr* >( newerAlt.expr );
-                // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
-                appExpr->get_inferParams()[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
-                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
-            } else {
-                delete adjType;
-            }
-        }
-    }
-
-    template< typename OutputIterator >
-    void AlternativeFinder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {
+                for ( std::list< DeclarationWithType* >::const_iterator candidate = candidates.begin(); candidate != candidates.end(); ++candidate ) {
+                        PRINT(
+                                std::cout << "inferRecursive: candidate is ";
+                                (*candidate)->print( std::cout );
+                                std::cout << std::endl;
+                                )
+                                AssertionSet newHave, newerNeed( newNeed );
+                        TypeEnvironment newEnv( newAlt.env );
+                        OpenVarSet newOpenVars( openVars );
+                        Type *adjType = (*candidate)->get_type()->clone();
+                        adjustExprType( adjType, newEnv, indexer );
+                        adjType->accept( global_renamer );
+                        PRINT(
+                                std::cerr << "unifying ";
+                                curDecl->get_type()->print( std::cerr );
+                                std::cerr << " with ";
+                                adjType->print( std::cerr );
+                                std::cerr << std::endl;
+                                )
+                                if ( unify( curDecl->get_type(), adjType, newEnv, newerNeed, newHave, newOpenVars, indexer ) ) {
+                                        PRINT(
+                                                std::cerr << "success!" << std::endl;
+                                                )
+                                                SymTab::Indexer newDecls( decls );
+                                        addToIndexer( newHave, newDecls );
+                                        Alternative newerAlt( newAlt );
+                                        newerAlt.env = newEnv;
+                                        assert( (*candidate)->get_uniqueId() );
+                                        Expression *varExpr = new VariableExpr( static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) ) );
+                                        deleteAll( varExpr->get_results() );
+                                        varExpr->get_results().clear();
+                                        varExpr->get_results().push_front( adjType->clone() );
+                                        PRINT(
+                                                std::cout << "satisfying assertion " << curDecl->get_uniqueId() << " ";
+                                                curDecl->print( std::cout );
+                                                std::cout << " with declaration " << (*candidate)->get_uniqueId() << " ";
+                                                (*candidate)->print( std::cout );
+                                                std::cout << std::endl;
+                                                )
+                                                ApplicationExpr *appExpr = static_cast< ApplicationExpr* >( newerAlt.expr );
+                                        // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
+                                        appExpr->get_inferParams()[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
+                                        inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
+                                } else {
+                                        delete adjType;
+                                }
+                }
+        }
+
+        template< typename OutputIterator >
+        void AlternativeFinder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {
 //      PRINT(
 //          std::cout << "inferParameters: assertions needed are" << std::endl;
 //          printAll( need, std::cout, 8 );
 //          )
-        SymTab::Indexer decls( indexer );
-        PRINT(
-            std::cout << "============= original indexer" << std::endl;
-            indexer.print( std::cout );
-            std::cout << "============= new indexer" << std::endl;
-            decls.print( std::cout );
-            )
-        addToIndexer( have, decls );
-        AssertionSet newNeed;
-        inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
+                SymTab::Indexer decls( indexer );
+                PRINT(
+                        std::cout << "============= original indexer" << std::endl;
+                        indexer.print( std::cout );
+                        std::cout << "============= new indexer" << std::endl;
+                        decls.print( std::cout );
+                        )
+                        addToIndexer( have, decls );
+                AssertionSet newNeed;
+                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
 //      PRINT(
 //          std::cout << "declaration 14 is ";
@@ -503 +518 @@
 //          *out++ = newAlt;
 //          )
-    }
-
-    template< typename OutputIterator >
-    void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, AltList &actualAlt, OutputIterator out ) {
-        OpenVarSet openVars;
-        AssertionSet resultNeed, resultHave;
-        TypeEnvironment resultEnv;
-        makeUnifiableVars( funcType, openVars, resultNeed );
-        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( actualAlt ) );
-            makeExprList( actualAlt, appExpr->get_args() );
-            PRINT(
-                std::cout << "need assertions:" << std::endl;
-                printAssertionSet( resultNeed, std::cout, 8 );
-                )
-            inferParameters( resultNeed, resultHave, newAlt, openVars, out );
-        }
-    }
-
-    void AlternativeFinder::visit( UntypedExpr *untypedExpr ) {
-        bool doneInit = false;
-        AlternativeFinder funcOpFinder( indexer, env );
-
-        AlternativeFinder funcFinder( indexer, env ); {
-            NameExpr *fname;
-            if ( ( fname = dynamic_cast<NameExpr *>( untypedExpr->get_function()))
-                 && ( fname->get_name() == std::string("LabAddress")) ) {
-                alternatives.push_back( Alternative( untypedExpr, env, Cost()) );
-                return;
-            }
-        }
-
-        funcFinder.findWithAdjustment( untypedExpr->get_function() );
-        std::list< AlternativeFinder > argAlternatives;
-        findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(), back_inserter( argAlternatives ) );
-
-        std::list< AltList > possibilities;
-        combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
-
-        Tuples::TupleAssignSpotter tassign( this );
-        if ( tassign.isTupleAssignment( untypedExpr, possibilities ) ) {
-            // take care of possible tuple assignments, or discard expression
-            return;
-        } // else ...
-
-        AltList candidates;
-
-        for ( AltList::const_iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
-            PRINT(
-                std::cout << "working on alternative: " << std::endl;
-                func->print( std::cout, 8 );
-                )
-            // check if the type is pointer to function
-            PointerType *pointer;
-            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 ) {
-                        // XXX
-                        //Designators::check_alternative( function, *actualAlt );
-                        makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
-                    }
-                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
-                    EqvClass eqvClass;
-                    if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
-                        if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
-                            for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
-                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
-                            }
-                        }
-                    }
-                }
-            } else {
-                // seek a function operator that's compatible
-                if ( !doneInit ) {
-                    doneInit = true;
-                    NameExpr *opExpr = new NameExpr( "?()" );
-                    try {
-                        funcOpFinder.findWithAdjustment( opExpr );
-                    } catch( SemanticError &e ) {
-                        // it's ok if there aren't any defined function ops
-                    }
-                    PRINT(
-                        std::cout << "known function ops:" << std::endl;
-                        printAlts( funcOpFinder.alternatives, std::cout, 8 );
+        }
+
+        template< typename OutputIterator >
+        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, AltList &actualAlt, OutputIterator out ) {
+                OpenVarSet openVars;
+                AssertionSet resultNeed, resultHave;
+                TypeEnvironment resultEnv;
+                makeUnifiableVars( funcType, openVars, resultNeed );
+                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( actualAlt ) );
+                        makeExprList( actualAlt, appExpr->get_args() );
+                        PRINT(
+                                std::cout << "need assertions:" << std::endl;
+                                printAssertionSet( resultNeed, std::cout, 8 );
+                                )
+                                inferParameters( resultNeed, resultHave, newAlt, openVars, out );
+                }
+        }
+
+        void AlternativeFinder::visit( UntypedExpr *untypedExpr ) {
+                bool doneInit = false;
+                AlternativeFinder funcOpFinder( indexer, env );
+
+                AlternativeFinder funcFinder( indexer, env ); {
+                        NameExpr *fname;
+                        if ( ( fname = dynamic_cast<NameExpr *>( untypedExpr->get_function()))
+                                 && ( fname->get_name() == std::string("LabAddress")) ) {
+                                alternatives.push_back( Alternative( untypedExpr, env, Cost()) );
+                                return;
+                        }
+                }
+
+                funcFinder.findWithAdjustment( untypedExpr->get_function() );
+                std::list< AlternativeFinder > argAlternatives;
+                findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(), back_inserter( argAlternatives ) );
+
+                std::list< AltList > possibilities;
+                combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
+
+                Tuples::TupleAssignSpotter tassign( this );
+                if ( tassign.isTupleAssignment( untypedExpr, possibilities ) ) {
+                        // take care of possible tuple assignments, or discard expression
+                        return;
+                } // else ...
+
+                AltList candidates;
+
+                for ( AltList::const_iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
+                        PRINT(
+                                std::cout << "working on alternative: " << std::endl;
+                                func->print( std::cout, 8 );
+                                )
+                                // check if the type is pointer to function
+                                PointerType *pointer;
+                        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 ) {
+                                                // XXX
+                                                //Designators::check_alternative( function, *actualAlt );
+                                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                        }
+                                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
+                                        EqvClass eqvClass;
+                                        if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
+                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
+                                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                        } // for
+                                                } // if
+                                        } // if
+                                } // if
+                        } else {
+                                // seek a function operator that's compatible
+                                if ( ! doneInit ) {
+                                        doneInit = true;
+                                        NameExpr *opExpr = new NameExpr( "?()" );
+                                        try {
+                                                funcOpFinder.findWithAdjustment( opExpr );
+                                        } catch( SemanticError &e ) {
+                                                // it's ok if there aren't any defined function ops
+                                        }
+                                        PRINT(
+                                                std::cout << "known function ops:" << std::endl;
+                                                printAlts( funcOpFinder.alternatives, std::cout, 8 );
+                                                )
+                                                }
+
+                                for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
+                                        // check if the type is pointer to function
+                                        PointerType *pointer;
+                                        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 ) {
+                                                                AltList currentAlt;
+                                                                currentAlt.push_back( *func );
+                                                                currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() );
+                                                                makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) );
+                                                        } // for
+                                                } // if
+                                        } // if
+                                } // for
+                        } // if
+                } // for
+
+                for ( AltList::iterator withFunc = candidates.begin(); withFunc != candidates.end(); ++withFunc ) {
+                        Cost cvtCost = computeConversionCost( *withFunc, indexer );
+
+                        PRINT(
+                                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::cout << "Case +++++++++++++" << std::endl;
+                                std::cout << "formals are:" << std::endl;
+                                printAll( function->get_parameters(), std::cout, 8 );
+                                std::cout << "actuals are:" << std::endl;
+                                printAll( appExpr->get_args(), std::cout, 8 );
+                                std::cout << "bindings are:" << std::endl;
+                                withFunc->env.print( std::cout, 8 );
+                                std::cout << "cost of conversion is:" << cvtCost << std::endl;
+                                )
+                                if ( cvtCost != Cost::infinity ) {
+                                        withFunc->cvtCost = cvtCost;
+                                        alternatives.push_back( *withFunc );
+                                } // if
+                } // for
+                candidates.clear();
+                candidates.splice( candidates.end(), alternatives );
+
+                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( alternatives ) );
+        }
+
+        bool isLvalue( Expression *expr ) {
+                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;
+        }
+
+        void AlternativeFinder::visit( AddressExpr *addressExpr ) {
+                AlternativeFinder finder( indexer, env );
+                finder.find( addressExpr->get_arg() );
+                for ( std::list< Alternative >::iterator i = finder.alternatives.begin(); i != finder.alternatives.end(); ++i ) {
+                        if ( isLvalue( i->expr ) ) {
+                                alternatives.push_back( Alternative( new AddressExpr( i->expr->clone() ), i->env, i->cost ) );
+                        } // if
+                } // for
+        }
+
+        void AlternativeFinder::visit( CastExpr *castExpr ) {
+                for ( std::list< Type* >::iterator i = castExpr->get_results().begin(); i != castExpr->get_results().end(); ++i ) {
+                        SymTab::validateType( *i, &indexer );
+                        adjustExprType( *i, env, indexer );
+                } // for
+
+                AlternativeFinder finder( indexer, env );
+                finder.findWithAdjustment( castExpr->get_arg() );
+
+                AltList candidates;
+                for ( std::list< Alternative >::iterator i = finder.alternatives.begin(); i != finder.alternatives.end(); ++i ) {
+                        AssertionSet needAssertions, haveAssertions;
+                        OpenVarSet openVars;
+
+                        // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
+                        // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
+                        // 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_results().size() - castExpr->get_results().size();
+                        if ( discardedValues < 0 ) continue;
+                        std::list< Type* >::iterator candidate_end = (*i).expr->get_results().begin();
+                        std::advance( candidate_end, castExpr->get_results().size() );
+                        if ( ! unifyList( (*i).expr->get_results().begin(), candidate_end,
+                                                         castExpr->get_results().begin(), castExpr->get_results().end(), i->env, needAssertions, haveAssertions, openVars, indexer ) ) continue;
+                        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
+                                thisCost += Cost( 0, 0, discardedValues );
+                                CastExpr *newExpr = castExpr->clone();
+                                newExpr->set_arg( i->expr->clone() );
+                                candidates.push_back( Alternative( newExpr, i->env, i->cost, thisCost ) );
+                        } // if
+                } // for
+
+                // findMinCost selects the alternatives with the lowest "cost" members, but has the side effect of copying the
+                // cvtCost member to the cost member (since the old cost is now irrelevant).  Thus, calling findMinCost twice
+                // selects first based on argument cost, then on conversion cost.
+                AltList minArgCost;
+                findMinCost( candidates.begin(), candidates.end(), std::back_inserter( minArgCost ) );
+                findMinCost( minArgCost.begin(), minArgCost.end(), std::back_inserter( alternatives ) );
+        }
+
+        void AlternativeFinder::visit( UntypedMemberExpr *memberExpr ) {
+                AlternativeFinder funcFinder( indexer, env );
+                funcFinder.findWithAdjustment( memberExpr->get_aggregate() );
+
+                for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
+                        if ( agg->expr->get_results().size() == 1 ) {
+                                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
+                                        addAggMembers( structInst, agg->expr, agg->cost, memberExpr->get_member() );
+                                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
+                                        addAggMembers( unionInst, agg->expr, agg->cost, memberExpr->get_member() );
+                                } // if
+                        } // if
+                } // for
+        }
+
+        void AlternativeFinder::visit( MemberExpr *memberExpr ) {
+                alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) );
+        }
+
+        void AlternativeFinder::visit( NameExpr *nameExpr ) {
+                std::list< DeclarationWithType* > declList;
+                indexer.lookupId( nameExpr->get_name(), declList );
+                PRINT( std::cerr << "nameExpr is " << nameExpr->get_name() << std::endl; )
+                        for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
+                                VariableExpr newExpr( *i, nameExpr->get_argName() );
+                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                                PRINT(
+                                        std::cerr << "decl is ";
+                                        (*i)->print( std::cerr );
+                                        std::cerr << std::endl;
+                                        std::cerr << "newExpr is ";
+                                        newExpr.print( std::cerr );
+                                        std::cerr << std::endl;
+                                        )
+                                        renameTypes( alternatives.back().expr );
+                                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
+                                        addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), "" );
+                                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
+                                        addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), "" );
+                                } // if
+                        } // for
+        }
+
+        void AlternativeFinder::visit( VariableExpr *variableExpr ) {
+                alternatives.push_back( Alternative( variableExpr->clone(), env, Cost::zero ) );
+        }
+
+        void AlternativeFinder::visit( ConstantExpr *constantExpr ) {
+                alternatives.push_back( Alternative( constantExpr->clone(), env, Cost::zero ) );
+        }
+
+        void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) {
+                if ( sizeofExpr->get_isType() ) {
+                        alternatives.push_back( Alternative( sizeofExpr->clone(), env, Cost::zero ) );
+                } else {
+                        // find all alternatives for the argument to sizeof
+                        AlternativeFinder finder( indexer, env );
+                        finder.find( sizeofExpr->get_expr() );
+                        // find the lowest cost alternative among the alternatives, otherwise ambiguous
+                        AltList winners;
+                        findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
+                        if ( winners.size() != 1 ) {
+                                throw SemanticError( "Ambiguous expression in sizeof operand: ", sizeofExpr->get_expr() );
+                        } // if
+                        // return the lowest cost alternative for the argument
+                        Alternative &choice = winners.front();
+                        alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
+                } // if
+        }
+
+        void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) {
+                // assume no polymorphism
+                // assume no implicit conversions
+                assert( function->get_parameters().size() == 1 );
+                PRINT(
+                        std::cout << "resolvAttr: funcDecl is ";
+                        funcDecl->print( std::cout );
+                        std::cout << " argType is ";
+                        argType->print( std::cout );
+                        std::cout << std::endl;
                         )
-                }
-
-                for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
-                    // check if the type is pointer to function
-                    PointerType *pointer;
-                    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 ) {
-                                AltList currentAlt;
-                                currentAlt.push_back( *func );
-                                currentAlt.insert( currentAlt.end(), actualAlt->begin(), actualAlt->end() );
-                                makeFunctionAlternatives( *funcOp, function, currentAlt, std::back_inserter( candidates ) );
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        for ( AltList::iterator withFunc = candidates.begin(); withFunc != candidates.end(); ++withFunc ) {
-            Cost cvtCost = computeConversionCost( *withFunc, indexer );
-
-            PRINT(
-                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::cout << "Case +++++++++++++" << std::endl;
-                std::cout << "formals are:" << std::endl;
-                printAll( function->get_parameters(), std::cout, 8 );
-                std::cout << "actuals are:" << std::endl;
-                printAll( appExpr->get_args(), std::cout, 8 );
-                std::cout << "bindings are:" << std::endl;
-                withFunc->env.print( std::cout, 8 );
-                std::cout << "cost of conversion is:" << cvtCost << std::endl;
-                )
-            if ( cvtCost != Cost::infinity ) {
-                withFunc->cvtCost = cvtCost;
-                alternatives.push_back( *withFunc );
-            }
-        }
-        candidates.clear();
-        candidates.splice( candidates.end(), alternatives );
-
-        findMinCost( candidates.begin(), candidates.end(), std::back_inserter( alternatives ) );
-    }
-
-    bool isLvalue( Expression *expr ) {
-        for ( std::list< Type* >::const_iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
-            if ( !(*i)->get_isLvalue() ) return false;
-        }
-        return true;
-    }
-
-    void AlternativeFinder::visit( AddressExpr *addressExpr ) {
-        AlternativeFinder finder( indexer, env );
-        finder.find( addressExpr->get_arg() );
-        for ( std::list< Alternative >::iterator i = finder.alternatives.begin(); i != finder.alternatives.end(); ++i ) {
-            if ( isLvalue( i->expr ) ) {
-                alternatives.push_back( Alternative( new AddressExpr( i->expr->clone() ), i->env, i->cost ) );
-            }
-        }
-    }
-
-    void AlternativeFinder::visit( CastExpr *castExpr ) {
-        for ( std::list< Type* >::iterator i = castExpr->get_results().begin(); i != castExpr->get_results().end(); ++i ) {
-            SymTab::validateType( *i, &indexer );
-            adjustExprType( *i, env, indexer );
-        }
-
-        AlternativeFinder finder( indexer, env );
-        finder.findWithAdjustment( castExpr->get_arg() );
-
-        AltList candidates;
-        for ( std::list< Alternative >::iterator i = finder.alternatives.begin(); i != finder.alternatives.end(); ++i ) {
-            AssertionSet needAssertions, haveAssertions;
-            OpenVarSet openVars;
-
-            // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
-            // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
-            // 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_results().size() - castExpr->get_results().size();
-            if ( discardedValues < 0 ) continue;
-            std::list< Type* >::iterator candidate_end = (*i).expr->get_results().begin();
-            std::advance( candidate_end, castExpr->get_results().size() );
-            if ( !unifyList( (*i).expr->get_results().begin(), candidate_end,
-                            castExpr->get_results().begin(), castExpr->get_results().end(), i->env, needAssertions, haveAssertions, openVars, indexer ) ) continue;
-            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
-                thisCost += Cost( 0, 0, discardedValues );
-                CastExpr *newExpr = castExpr->clone();
-                newExpr->set_arg( i->expr->clone() );
-                candidates.push_back( Alternative( newExpr, i->env, i->cost, thisCost ) );
-            }
-        }
-
-        // findMinCost selects the alternatives with the lowest "cost" members, but has the side effect of copying the
-        // cvtCost member to the cost member (since the old cost is now irrelevant).  Thus, calling findMinCost twice
-        // selects first based on argument cost, then on conversion cost.
-        AltList minArgCost;
-        findMinCost( candidates.begin(), candidates.end(), std::back_inserter( minArgCost ) );
-        findMinCost( minArgCost.begin(), minArgCost.end(), std::back_inserter( alternatives ) );
-    }
-
-    void AlternativeFinder::visit( UntypedMemberExpr *memberExpr ) {
-        AlternativeFinder funcFinder( indexer, env );
-        funcFinder.findWithAdjustment( memberExpr->get_aggregate() );
-
-        for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
-            if ( agg->expr->get_results().size() == 1 ) {
-                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
-                    addAggMembers( structInst, agg->expr, agg->cost, memberExpr->get_member() );
-                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
-                    addAggMembers( unionInst, agg->expr, agg->cost, memberExpr->get_member() );
-                }
-            }
-        }
-    }
-
-    void AlternativeFinder::visit( MemberExpr *memberExpr ) {
-        alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) );
-    }
-
-    void AlternativeFinder::visit( NameExpr *nameExpr ) {
-        std::list< DeclarationWithType* > declList;
-        indexer.lookupId( nameExpr->get_name(), declList );
-        PRINT(
-            std::cerr << "nameExpr is " << nameExpr->get_name() << std::endl;
-            )
-        for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
-            VariableExpr newExpr( *i, nameExpr->get_argName() );
-            alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
-            PRINT(
-                std::cerr << "decl is ";
-                (*i)->print( std::cerr );
-                std::cerr << std::endl;
-                std::cerr << "newExpr is ";
-                newExpr.print( std::cerr );
-                std::cerr << std::endl;
-                )
-            renameTypes( alternatives.back().expr );
-            if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
-                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), "" );
-            } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
-                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), "" );
-            }
-        }
-    }
-
-    void AlternativeFinder::visit( VariableExpr *variableExpr ) {
-        alternatives.push_back( Alternative( variableExpr->clone(), env, Cost::zero ) );
-    }
-
-    void AlternativeFinder::visit( ConstantExpr *constantExpr ) {
-        alternatives.push_back( Alternative( constantExpr->clone(), env, Cost::zero ) );
-    }
-
-    void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) {
-        if ( sizeofExpr->get_isType() ) {
-            alternatives.push_back( Alternative( sizeofExpr->clone(), env, Cost::zero ) );
-        } else {
-            // find all alternatives for the argument to sizeof
-            AlternativeFinder finder( indexer, env );
-            finder.find( sizeofExpr->get_expr() );
-            // find the lowest cost alternative among the alternatives, otherwise ambiguous
-            AltList winners;
-            findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
-            if ( winners.size() != 1 ) {
-                throw SemanticError( "Ambiguous expression in sizeof operand: ", sizeofExpr->get_expr() );
-            }
-            // return the lowest cost alternative for the argument
-            Alternative &choice = winners.front();
-            alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
-        }
-    }
-
-    void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) {
-        // assume no polymorphism
-        // assume no implicit conversions
-        assert( function->get_parameters().size() == 1 );
-        PRINT(
-            std::cout << "resolvAttr: funcDecl is ";
-            funcDecl->print( std::cout );
-            std::cout << " argType is ";
-            argType->print( std::cout );
-            std::cout << std::endl;
-            )
-        if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
-            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->get_results().push_back( (*i)->get_type()->clone() );
-            }
-        }
-    }
-
-    void AlternativeFinder::visit( AttrExpr *attrExpr ) {
-        // assume no 'pointer-to-attribute'
-        NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() );
-        assert( nameExpr );
-        std::list< DeclarationWithType* > attrList;
-        indexer.lookupId( nameExpr->get_name(), attrList );
-        if ( attrExpr->get_isType() || attrExpr->get_expr() ) {
-            for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
-                // check if the type is function
-                if ( FunctionType *function = dynamic_cast< FunctionType* >( (*i)->get_type() ) ) {
-                    // assume exactly one parameter
-                    if ( function->get_parameters().size() == 1 ) {
-                        if ( attrExpr->get_isType() ) {
-                            resolveAttr( *i, function, attrExpr->get_type(), env );
-                        } else {
-                            AlternativeFinder finder( indexer, env );
-                            finder.find( attrExpr->get_expr() );
-                            for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
-                                if ( choice->expr->get_results().size() == 1 ) {
-                                    resolveAttr(*i, function, choice->expr->get_results().front(), choice->env );
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        } else {
-            for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
-                VariableExpr newExpr( *i );
-                alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
-                renameTypes( alternatives.back().expr );
-            }
-        }
-    }
-
-    void AlternativeFinder::visit( LogicalExpr *logicalExpr ) {
-        AlternativeFinder firstFinder( indexer, env );
-        firstFinder.findWithAdjustment( logicalExpr->get_arg1() );
-        for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) {
-            AlternativeFinder secondFinder( indexer, first->env );
-            secondFinder.findWithAdjustment( logicalExpr->get_arg2() );
-            for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) {
-                LogicalExpr *newExpr = new LogicalExpr( first->expr->clone(), second->expr->clone(), logicalExpr->get_isAnd() );
-                alternatives.push_back( Alternative( newExpr, second->env, first->cost + second->cost ) );
-            }
-        }
-    }
-
-    void AlternativeFinder::visit( ConditionalExpr *conditionalExpr ) {
-        AlternativeFinder firstFinder( indexer, env );
-        firstFinder.findWithAdjustment( conditionalExpr->get_arg1() );
-        for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) {
-            AlternativeFinder secondFinder( indexer, first->env );
-            secondFinder.findWithAdjustment( conditionalExpr->get_arg2() );
-            for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) {
-                AlternativeFinder thirdFinder( indexer, second->env );
-                thirdFinder.findWithAdjustment( conditionalExpr->get_arg3() );
-                for ( AltList::const_iterator third = thirdFinder.alternatives.begin(); third != thirdFinder.alternatives.end(); ++third ) {
-                    OpenVarSet openVars;
-                    AssertionSet needAssertions, haveAssertions;
-                    Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );
-                    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() );
-                        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() );
-                            }
-                        }
-                        newAlt.expr = newExpr;
-                        inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );
-                    }
-                }
-            }
-        }
-    }
-
-    void AlternativeFinder::visit( CommaExpr *commaExpr ) {
-        TypeEnvironment newEnv( env );
-        Expression *newFirstArg = resolveInVoidContext( commaExpr->get_arg1(), indexer, newEnv );
-        AlternativeFinder secondFinder( indexer, newEnv );
-        secondFinder.findWithAdjustment( commaExpr->get_arg2() );
-        for ( AltList::const_iterator alt = secondFinder.alternatives.begin(); alt != secondFinder.alternatives.end(); ++alt ) {
-            alternatives.push_back( Alternative( new CommaExpr( newFirstArg->clone(), alt->expr->clone() ), alt->env, alt->cost ) );
-        }
-        delete newFirstArg;
-    }
-
-    void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
-        std::list< AlternativeFinder > subExprAlternatives;
-        findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) );
-        std::list< AltList > possibilities;
-        combos( subExprAlternatives.begin(), subExprAlternatives.end(), back_inserter( possibilities ) );
-        for ( std::list< AltList >::const_iterator i = possibilities.begin(); i != possibilities.end(); ++i ) {
-            TupleExpr *newExpr = new TupleExpr;
-            makeExprList( *i, 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() );
-                }
-            }
-
-            TypeEnvironment compositeEnv;
-            simpleCombineEnvironments( i->begin(), i->end(), compositeEnv );
-            alternatives.push_back( Alternative( newExpr, compositeEnv, sumCost( *i ) ) );
-        }
-    }
+                        if ( typesCompatibleIgnoreQualifiers( argType, function->get_parameters().front()->get_type(), indexer, env ) ) {
+                                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->get_results().push_back( (*i)->get_type()->clone() );
+                                } // for
+                        } // if
+        }
+
+        void AlternativeFinder::visit( AttrExpr *attrExpr ) {
+                // assume no 'pointer-to-attribute'
+                NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() );
+                assert( nameExpr );
+                std::list< DeclarationWithType* > attrList;
+                indexer.lookupId( nameExpr->get_name(), attrList );
+                if ( attrExpr->get_isType() || attrExpr->get_expr() ) {
+                        for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
+                                // check if the type is function
+                                if ( FunctionType *function = dynamic_cast< FunctionType* >( (*i)->get_type() ) ) {
+                                        // assume exactly one parameter
+                                        if ( function->get_parameters().size() == 1 ) {
+                                                if ( attrExpr->get_isType() ) {
+                                                        resolveAttr( *i, function, attrExpr->get_type(), env );
+                                                } else {
+                                                        AlternativeFinder finder( indexer, env );
+                                                        finder.find( attrExpr->get_expr() );
+                                                        for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
+                                                                if ( choice->expr->get_results().size() == 1 ) {
+                                                                        resolveAttr(*i, function, choice->expr->get_results().front(), choice->env );
+                                                                } // fi
+                                                        } // for
+                                                } // if
+                                        } // if
+                                } // if
+                        } // for
+                } else {
+                        for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
+                                VariableExpr newExpr( *i );
+                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                                renameTypes( alternatives.back().expr );
+                        } // for
+                } // if
+        }
+
+        void AlternativeFinder::visit( LogicalExpr *logicalExpr ) {
+                AlternativeFinder firstFinder( indexer, env );
+                firstFinder.findWithAdjustment( logicalExpr->get_arg1() );
+                for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) {
+                        AlternativeFinder secondFinder( indexer, first->env );
+                        secondFinder.findWithAdjustment( logicalExpr->get_arg2() );
+                        for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) {
+                                LogicalExpr *newExpr = new LogicalExpr( first->expr->clone(), second->expr->clone(), logicalExpr->get_isAnd() );
+                                alternatives.push_back( Alternative( newExpr, second->env, first->cost + second->cost ) );
+                        }
+                }
+        }
+
+        void AlternativeFinder::visit( ConditionalExpr *conditionalExpr ) {
+                AlternativeFinder firstFinder( indexer, env );
+                firstFinder.findWithAdjustment( conditionalExpr->get_arg1() );
+                for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) {
+                        AlternativeFinder secondFinder( indexer, first->env );
+                        secondFinder.findWithAdjustment( conditionalExpr->get_arg2() );
+                        for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) {
+                                AlternativeFinder thirdFinder( indexer, second->env );
+                                thirdFinder.findWithAdjustment( conditionalExpr->get_arg3() );
+                                for ( AltList::const_iterator third = thirdFinder.alternatives.begin(); third != thirdFinder.alternatives.end(); ++third ) {
+                                        OpenVarSet openVars;
+                                        AssertionSet needAssertions, haveAssertions;
+                                        Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );
+                                        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() );
+                                                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 ) );
+                                        } // if
+                                } // for
+                        } // for
+                } // for
+        }
+
+        void AlternativeFinder::visit( CommaExpr *commaExpr ) {
+                TypeEnvironment newEnv( env );
+                Expression *newFirstArg = resolveInVoidContext( commaExpr->get_arg1(), indexer, newEnv );
+                AlternativeFinder secondFinder( indexer, newEnv );
+                secondFinder.findWithAdjustment( commaExpr->get_arg2() );
+                for ( AltList::const_iterator alt = secondFinder.alternatives.begin(); alt != secondFinder.alternatives.end(); ++alt ) {
+                        alternatives.push_back( Alternative( new CommaExpr( newFirstArg->clone(), alt->expr->clone() ), alt->env, alt->cost ) );
+                } // for
+                delete newFirstArg;
+        }
+
+        void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
+                std::list< AlternativeFinder > subExprAlternatives;
+                findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) );
+                std::list< AltList > possibilities;
+                combos( subExprAlternatives.begin(), subExprAlternatives.end(), back_inserter( possibilities ) );
+                for ( std::list< AltList >::const_iterator i = possibilities.begin(); i != possibilities.end(); ++i ) {
+                        TupleExpr *newExpr = new TupleExpr;
+                        makeExprList( *i, 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;
+                        simpleCombineEnvironments( i->begin(), i->end(), compositeEnv );
+                        alternatives.push_back( Alternative( newExpr, compositeEnv, sumCost( *i ) ) );
+                } // for
+        }
 } // namespace ResolvExpr
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/ResolvExpr/AlternativeFinder.h

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// AlternativeFinder.h -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Sat May 16 23:56:12 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat May 16 23:58:43 2015
+// Update Count     : 2
+// 
+
 #ifndef ALTERNATIVEFINDER_H
 #define ALTERNATIVEFINDER_H
@@ -11 +26 @@
 
 namespace ResolvExpr {
-    class AlternativeFinder : public Visitor {
-      public:
-        AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
-        void find( Expression *expr, bool adjust = false );
-        void findWithAdjustment( Expression *expr );
-        AltList &get_alternatives() { return alternatives; }
-  
-        // make this look like an STL container so that we can apply generic algorithms
-        typedef Alternative value_type;
-        typedef AltList::iterator iterator;
-        typedef AltList::const_iterator const_iterator;
-        AltList::iterator begin() { return alternatives.begin(); }
-        AltList::iterator end() { return alternatives.end(); }
-        AltList::const_iterator begin() const { return alternatives.begin(); }
-        AltList::const_iterator end() const { return alternatives.end(); }
-  
-        const SymTab::Indexer &get_indexer() const { return indexer; }
-        const TypeEnvironment &get_environ() const { return env; }
-      private:
-        virtual void visit( ApplicationExpr *applicationExpr );
-        virtual void visit( UntypedExpr *untypedExpr );
-        virtual void visit( AddressExpr *addressExpr );
-        virtual void visit( CastExpr *castExpr );
-        virtual void visit( UntypedMemberExpr *memberExpr );
-        virtual void visit( MemberExpr *memberExpr );
-        virtual void visit( NameExpr *variableExpr );
-        virtual void visit( VariableExpr *variableExpr );
-        virtual void visit( ConstantExpr *constantExpr ); 
-        virtual void visit( SizeofExpr *sizeofExpr );
-        virtual void visit( AttrExpr *attrExpr );
-        virtual void visit( LogicalExpr *logicalExpr );
-        virtual void visit( ConditionalExpr *conditionalExpr );
-        virtual void visit( CommaExpr *commaExpr );
-        virtual void visit( TupleExpr *tupleExpr );
-      public:  // xxx - temporary hack - should make Tuples::TupleAssignment a friend
-        template< typename InputIterator, typename OutputIterator >
-            void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
+        class AlternativeFinder : public Visitor {
+          public:
+                AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
+                void find( Expression *expr, bool adjust = false );
+                void findWithAdjustment( Expression *expr );
+                AltList &get_alternatives() { return alternatives; }
 
-      private:
-        template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name );
-        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, AltList &actualAlt, OutputIterator out );
-        template< typename OutputIterator >
-            void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
-        void resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env );
+                // make this look like an STL container so that we can apply generic algorithms
+                typedef Alternative value_type;
+                typedef AltList::iterator iterator;
+                typedef AltList::const_iterator const_iterator;
+                AltList::iterator begin() { return alternatives.begin(); }
+                AltList::iterator end() { return alternatives.end(); }
+                AltList::const_iterator begin() const { return alternatives.begin(); }
+                AltList::const_iterator end() const { return alternatives.end(); }
 
-        const SymTab::Indexer &indexer;
-        AltList alternatives;
-        const TypeEnvironment &env;
-    }; // AlternativeFinder
+                const SymTab::Indexer &get_indexer() const { return indexer; }
+                const TypeEnvironment &get_environ() const { return env; }
+          private:
+                virtual void visit( ApplicationExpr *applicationExpr );
+                virtual void visit( UntypedExpr *untypedExpr );
+                virtual void visit( AddressExpr *addressExpr );
+                virtual void visit( CastExpr *castExpr );
+                virtual void visit( UntypedMemberExpr *memberExpr );
+                virtual void visit( MemberExpr *memberExpr );
+                virtual void visit( NameExpr *variableExpr );
+                virtual void visit( VariableExpr *variableExpr );
+                virtual void visit( ConstantExpr *constantExpr ); 
+                virtual void visit( SizeofExpr *sizeofExpr );
+                virtual void visit( AttrExpr *attrExpr );
+                virtual void visit( LogicalExpr *logicalExpr );
+                virtual void visit( ConditionalExpr *conditionalExpr );
+                virtual void visit( CommaExpr *commaExpr );
+                virtual void visit( TupleExpr *tupleExpr );
+          public:  // xxx - temporary hack - should make Tuples::TupleAssignment a friend
+                template< typename InputIterator, typename OutputIterator >
+                void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
 
-    Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
+          private:
+                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const std::string &name );
+                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, AltList &actualAlt, OutputIterator out );
+                template< typename OutputIterator >
+                void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
+                void resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env );
+
+                const SymTab::Indexer &indexer;
+                AltList alternatives;
+                const TypeEnvironment &env;
+        }; // AlternativeFinder
+
+        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env );
 } // namespace ResolvExpr
 
 #endif // ALTERNATIVEFINDER_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/ResolvExpr/AlternativePrinter.cc

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// AlternativePrinter.cc -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 06:53:19 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 06:55:05 2015
+// Update Count     : 2
+//
+
 #include "AlternativePrinter.h"
 #include "AlternativeFinder.h"
@@ -8 +23 @@
 
 namespace ResolvExpr {
-    AlternativePrinter::AlternativePrinter( std::ostream &os ) : SymTab::Indexer( false ), os( os ) {}
+        AlternativePrinter::AlternativePrinter( std::ostream &os ) : SymTab::Indexer( false ), os( os ) {}
 
-    void AlternativePrinter::visit( ExprStmt *exprStmt ) {
-        TypeEnvironment env;
-        AlternativeFinder finder( *this, env );
-        finder.findWithAdjustment( exprStmt->get_expr() );
-        int count = 1;
-        os << "There are " << finder.get_alternatives().size() << " alternatives" << std::endl;
-        for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-            os << "Alternative " << count++ << " ==============" << std::endl;
-            printAll( i->expr->get_results(), os );
-            //    i->print( os );
-            os << std::endl;
-        } // for
-    } // AlternativePrinter::visit
+        void AlternativePrinter::visit( ExprStmt *exprStmt ) {
+                TypeEnvironment env;
+                AlternativeFinder finder( *this, env );
+                finder.findWithAdjustment( exprStmt->get_expr() );
+                int count = 1;
+                os << "There are " << finder.get_alternatives().size() << " alternatives" << std::endl;
+                for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
+                        os << "Alternative " << count++ << " ==============" << std::endl;
+                        printAll( i->expr->get_results(), os );
+                        //    i->print( os );
+                        os << std::endl;
+                } // for
+        } // AlternativePrinter::visit
 } // namespace ResolvExpr
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/ResolvExpr/AlternativePrinter.h

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// AlternativePrinter.h -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 06:55:43 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 06:57:12 2015
+// Update Count     : 3
+//
+
 #ifndef ALTERNATIVEPRINTER_H
 #define ALTERNATIVEPRINTER_H
@@ -8 +23 @@
 
 namespace ResolvExpr {
-    class AlternativePrinter : public SymTab::Indexer {
-      public:
-        AlternativePrinter( std::ostream &os );
-        virtual void visit(ExprStmt *exprStmt);
-      private:
-        std::ostream &os;
-    };
+        class AlternativePrinter : public SymTab::Indexer {
+          public:
+                AlternativePrinter( std::ostream &os );
+                virtual void visit( ExprStmt *exprStmt );
+          private:
+                std::ostream &os;
+        };
 } // namespace ResolvExpr
 
 #endif // ALTERNATIVEPRINTER_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/ResolvExpr/CastCost.cc

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// CastCost.cc -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 06:57:43 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 06:59:10 2015
+// Update Count     : 2
+//
+
 #include "typeops.h"
 #include "Cost.h"
@@ -8 +23 @@
 
 namespace ResolvExpr {
-    class CastCost : public ConversionCost {
-      public:
-        CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
+        class CastCost : public ConversionCost {
+          public:
+                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
   
-        virtual void visit( BasicType *basicType );
-        virtual void visit( PointerType *pointerType );
-    };
+                virtual void visit( BasicType *basicType );
+                virtual void visit( PointerType *pointerType );
+        };
 
-    Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-        if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
-            EqvClass eqvClass;
-            NamedTypeDecl *namedType;
-            if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
-                return castCost( src, eqvClass.type, indexer, env );
-            } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
-                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
-                // all typedefs should be gone by this point
-                assert( type );
-                if ( type->get_base() ) {
-                    return castCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
+        Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
+                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
+                        EqvClass eqvClass;
+                        NamedTypeDecl *namedType;
+                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
+                                return castCost( src, eqvClass.type, indexer, env );
+                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
+                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
+                                // all typedefs should be gone by this point
+                                assert( type );
+                                if ( type->get_base() ) {
+                                        return castCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
+                                } // if
+                        } // if
                 } // if
-            } // if
-        } // if
-        if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
-            return Cost( 0, 0, 0 );
-        } else if ( dynamic_cast< VoidType* >( dest ) ) {
-            return Cost( 0, 0, 1 );
-        } else {
-            CastCost converter( dest, indexer, env );
-            src->accept( converter );
-            if ( converter.get_cost() == Cost::infinity ) {
-                return Cost::infinity;
-            } else {
-                return converter.get_cost() + Cost( 0, 0, 0 );
-            } // if
-        } // if
-    }
+                if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
+                        return Cost( 0, 0, 0 );
+                } else if ( dynamic_cast< VoidType* >( dest ) ) {
+                        return Cost( 0, 0, 1 );
+                } else {
+                        CastCost converter( dest, indexer, env );
+                        src->accept( converter );
+                        if ( converter.get_cost() == Cost::infinity ) {
+                                return Cost::infinity;
+                        } else {
+                                return converter.get_cost() + Cost( 0, 0, 0 );
+                        } // if
+                } // if
+        }
 
-    CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
-        : ConversionCost( dest, indexer, env ) {
-    }
+        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
+                : ConversionCost( dest, indexer, env ) {
+        }
 
-    void CastCost::visit( BasicType *basicType ) {
-        if ( dynamic_cast< PointerType* >( dest ) ) {
-            cost = Cost( 1, 0, 0 );
-        } else {
-            ConversionCost::visit( basicType );
-        } // if
-    }
+        void CastCost::visit( BasicType *basicType ) {
+                if ( dynamic_cast< PointerType* >( dest ) ) {
+                        cost = Cost( 1, 0, 0 );
+                } else {
+                        ConversionCost::visit( basicType );
+                } // if
+        }
 
-    void CastCost::visit( PointerType *pointerType ) {
-        if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-            if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
-                cost = Cost( 0, 0, 1 );
-            } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
-                if ( destAsBasic->isInteger() ) {
-                    cost = Cost( 1, 0, 0 );
-                }
-            } else {
-                TypeEnvironment newEnv( env );
-                newEnv.add( pointerType->get_forall() );
-                newEnv.add( pointerType->get_base()->get_forall() );
-                int assignResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
-                if ( assignResult > 0 ) {
-                    cost = Cost( 0, 0, 1 );
-                } else if ( assignResult < 0 ) {
-                    cost = Cost( 1, 0, 0 );
+        void CastCost::visit( PointerType *pointerType ) {
+                if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
+                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                                cost = Cost( 0, 0, 1 );
+                        } else if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
+                                if ( destAsBasic->isInteger() ) {
+                                        cost = Cost( 1, 0, 0 );
+                                } // if
+                        } else {
+                                TypeEnvironment newEnv( env );
+                                newEnv.add( pointerType->get_forall() );
+                                newEnv.add( pointerType->get_base()->get_forall() );
+                                int assignResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
+                                if ( assignResult > 0 ) {
+                                        cost = Cost( 0, 0, 1 );
+                                } else if ( assignResult < 0 ) {
+                                        cost = Cost( 1, 0, 0 );
+                                } // if
+                        } // if
                 } // if
-            } // if
-        } // if
-    }
+        }
 } // namespace ResolvExpr
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/ResolvExpr/CommonType.cc

@@ -1 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: CommonType.cc,v 1.6 2005/08/29 20:14:15 rcbilson Exp $
- *
- */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// CommonType.cc -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 06:59:27 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 07:04:50 2015
+// Update Count     : 2
+//
 
 #include "typeops.h"
@@ -14 +22 @@
 
 namespace ResolvExpr {
-
-class CommonType : public Visitor
-{
-public:
-  CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
-  
-  Type *get_result() const { return result; }
-
-private:
-  virtual void visit( VoidType *voidType );
-  virtual void visit( BasicType *basicType );
-  virtual void visit( PointerType *pointerType );
-  virtual void visit( ArrayType *arrayType );
-  virtual void visit( FunctionType *functionType );
-  virtual void visit( StructInstType *aggregateUseType );
-  virtual void visit( UnionInstType *aggregateUseType );
-  virtual void visit( EnumInstType *aggregateUseType );
-  virtual void visit( ContextInstType *aggregateUseType );
-  virtual void visit( TypeInstType *aggregateUseType );
-  virtual void visit( TupleType *tupleType );
-
-  template< typename RefType > void handleRefType( RefType *inst, Type *other );
-
-  Type *result;
-  Type *type2;                          // inherited
-  bool widenFirst, widenSecond;
-  const SymTab::Indexer &indexer;
-  TypeEnvironment &env;
-  const OpenVarSet &openVars;
-};
-
-Type *
-commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars )
-{
-  CommonType visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
-  type1->accept( visitor );
-  Type *result = visitor.get_result();
-  if( !result ) {
-    if( widenSecond ) {
-      TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 );
-      if( inst ) {
-        NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
-        if( nt ) {
-          TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
-          assert( type );
-          if( type->get_base() ) {
-            Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
-            AssertionSet have, need;
-            OpenVarSet newOpen( openVars );
-            type1->get_qualifiers() = Type::Qualifiers();
-            type->get_base()->get_qualifiers() = tq1;
-            if( unifyExact( type1, type->get_base(), env, have, need, newOpen, indexer ) ) {
-              result = type1->clone();
-              result->get_qualifiers() = tq1 + tq2;
-            }
-            type1->get_qualifiers() = tq1;
-            type->get_base()->get_qualifiers() = Type::Qualifiers();
-          }
-        }
-      }
-    }
-  }
+        class CommonType : public Visitor {
+          public:
+                CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
+                Type *get_result() const { return result; }
+          private:
+                virtual void visit( VoidType *voidType );
+                virtual void visit( BasicType *basicType );
+                virtual void visit( PointerType *pointerType );
+                virtual void visit( ArrayType *arrayType );
+                virtual void visit( FunctionType *functionType );
+                virtual void visit( StructInstType *aggregateUseType );
+                virtual void visit( UnionInstType *aggregateUseType );
+                virtual void visit( EnumInstType *aggregateUseType );
+                virtual void visit( ContextInstType *aggregateUseType );
+                virtual void visit( TypeInstType *aggregateUseType );
+                virtual void visit( TupleType *tupleType );
+
+                template< typename RefType > void handleRefType( RefType *inst, Type *other );
+
+                Type *result;
+                Type *type2;                            // inherited
+                bool widenFirst, widenSecond;
+                const SymTab::Indexer &indexer;
+                TypeEnvironment &env;
+                const OpenVarSet &openVars;
+        };
+
+        Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) {
+                CommonType visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
+                type1->accept( visitor );
+                Type *result = visitor.get_result();
+                if ( ! result ) {
+                        if ( widenSecond ) {
+                                TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 );
+                                if ( inst ) {
+                                        NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
+                                        if ( nt ) {
+                                                TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
+                                                assert( type );
+                                                if ( type->get_base() ) {
+                                                        Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
+                                                        AssertionSet have, need;
+                                                        OpenVarSet newOpen( openVars );
+                                                        type1->get_qualifiers() = Type::Qualifiers();
+                                                        type->get_base()->get_qualifiers() = tq1;
+                                                        if ( unifyExact( type1, type->get_base(), env, have, need, newOpen, indexer ) ) {
+                                                                result = type1->clone();
+                                                                result->get_qualifiers() = tq1 + tq2;
+                                                        } // if
+                                                        type1->get_qualifiers() = tq1;
+                                                        type->get_base()->get_qualifiers() = Type::Qualifiers();
+                                                } // if
+                                        } // if
+                                } // if
+                        } // if
+                } // if
 #ifdef DEBUG
-  std::cout << "============= commonType" << std::endl << "type1 is ";
-  type1->print( std::cout );
-  std::cout << " type2 is ";
-  type2->print( std::cout );
-  if( result ) {
-    std::cout << " common type is ";
-    result->print( std::cout );
-  } else {
-    std::cout << " no common type";
-  }
-  std::cout << std::endl;
+                std::cout << "============= commonType" << std::endl << "type1 is ";
+                type1->print( std::cout );
+                std::cout << " type2 is ";
+                type2->print( std::cout );
+                if ( result ) {
+                        std::cout << " common type is ";
+                        result->print( std::cout );
+                } else {
+                        std::cout << " no common type";
+                } // if
+                std::cout << std::endl;
 #endif
-  return result;
-}
-
-static const BasicType::Kind combinedType[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] =
-{
+                return result;
+        }
+
+        static const BasicType::Kind combinedType[ BasicType::NUMBER_OF_BASIC_TYPES ][ BasicType::NUMBER_OF_BASIC_TYPES ] =
+        {
 /*              Bool            Char    SignedChar      UnsignedChar    ShortSignedInt  ShortUnsignedInt        SignedInt       UnsignedInt     LongSignedInt   LongUnsignedInt LongLongSignedInt       LongLongUnsignedInt     Float   Double  LongDouble      FloatComplex    DoubleComplex   LongDoubleComplex       FloatImaginary  DoubleImaginary LongDoubleImaginary */
-/* Bool */      { BasicType::Bool,              BasicType::Char,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* Char */      { BasicType::Char,              BasicType::Char,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* SignedChar */        { BasicType::SignedChar,        BasicType::UnsignedChar,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* UnsignedChar */      { BasicType::UnsignedChar,      BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* ShortSignedInt */    { BasicType::ShortSignedInt,    BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* ShortUnsignedInt */  { BasicType::ShortUnsignedInt,  BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* SignedInt */         { BasicType::SignedInt,         BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* UnsignedInt */       { BasicType::UnsignedInt,               BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* LongSignedInt */     { BasicType::LongSignedInt,             BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* LongUnsignedInt */   { BasicType::LongUnsignedInt,   BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* LongLongSignedInt */         { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* LongLongUnsignedInt */       { BasicType::LongLongUnsignedInt,       BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* Float */     { BasicType::Float,     BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* Double */    { BasicType::Double,    BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::LongDouble,  BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* LongDouble */        { BasicType::LongDouble,                BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex },
-/* FloatComplex */      { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* DoubleComplex */     { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
-/* LongDoubleComplex */         { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex },
-/* FloatImaginary */    { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatImaginary,      BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary },
-/* DoubleImaginary */   { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleImaginary,     BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary },
-/* LongDoubleImaginary */       { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary }
-};
-
-CommonType::CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars )
-  : result( 0 ), type2( type2 ), widenFirst( widenFirst ), widenSecond( widenSecond ), indexer( indexer ), env( env ), openVars( openVars )
-{
-}
-
-void 
-CommonType::visit( VoidType *voidType )
-{
-}
-
-void 
-CommonType::visit( BasicType *basicType )
-{
-  if( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
-    BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ];
-    if( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= otherBasic->get_qualifiers() ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->get_qualifiers() <= otherBasic->get_qualifiers() ) || widenSecond ) ) {
-      result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
-    }
-  }
-}
-
-void 
-CommonType::visit( PointerType *pointerType )
-{
-  if( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
-    if( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) ) {
-      result = otherPointer->clone();
-      result->get_qualifiers() += pointerType->get_qualifiers();
-    } else if( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) ) {
-      result = pointerType->clone();
-      result->get_qualifiers() += otherPointer->get_qualifiers();
-    } else if( ( pointerType->get_base()->get_qualifiers() >= otherPointer->get_base()->get_qualifiers() || widenFirst )
-               && ( pointerType->get_base()->get_qualifiers() <= otherPointer->get_base()->get_qualifiers() || widenSecond ) ) {
-      Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers(), tq2 = otherPointer->get_base()->get_qualifiers();
-      pointerType->get_base()->get_qualifiers() = Type::Qualifiers();
-      otherPointer->get_base()->get_qualifiers() = Type::Qualifiers();
-      AssertionSet have, need;
-      OpenVarSet newOpen( openVars );
-      if( unifyExact( pointerType->get_base(), otherPointer->get_base(), env, have, need, newOpen, indexer ) ) {
-        if( tq1 < tq2 ) {
-          result = pointerType->clone();
-        } else {
-          result = otherPointer->clone();
-        }
-        result->get_qualifiers() = tq1 + tq2;
-      } else {
-        /// std::cout << "place for ptr-to-type" << std::endl;
-      }
-      pointerType->get_base()->get_qualifiers() = tq1;
-      otherPointer->get_base()->get_qualifiers() = tq2;
-    }
-  }
-}
-
-void 
-CommonType::visit( ArrayType *arrayType )
-{
-}
-
-void 
-CommonType::visit( FunctionType *functionType )
-{
-}
-
-template< typename RefType > void 
-CommonType::handleRefType( RefType *inst, Type *other )
-{
-}
-
-void 
-CommonType::visit( StructInstType *aggregateUseType )
-{
-}
-
-void 
-CommonType::visit( UnionInstType *aggregateUseType )
-{
-}
-
-void 
-CommonType::visit( EnumInstType *aggregateUseType )
-{
-}
-
-void 
-CommonType::visit( ContextInstType *aggregateUseType )
-{
-}
-
-void 
-CommonType::visit( TypeInstType *inst )
-{
-  if( widenFirst ) {
-    NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
-    if( nt ) {
-      TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
-      assert( type );
-      if( type->get_base() ) {
-        Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers();
-        AssertionSet have, need;
-        OpenVarSet newOpen( openVars );
-        type2->get_qualifiers() = Type::Qualifiers();
-        type->get_base()->get_qualifiers() = tq1;
-        if( unifyExact( type->get_base(), type2, env, have, need, newOpen, indexer ) ) {
-          result = type2->clone();
-          result->get_qualifiers() = tq1 + tq2;
-        }
-        type2->get_qualifiers() = tq2;
-        type->get_base()->get_qualifiers() = Type::Qualifiers();
-      }
-    }
-  }
-}
-
-void 
-CommonType::visit( TupleType *tupleType )
-{
-}
-
+                /* Bool */      { BasicType::Bool,              BasicType::Char,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* Char */      { BasicType::Char,              BasicType::Char,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* SignedChar */        { BasicType::SignedChar,        BasicType::UnsignedChar,        BasicType::SignedChar,  BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* UnsignedChar */      { BasicType::UnsignedChar,      BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::UnsignedChar,        BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* ShortSignedInt */    { BasicType::ShortSignedInt,    BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortSignedInt,      BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* ShortUnsignedInt */  { BasicType::ShortUnsignedInt,  BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::ShortUnsignedInt,    BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* SignedInt */         { BasicType::SignedInt,         BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::SignedInt,   BasicType::UnsignedInt, BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* UnsignedInt */       { BasicType::UnsignedInt,               BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::UnsignedInt, BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongSignedInt */     { BasicType::LongSignedInt,             BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongSignedInt,       BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongUnsignedInt */   { BasicType::LongUnsignedInt,   BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongUnsignedInt,     BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongLongSignedInt */         { BasicType::LongLongSignedInt, BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongSignedInt,   BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongLongUnsignedInt */       { BasicType::LongLongUnsignedInt,       BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* Float */     { BasicType::Float,     BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Float,       BasicType::Double,      BasicType::LongDouble,  BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* Double */    { BasicType::Double,    BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::Double,      BasicType::LongDouble,  BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongDouble */        { BasicType::LongDouble,                BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDouble,  BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex },
+                /* FloatComplex */      { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* DoubleComplex */     { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex },
+                /* LongDoubleComplex */         { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex },
+                /* FloatImaginary */    { BasicType::FloatComplex,      BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatComplex,        BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::FloatImaginary,      BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary },
+                /* DoubleImaginary */   { BasicType::DoubleComplex,     BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleComplex,       BasicType::DoubleComplex,       BasicType::LongDoubleComplex,   BasicType::DoubleImaginary,     BasicType::DoubleImaginary,     BasicType::LongDoubleImaginary },
+                /* LongDoubleImaginary */       { BasicType::LongDoubleComplex, BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleComplex,   BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary, BasicType::LongDoubleImaginary }
+        };
+
+        CommonType::CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars )
+                : result( 0 ), type2( type2 ), widenFirst( widenFirst ), widenSecond( widenSecond ), indexer( indexer ), env( env ), openVars( openVars ) {
+        }
+
+        void CommonType::visit( VoidType *voidType ) {
+        }
+
+        void CommonType::visit( BasicType *basicType ) {
+                if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
+                        BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ];
+                        if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= otherBasic->get_qualifiers() ) || widenFirst ) && ( ( newType == otherBasic->get_kind() && basicType->get_qualifiers() <= otherBasic->get_qualifiers() ) || widenSecond ) ) {
+                                result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
+                        } // if
+                } // if
+        }
+
+        void CommonType::visit( PointerType *pointerType ) {
+                if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
+                        if ( widenFirst && dynamic_cast< VoidType* >( otherPointer->get_base() ) ) {
+                                result = otherPointer->clone();
+                                result->get_qualifiers() += pointerType->get_qualifiers();
+                        } else if ( widenSecond && dynamic_cast< VoidType* >( pointerType->get_base() ) ) {
+                                result = pointerType->clone();
+                                result->get_qualifiers() += otherPointer->get_qualifiers();
+                        } else if ( ( pointerType->get_base()->get_qualifiers() >= otherPointer->get_base()->get_qualifiers() || widenFirst )
+                                           && ( pointerType->get_base()->get_qualifiers() <= otherPointer->get_base()->get_qualifiers() || widenSecond ) ) {
+                                Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers(), tq2 = otherPointer->get_base()->get_qualifiers();
+                                pointerType->get_base()->get_qualifiers() = Type::Qualifiers();
+                                otherPointer->get_base()->get_qualifiers() = Type::Qualifiers();
+                                AssertionSet have, need;
+                                OpenVarSet newOpen( openVars );
+                                if ( unifyExact( pointerType->get_base(), otherPointer->get_base(), env, have, need, newOpen, indexer ) ) {
+                                        if ( tq1 < tq2 ) {
+                                                result = pointerType->clone();
+                                        } else {
+                                                result = otherPointer->clone();
+                                        } // if
+                                        result->get_qualifiers() = tq1 + tq2;
+                                } else {
+                                        /// std::cout << "place for ptr-to-type" << std::endl;
+                                } // if
+                                pointerType->get_base()->get_qualifiers() = tq1;
+                                otherPointer->get_base()->get_qualifiers() = tq2;
+                        } // if
+                } // if
+        }
+
+        void CommonType::visit( ArrayType *arrayType ) {
+        }
+
+        void CommonType::visit( FunctionType *functionType ) {
+        }
+
+        template< typename RefType > void CommonType::handleRefType( RefType *inst, Type *other ) {
+        }
+
+        void CommonType::visit( StructInstType *aggregateUseType ) {
+        }
+
+        void CommonType::visit( UnionInstType *aggregateUseType ) {
+        }
+
+        void CommonType::visit( EnumInstType *aggregateUseType ) {
+        }
+
+        void CommonType::visit( ContextInstType *aggregateUseType ) {
+        }
+
+        void CommonType::visit( TypeInstType *inst ) {
+                if ( widenFirst ) {
+                        NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
+                        if ( nt ) {
+                                TypeDecl *type = dynamic_cast< TypeDecl* >( nt );
+                                assert( type );
+                                if ( type->get_base() ) {
+                                        Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers();
+                                        AssertionSet have, need;
+                                        OpenVarSet newOpen( openVars );
+                                        type2->get_qualifiers() = Type::Qualifiers();
+                                        type->get_base()->get_qualifiers() = tq1;
+                                        if ( unifyExact( type->get_base(), type2, env, have, need, newOpen, indexer ) ) {
+                                                result = type2->clone();
+                                                result->get_qualifiers() = tq1 + tq2;
+                                        } // if
+                                        type2->get_qualifiers() = tq2;
+                                        type->get_base()->get_qualifiers() = Type::Qualifiers();
+                                } // if
+                        } // if
+                } // if
+        }
+
+        void CommonType::visit( TupleType *tupleType ) {
+        }
 } // namespace ResolvExpr
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/ResolvExpr/ConversionCost.cc

@@ -1 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: ConversionCost.cc,v 1.11 2005/08/29 20:14:15 rcbilson Exp $
- *
- */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// ConversionCost.cc -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 07:06:19 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 07:22:19 2015
+// Update Count     : 4
+//
 
 #include "ConversionCost.h"
@@ -12 +20 @@
 #include "SymTab/Indexer.h"
 
-
 namespace ResolvExpr {
-
-const Cost Cost::zero = Cost( 0, 0, 0 );
-const Cost Cost::infinity = Cost( -1, -1, -1 );
-
-Cost
-conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
-{
-  if( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
-    EqvClass eqvClass;
-    NamedTypeDecl *namedType;
+        const Cost Cost::zero = Cost( 0, 0, 0 );
+        const Cost Cost::infinity = Cost( -1, -1, -1 );
+
+        Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
+                if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
+                        EqvClass eqvClass;
+                        NamedTypeDecl *namedType;
 ///     std::cout << "type inst " << destAsTypeInst->get_name();
-    if( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
-      return conversionCost( src, eqvClass.type, indexer, env );
-    } else if( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
+                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
+                                return conversionCost( src, eqvClass.type, indexer, env );
+                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
 ///       std::cout << " found" << std::endl;
-      TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
-      // all typedefs should be gone by this point
-      assert( type );
-      if( type->get_base() ) {
-        return conversionCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
-      }
-    }
+                                TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
+                                // all typedefs should be gone by this point
+                                assert( type );
+                                if ( type->get_base() ) {
+                                        return conversionCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
+                                } // if
+                        } // if
 ///     std::cout << " not found" << std::endl;
-  }
+                } // if
 ///   std::cout << "src is ";
 ///   src->print( std::cout );
@@ -44 +48 @@
 ///   std::cout << std::endl << "env is" << std::endl;
 ///   env.print( std::cout, 8 );
-  if( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
+                if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
 ///     std::cout << "compatible!" << std::endl;
-    return Cost( 0, 0, 0 );
-  } else if( dynamic_cast< VoidType* >( dest ) ) {
-    return Cost( 0, 0, 1 );
-  } else {
-    ConversionCost converter( dest, indexer, env );
-    src->accept( converter );
-    if( converter.get_cost() == Cost::infinity ) {
-      return Cost::infinity;
-    } else {
-      return converter.get_cost() + Cost( 0, 0, 0 );
-    }
-  }
-}
-
-ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
-  : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env )
-{
-}
+                        return Cost( 0, 0, 0 );
+                } else if ( dynamic_cast< VoidType* >( dest ) ) {
+                        return Cost( 0, 0, 1 );
+                } else {
+                        ConversionCost converter( dest, indexer, env );
+                        src->accept( converter );
+                        if ( converter.get_cost() == Cost::infinity ) {
+                                return Cost::infinity;
+                        } else {
+                                return converter.get_cost() + Cost( 0, 0, 0 );
+                        } // if
+                } // if
+        }
+
+        ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
+                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ) {
+        }
 
 /*
-Old
-===
-                     Double
-                       |
-                     Float
-                       |