Changeset 083cf31

Timestamp:

Jan 7, 2016, 11:28:48 AM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

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, with_gc

Children:

1e9d87b

Parents:

267cb3d (diff), de91427b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

merge with master

Files:

• INSTALL (modified) (1 diff)
• configure (modified) (1 diff)
• configure.ac (modified) (1 diff)
• doc/refrat/refrat.tex (modified) (1 diff)
• src/CodeGen/CodeGenerator.cc (modified) (1 diff)
• src/CodeGen/CodeGenerator.h (modified) (1 diff)
• src/GenPoly/Box.cc (modified) (57 diffs)
• src/GenPoly/DeclMutator.cc (added)
• src/GenPoly/DeclMutator.h (added)
• src/GenPoly/FindFunction.h (modified) (1 diff)
• src/GenPoly/GenPoly.cc (modified) (4 diffs)
• src/GenPoly/GenPoly.h (modified) (1 diff)
• src/GenPoly/InstantiateGeneric.cc (modified) (10 diffs)
• src/GenPoly/Lvalue.cc (modified) (4 diffs)
• src/GenPoly/PolyMutator.h (modified) (2 diffs)
• src/GenPoly/ScrubTyVars.cc (modified) (2 diffs)
• src/GenPoly/ScrubTyVars.h (modified) (3 diffs)
• src/GenPoly/Specialize.cc (modified) (2 diffs)
• src/GenPoly/module.mk (modified) (1 diff)
• src/InitTweak/InitModel.h (modified) (1 diff)
• src/InitTweak/RemoveInit.cc (modified) (6 diffs)
• src/InitTweak/RemoveInit.h (modified) (2 diffs)
• src/Makefile.in (modified) (7 diffs)
• src/Parser/ExpressionNode.cc (modified) (1 diff)
• src/ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• src/ResolvExpr/AlternativeFinder.h (modified) (1 diff)
• src/SymTab/Indexer.cc (modified) (1 diff)
• src/SymTab/Indexer.h (modified) (1 diff)
• src/SymTab/Mangler.cc (modified) (5 diffs)
• src/SymTab/Mangler.h (modified) (3 diffs)
• src/SymTab/Validate.cc (modified) (5 diffs)
• src/SynTree/Declaration.cc (modified) (2 diffs)
• src/SynTree/Declaration.h (modified) (2 diffs)
• src/SynTree/Expression.cc (modified) (3 diffs)
• src/SynTree/Expression.h (modified) (23 diffs)
• src/SynTree/Mutator.cc (modified) (1 diff)
• src/SynTree/Mutator.h (modified) (1 diff)
• src/SynTree/PointerType.cc (modified) (2 diffs)
• src/SynTree/Statement.cc (modified) (2 diffs)
• src/SynTree/Statement.h (modified) (2 diffs)
• src/SynTree/SynTree.h (modified) (1 diff)
• src/SynTree/Type.cc (modified) (2 diffs)
• src/SynTree/Type.h (modified) (16 diffs)
• src/SynTree/Visitor.cc (modified) (1 diff)
• src/SynTree/Visitor.h (modified) (1 diff)
• src/Tuples/FlattenTuple.cc (modified) (1 diff)
• src/Tuples/FlattenTuple.h (modified) (1 diff)
• src/driver/Makefile.in (modified) (1 diff)
• src/examples/Makefile.in (modified) (1 diff)
• src/examples/fstream_test.c (modified) (2 diffs)
• src/examples/hello.c (modified) (2 diffs)
• src/examples/iostream.c (modified) (6 diffs)
• src/examples/iostream.h (modified) (4 diffs)
• src/examples/sum.c (modified) (5 diffs)
• src/examples/vector_test.c (modified) (3 diffs)
• src/libcfa/Makefile.am (modified) (2 diffs)
• src/libcfa/Makefile.in (modified) (2 diffs)
• src/main.cc (modified) (4 diffs)

INSTALL

@@ -19 +19 @@
   cfa-cc components.  Some components will be installed in /some/directory/bin,
   others in /some/directory/lib.  If unspecified, this defaults to /usr/local.
+  If you wish to use (a subdirectory of) your home directory, ${HOME}/some/dir 
+  works, but it is important not to put quotes around the directory path; 
+  Cforall may appear to build, but the installed version may not work properly.
 
 --with-backend-compiler=PROGRAM specifies the installed path of gcc.  It

configure

@@ -2999 +2999 @@
         cfa_incdir="${cfa_prefix}/include"
 else
-        cfa_incdir=${$includedir}
+        cfa_incdir=${includedir}
 fi
 

configure.ac

@@ -41 +41 @@
         cfa_incdir="${cfa_prefix}/include"
 else
-        cfa_incdir=${$includedir}
+        cfa_incdir=${includedir}
 fi 
 AC_DEFINE_UNQUOTED(CFA_INCDIR, "${cfa_incdir}", [Location of include files.])

doc/refrat/refrat.tex

@@ -112 +112 @@
 \lstset{
 language=CFA,
-columns=fullflexible,
+columns=flexible,
 basicstyle=\sf\small,
 tabsize=4,
 xleftmargin=\parindent,
 escapechar=@,
-%fancyvrb=true,
+keepspaces=true,
 %showtabs=true,
-keepspaces=true,
-showtabs=true,
-tab=,
+%tab=\rightarrowfill,
 }%
 

src/CodeGen/CodeGenerator.cc

@@ -446 +446 @@
                 output << ")";
         }
+
+        void CodeGenerator::visit( AlignofExpr *sizeofExpr ) {
+                // use GCC extension to avoid bumping std to C11
+                output << "__alignof__(";
+                if ( sizeofExpr->get_isType() ) {
+                        output << genType( sizeofExpr->get_type(), "" );
+                } else {
+                        sizeofExpr->get_expr()->accept( *this );
+                } // if
+                output << ")";
+        }
   
         void CodeGenerator::visit( LogicalExpr *logicalExpr ) {

src/CodeGen/CodeGenerator.h

@@ -60 +60 @@
                 virtual void visit( ConstantExpr *constantExpr ); 
                 virtual void visit( SizeofExpr *sizeofExpr );
+                virtual void visit( AlignofExpr *alignofExpr );
                 virtual void visit( LogicalExpr *logicalExpr );
                 virtual void visit( ConditionalExpr *conditionalExpr );

src/GenPoly/Box.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Box.cc -- 
+// Box.cc --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Wed Dec 02 11:52:37 2015
-// Update Count     : 201
+// Last Modified On : Fri Dec 18 14:53:08 2015
+// Update Count     : 217
 //
 
@@ -28 +28 @@
 #include "Parser/ParseNode.h"
 
+#include "SynTree/Constant.h"
 #include "SynTree/Type.h"
 #include "SynTree/Expression.h"
@@ -50 +51 @@
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
+                /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 : public PolyMutator {
                   public:
@@ -60 +62 @@
                         virtual Expression *mutate( CommaExpr *commaExpr );
                         virtual Expression *mutate( ConditionalExpr *condExpr );
-                        virtual Statement *mutate(ReturnStmt *catchStmt);
+                        virtual Statement * mutate( ReturnStmt *returnStmt );
                         virtual Type *mutate( PointerType *pointerType );
-                        virtual Type *mutate( FunctionType *pointerType );
-  
+                        virtual Type * mutate( FunctionType *functionType );
+
                         virtual void doBeginScope();
                         virtual void doEndScope();
@@ -88 +90 @@
                 };
 
+                /// Moves polymorphic returns in function types to pointer-type parameters, adds type size and assertion parameters to parameter lists as well
                 class Pass2 : public PolyMutator {
                   public:
-                        Pass2();
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
@@ -101 +103 @@
                   private:
                         void addAdapters( FunctionType *functionType );
-  
+
                         std::map< UniqueId, std::string > adapterName;
                 };
 
+                /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, and sizeof expressions of polymorphic types with the proper variable
                 class Pass3 : public PolyMutator {
                   public:
@@ -148 +151 @@
                         // the correct thing in some situations. It's not clear to me why this wasn't working.
 
-                        // if the return type or a parameter type involved polymorphic types, then the adapter will need 
-                        // to take those polymorphic types as pointers. Therefore, there can be two different functions 
+                        // if the return type or a parameter type involved polymorphic types, then the adapter will need
+                        // to take those polymorphic types as pointers. Therefore, there can be two different functions
                         // with the same mangled name, so we need to further mangle the names.
                         for ( std::list< DeclarationWithType *>::iterator retval = function->get_returnVals().begin(); retval != function->get_returnVals().end(); ++retval ) {
-                                if ( isPolyVal( (*retval)->get_type(), tyVars ) ) {
+                                if ( isPolyType( (*retval)->get_type(), tyVars ) ) {
                                         name << "P";
                                 } else {
@@ -161 +164 @@
                         std::list< DeclarationWithType *> &paramList = function->get_parameters();
                         for ( std::list< DeclarationWithType *>::iterator arg = paramList.begin(); arg != paramList.end(); ++arg ) {
-                                if ( isPolyVal( (*arg)->get_type(), tyVars ) ) {
+                                if ( isPolyType( (*arg)->get_type(), tyVars ) ) {
                                         name << "P";
                                 } else {
-                                        name << "M";                            
+                                        name << "M";
                                 }
                         } // for
@@ -178 +181 @@
                 }
 
-                Pass1::Pass1()
-                        : useRetval( false ), tempNamer( "_temp" ) {
+                Pass1::Pass1() : useRetval( false ), tempNamer( "_temp" ) {
                         adapters.push(AdapterMap());
                 }
@@ -191 +193 @@
                                                         if ( PointerType *pointer = dynamic_cast< PointerType *>( funType->get_parameters().front()->get_type() ) ) {
                                                                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( pointer->get_base() ) ) {
-                                                                        name = typeInst->get_name();
-                                                                        return true;
+                                                                        if ( TypeInstType *typeInst2 = dynamic_cast< TypeInstType *>( funType->get_parameters().back()->get_type() ) ) {
+                                                                                if ( typeInst->get_name() == typeInst2->get_name() ) {
+                                                                                        name = typeInst->get_name();
+                                                                                        return true;
+                                                                                } // if
+                                                                        } // if
                                                                 } // if
                                                         } // if
@@ -228 +234 @@
                                 if ( isPolyRet( functionDecl->get_functionType(), typeName ) && functionDecl->get_linkage() == LinkageSpec::Cforall ) {
                                         retval = functionDecl->get_functionType()->get_returnVals().front();
-  
+
                                         // give names to unnamed return values
                                         if ( retval->get_name() == "" ) {
@@ -235 +241 @@
                                         } // if
                                 } // if
-        
+
                                 FunctionType *functionType = functionDecl->get_functionType();
                                 makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
@@ -260 +266 @@
 
                                 functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
-  
+
                                 scopeTyVars = oldtyVars;
                                 assignOps = oldassignOps;
@@ -276 +282 @@
 
                 TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
-///     std::cerr << "add " << typeDecl->get_name() << "\n";
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
                         return Mutator::mutate( typeDecl );
@@ -302 +307 @@
 
                 void Pass1::passTypeVars( ApplicationExpr *appExpr, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
+                        // pass size/align for type variables
                         for ( TyVarMap::const_iterator tyParm = exprTyVars.begin(); tyParm != exprTyVars.end(); ++tyParm ) {
                                 ResolvExpr::EqvClass eqvClass;
@@ -310 +316 @@
                                                 arg = appExpr->get_args().insert( arg, new SizeofExpr( concrete->clone() ) );
                                                 arg++;
+                                                arg = appExpr->get_args().insert( arg, new AlignofExpr( concrete->clone() ) );
+                                                arg++;
                                         } else {
                                                 throw SemanticError( "unbound type variable in application ", appExpr );
@@ -315 +323 @@
                                 } // if
                         } // for
+
+                        // add size/align for generic types to parameter list
+                        //assert( ! appExpr->get_function()->get_results().empty() );
+                        if ( appExpr->get_function()->get_results().empty() ) return;
+                        FunctionType *funcType = getFunctionType( appExpr->get_function()->get_results().front() );
+                        assert( funcType );
+
+                        std::list< DeclarationWithType* >::const_iterator fnParm = funcType->get_parameters().begin();
+                        std::list< Expression* >::const_iterator fnArg = arg;
+                        std::set< std::string > seenTypes; //< names for generic types we've seen
+                        for ( ; fnParm != funcType->get_parameters().end() && fnArg != appExpr->get_args().end(); ++fnParm, ++fnArg ) {
+                                Type *parmType = (*fnParm)->get_type();
+                                if ( ! dynamic_cast< TypeInstType* >( parmType ) && isPolyType( parmType, exprTyVars ) ) {
+                                        std::string sizeName = sizeofName( parmType );
+                                        if ( seenTypes.count( sizeName ) ) continue;
+
+                                        assert( ! (*fnArg)->get_results().empty() );
+                                        Type *argType = (*fnArg)->get_results().front();
+                                        arg = appExpr->get_args().insert( arg, new SizeofExpr( argType->clone() ) );
+                                        arg++;
+                                        arg = appExpr->get_args().insert( arg, new AlignofExpr( argType->clone() ) );
+                                        arg++;
+
+                                        seenTypes.insert( sizeName );
+                                }
+                        }
                 }
 
@@ -323 +357 @@
                 }
 
-                TypeInstType *isPolyType( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars ) {
-                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
-                                if ( env ) {
-                                        if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
-                                                return isPolyType( newType, env, tyVars );
-                                        } // if
-                                } // if
-                                if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
-                                        return typeInst;
-                                } else {
-                                        return 0;
-                                } // if
-                        } else {
-                                return 0;
-                        } // if
-                }
-
                 Expression *Pass1::addRetParam( ApplicationExpr *appExpr, FunctionType *function, Type *retType, std::list< Expression *>::iterator &arg ) {
-                        if ( useRetval ) {
-                                assert( retval );
-                                arg = appExpr->get_args().insert( arg, new VariableExpr( retval ) );
-                                arg++;
-                        } else {
-                                ObjectDecl *newObj = makeTemporary( retType->clone() );
-                                Expression *paramExpr = new VariableExpr( newObj );
-                                if ( ! isPolyType( newObj->get_type(), env, scopeTyVars ) ) {
-                                        paramExpr = new AddressExpr( paramExpr );
-                                } // if
-                                arg = appExpr->get_args().insert( arg, paramExpr );
-                                arg++;
-///     stmtsToAdd.push_back( new ExprStmt( noLabels, appExpr ) );
-                                CommaExpr *commaExpr = new CommaExpr( appExpr, new VariableExpr( newObj ) );
-                                commaExpr->set_env( appExpr->get_env() );
-                                appExpr->set_env( 0 );
-                                return commaExpr;
-                        } // if
-                        return appExpr;
+                        // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous.
+                        // if ( useRetval ) {
+                        //      assert( retval );
+                        //      arg = appExpr->get_args().insert( arg, new VariableExpr( retval ) );
+                        //      arg++;
+                        // } else {
+
+                        // Create temporary to hold return value of polymorphic function and produce that temporary as a result
+                        // using a comma expression.  Possibly change comma expression into statement expression "{}" for multiple
+                        // return values.
+                        ObjectDecl *newObj = makeTemporary( retType->clone() );
+                        Expression *paramExpr = new VariableExpr( newObj );
+                        // If the type of the temporary is not polymorphic, box temporary by taking its address; otherwise the
+                        // temporary is already boxed and can be used directly.
+                        if ( ! isPolyType( newObj->get_type(), scopeTyVars, env ) ) {
+                                paramExpr = new AddressExpr( paramExpr );
+                        } // if
+                        arg = appExpr->get_args().insert( arg, paramExpr ); // add argument to function call
+                        arg++;
+                        // Build a comma expression to call the function and emulate a normal return.
+                        CommaExpr *commaExpr = new CommaExpr( appExpr, new VariableExpr( newObj ) );
+                        commaExpr->set_env( appExpr->get_env() );
+                        appExpr->set_env( 0 );
+                        return commaExpr;
+                        // } // if
+                        // return appExpr;
                 }
 
@@ -374 +398 @@
                 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() && isPolyType( function->get_returnVals().front()->get_type(), tyVars ) ) {
                                 ret = addRetParam( appExpr, function, function->get_returnVals().front()->get_type(), arg );
                         } // if
@@ -382 +406 @@
                         appExpr->get_args().push_front( appExpr->get_function() );
                         appExpr->set_function( new NameExpr( adapterName ) );
-  
+
                         return ret;
                 }
@@ -388 +412 @@
                 void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
                         assert( ! arg->get_results().empty() );
-///   if ( ! dynamic_cast< PointerType *>( arg->get_results().front() ) ) {
+//   if ( ! dynamic_cast< PointerType *>( arg->get_results().front() ) ) {
                         TypeInstType *typeInst = dynamic_cast< TypeInstType *>( param );
                         if ( typeInst && exprTyVars.find( typeInst->get_name() ) != exprTyVars.end() ) {
@@ -408 +432 @@
                                 } // if
                         } // if
-///   }
+//   }
                 }
 
@@ -425 +449 @@
 
                 void Pass1::boxParams( ApplicationExpr *appExpr, FunctionType *function, std::list< Expression *>::iterator &arg, const TyVarMap &exprTyVars ) {
-///   std::cout << "function is ";
-///   function->print( std::cout );
                         for ( std::list< DeclarationWithType *>::const_iterator param = function->get_parameters().begin(); param != function->get_parameters().end(); ++param, ++arg ) {
-///     std::cout << "parameter is ";
-///     (*param)->print( std::fcout );
-///     std::cout << std::endl << "argument is ";
-///     (*arg)->print( std::cout );
                                 assert( arg != appExpr->get_args().end() );
                                 addCast( *arg, (*param)->get_type(), exprTyVars );
@@ -466 +484 @@
                         // 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() && isPolyType( adapter->get_returnVals().front()->get_type(), tyVars ) ) {
                                 makeRetParm( adapter );
                         } // if
@@ -476 +494 @@
                         assert( param );
                         assert( arg );
-///   std::cout << "arg type is ";
-///   arg->get_type()->print( std::cout );
-///   std::cout << "param type is ";
-///   param->get_type()->print( std::cout );
-///   std::cout << " tyVars are: ";
-///   printTyVarMap( std::cout, tyVars );
-                        if ( isPolyVal( realParam->get_type(), tyVars ) ) {
-///     if ( dynamic_cast< PointerType *>( arg->get_type() ) ) {
-///       return new CastExpr( new VariableExpr( param ), arg->get_type()->clone() );
-///     } else {
+                        if ( isPolyType( realParam->get_type(), tyVars ) ) {
+//     if ( dynamic_cast< PointerType *>( arg->get_type() ) ) {
+//       return new CastExpr( new VariableExpr( param ), arg->get_type()->clone() );
+//     } else {
                                 if ( dynamic_cast<TypeInstType *>(arg->get_type()) == NULL ) {
                                         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
@@ -492 +504 @@
                                         return deref;
                                 } // if
-///     }
+//     }
                         } // if
                         return new VariableExpr( param );
@@ -517 +529 @@
                         ApplicationExpr *adapteeApp = new ApplicationExpr( new CastExpr( new VariableExpr( adapteeDecl ), new PointerType( Type::Qualifiers(), realType ) ) );
                         Statement *bodyStmt;
-  
+
                         std::list< TypeDecl *>::iterator tyArg = realType->get_forall().begin();
                         std::list< TypeDecl *>::iterator tyParam = adapterType->get_forall().begin();
@@ -531 +543 @@
                                 } // for
                         } // for
-  
+
                         std::list< DeclarationWithType *>::iterator arg = realType->get_parameters().begin();
                         std::list< DeclarationWithType *>::iterator param = adapterType->get_parameters().begin();
@@ -539 +551 @@
                                 addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
                                 bodyStmt = new ExprStmt( noLabels, adapteeApp );
-                        } else if ( isPolyVal( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
+                        } else if ( isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
                                 if ( (*param)->get_name() == "" ) {
                                         (*param)->set_name( "_ret" );
@@ -588 +600 @@
                                 if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
                                         adaptersDone.insert( adaptersDone.begin(), mangleName );
-                                        
+
                                         // apply substitution to type variables to figure out what the adapter's type should look like
                                         assert( env );
                                         env->apply( realFunction );
-                                        mangleName = SymTab::Mangler::mangle( realFunction ); 
+                                        mangleName = SymTab::Mangler::mangle( realFunction );
                                         mangleName += makePolyMonoSuffix( originalFunction, exprTyVars );
 
@@ -611 +623 @@
                 } // passAdapters
 
-                TypeInstType *isPolyPtr( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars ) {
-                        if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
-                                return isPolyType( ptr->get_base(), env, tyVars );
-                        } else if ( env ) {
-                                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
-                                        if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
-                                                return isPolyPtr( newType, env, tyVars );
-                                        } // if
-                                } // if
-                        } // if
-                        return 0;
-                }
-
-                TypeInstType *isPolyPtrPtr( Type *type, const TypeSubstitution *env, const TyVarMap &tyVars ) {
-                        if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
-                                return isPolyPtr( ptr->get_base(), env, tyVars );
-                        } else if ( env ) {
-                                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
-                                        if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
-                                                return isPolyPtrPtr( newType, env, tyVars );
-                                        } // if
-                                } // if
-                        } // if
-                        return 0;
-                }
-
-                Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, std::string polyName, bool isIncr ) {
+                Expression *makeIncrDecrExpr( ApplicationExpr *appExpr, Type *polyType, bool isIncr ) {
                         NameExpr *opExpr;
                         if ( isIncr ) {
@@ -650 +636 @@
                                 addAssign->get_args().push_back( appExpr->get_args().front() );
                         } // if
-                        addAssign->get_args().push_back( new NameExpr( polyName ) );
+                        addAssign->get_args().push_back( new NameExpr( sizeofName( polyType ) ) );
                         addAssign->get_results().front() = appExpr->get_results().front()->clone();
                         if ( appExpr->get_env() ) {
@@ -667 +653 @@
                                                 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 );  // the arguments cannot both be polymorphic pointers
+                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
+                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
+                                                assert( ! baseType1 || ! baseType2 ); // the arguments cannot both be polymorphic pointers
                                                 UntypedExpr *ret = 0;
-                                                if ( typeInst1 || typeInst2 ) { // one of the arguments is a polymorphic pointer
+                                                if ( baseType1 || baseType2 ) { // one of the arguments is a polymorphic pointer
                                                         ret = new UntypedExpr( new NameExpr( "?+?" ) );
                                                 } // if
-                                                if ( typeInst1 ) {
+                                                if ( baseType1 ) {
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().back() );
-                                                        multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
+                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) );
                                                         ret->get_args().push_back( appExpr->get_args().front() );
                                                         ret->get_args().push_back( multiply );
-                                                } else if ( typeInst2 ) {
+                                                } else if ( baseType2 ) {
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().front() );
-                                                        multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) );
+                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType2 ) ) );
                                                         ret->get_args().push_back( multiply );
                                                         ret->get_args().push_back( appExpr->get_args().back() );
                                                 } // if
-                                                if ( typeInst1 || typeInst2 ) {
+                                                if ( baseType1 || baseType2 ) {
                                                         ret->get_results().push_front( appExpr->get_results().front()->clone() );
                                                         if ( appExpr->get_env() ) {
@@ -700 +686 @@
                                                 assert( ! appExpr->get_results().empty() );
                                                 assert( ! appExpr->get_args().empty() );
-                                                if ( isPolyType( appExpr->get_results().front(), env, scopeTyVars ) ) {
+                                                if ( isPolyType( appExpr->get_results().front(), scopeTyVars, env ) ) {
                                                         Expression *ret = appExpr->get_args().front();
                                                         delete ret->get_results().front();
@@ -715 +701 @@
                                                 assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 1 );
-                                                if ( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
+                                                if ( Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env ) ) {
                                                         Type *tempType = appExpr->get_results().front()->clone();
                                                         if ( env ) {
@@ -729 +715 @@
                                                                 assignExpr->get_args().push_back( appExpr->get_args().front()->clone() );
                                                         } // if
-                                                        CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "?++" ) );
+                                                        CommaExpr *firstComma = new CommaExpr( assignExpr, makeIncrDecrExpr( appExpr, baseType, varExpr->get_var()->get_name() == "?++" ) );
                                                         return new CommaExpr( firstComma, tempExpr );
                                                 } // if
@@ -735 +721 @@
                                                 assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 1 );
-                                                if ( TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars ) ) {
-                                                        return makeIncrDecrExpr( appExpr, typeInst->get_name(), varExpr->get_var()->get_name() == "++?" );
+                                                if ( Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env ) ) {
+                                                        return makeIncrDecrExpr( appExpr, baseType, varExpr->get_var()->get_name() == "++?" );
                                                 } // if
                                         } else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
                                                 assert( ! appExpr->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 );
-                                                if ( typeInst1 && typeInst2 ) {
+                                                Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_results().front(), scopeTyVars, env );
+                                                Type *baseType2 = isPolyPtr( appExpr->get_args().back()->get_results().front(), scopeTyVars, env );
+                                                if ( baseType1 && baseType2 ) {
                                                         UntypedExpr *divide = new UntypedExpr( new NameExpr( "?/?" ) );
                                                         divide->get_args().push_back( appExpr );
-                                                        divide->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
+                                                        divide->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) );
                                                         divide->get_results().push_front( appExpr->get_results().front()->clone() );
                                                         if ( appExpr->get_env() ) {
@@ -753 +739 @@
                                                         } // if
                                                         return divide;
-                                                } else if ( typeInst1 ) {
+                                                } else if ( baseType1 ) {
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().back() );
-                                                        multiply->get_args().push_back( new NameExpr( typeInst1->get_name() ) );
+                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType1 ) ) );
                                                         appExpr->get_args().back() = multiply;
-                                                } else if ( typeInst2 ) {
+                                                } else if ( baseType2 ) {
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().front() );
-                                                        multiply->get_args().push_back( new NameExpr( typeInst2->get_name() ) );
+                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType2 ) ) );
                                                         appExpr->get_args().front() = multiply;
                                                 } // if
@@ -767 +753 @@
                                                 assert( ! appExpr->get_results().empty() );
                                                 assert( appExpr->get_args().size() == 2 );
-                                                TypeInstType *typeInst = isPolyPtr( appExpr->get_results().front(), env, scopeTyVars );
-                                                if ( typeInst ) {
+                                                Type *baseType = isPolyPtr( appExpr->get_results().front(), scopeTyVars, env );
+                                                if ( baseType ) {
                                                         UntypedExpr *multiply = new UntypedExpr( new NameExpr( "?*?" ) );
                                                         multiply->get_args().push_back( appExpr->get_args().back() );
-                                                        multiply->get_args().push_back( new NameExpr( typeInst->get_name() ) );
+                                                        multiply->get_args().push_back( new NameExpr( sizeofName( baseType ) ) );
                                                         appExpr->get_args().back() = multiply;
                                                 } // if
@@ -792 +778 @@
                         mutateAll( appExpr->get_args(), *this );
                         useRetval = oldUseRetval;
-  
+
                         assert( ! appExpr->get_function()->get_results().empty() );
                         PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
@@ -798 +784 @@
                         FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
                         assert( function );
-  
+
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
                                 return newExpr;
                         } // if
-  
+
                         Expression *ret = appExpr;
-  
+
                         std::list< Expression *>::iterator arg = appExpr->get_args().begin();
                         std::list< Expression *>::iterator paramBegin = appExpr->get_args().begin();
-  
+
                         std::string typeName;
                         if ( isPolyRet( function, typeName ) ) {
@@ -821 +807 @@
                         } // if
                         arg = appExpr->get_args().begin();
-  
+
                         TyVarMap exprTyVars;
                         makeTyVarMap( function, exprTyVars );
-  
+
                         passTypeVars( appExpr, arg, exprTyVars );
                         addInferredParams( appExpr, function, arg, exprTyVars );
 
                         arg = paramBegin;
-  
+
                         boxParams( appExpr, function, arg, exprTyVars );
 
@@ -838 +824 @@
 
                 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(), scopeTyVars, env ) ) {
                                 if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
                                         if ( name->get_name() == "*?" ) {
@@ -853 +839 @@
                 Expression *Pass1::mutate( AddressExpr *addrExpr ) {
                         assert( ! addrExpr->get_arg()->get_results().empty() );
+
+                        bool needs = false;
+                        if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
+                                if ( ! expr->get_results().empty() && isPolyType( expr->get_results().front(), scopeTyVars, env ) ) {
+                                        if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
+                                                if ( name->get_name() == "*?" ) {
+                                                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
+                                                                assert( ! appExpr->get_function()->get_results().empty() );
+                                                                PointerType *pointer = dynamic_cast< PointerType *>( appExpr->get_function()->get_results().front() );
+                                                                assert( pointer );
+                                                                FunctionType *function = dynamic_cast< FunctionType *>( pointer->get_base() );
+                                                                assert( function );
+                                                                needs = needsAdapter( function, scopeTyVars );
+                                                        } // if
+                                                } // if
+                                        } // if
+                                } // if
+                        } // if
                         addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
-                        if ( isPolyType( addrExpr->get_arg()->get_results().front(), env, scopeTyVars ) ) {
+                        if ( isPolyType( addrExpr->get_arg()->get_results().front(), scopeTyVars, env ) || needs ) {
                                 Expression *ret = addrExpr->get_arg();
                                 delete ret->get_results().front();
@@ -866 +870 @@
                 }
 
-                Statement * Pass1::mutate(ReturnStmt *retStmt) {
-                        // by this point, a cast expr on a polymorphic return value is redundant
-                        while ( CastExpr *castExpr = dynamic_cast< CastExpr *>( retStmt->get_expr() ) ) {
-                                retStmt->set_expr( castExpr->get_arg() );
-                                retStmt->get_expr()->set_env( castExpr->get_env() );
-                                castExpr->set_env( 0 );
-                                castExpr->set_arg( 0 );
-                                delete castExpr;
-                        }
-                        if ( retval && retStmt->get_expr() ) {
-                                assert( ! retStmt->get_expr()->get_results().empty() );
-                                if ( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
-///       retStmt->set_expr( mutateExpression( retStmt->get_expr() ) );
-                                        TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() );
-                                        assert( typeInst );
-                                        std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
-                                        if ( assignIter == assignOps.end() ) {
-                                                throw SemanticError( "Attempt to return dtype or ftype object in ", retStmt->get_expr() );
-                                        } // if
-                                        ApplicationExpr *assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) );
-                                        Expression *retParm = new NameExpr( retval->get_name() );
-                                        retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
-                                        assignExpr->get_args().push_back( retParm );
-                                        assignExpr->get_args().push_back( retStmt->get_expr() );
-                                        stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( assignExpr ) ) );
-                                } else {
-                                        useRetval = true;
-                                        stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( retStmt->get_expr() ) ) );
-                                        useRetval = false;
+                Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
+                        if ( retval && returnStmt->get_expr() ) {
+                                assert( ! returnStmt->get_expr()->get_results().empty() );
+                                // ***** Code Removal ***** After introducing a temporary variable for all return expressions, the following code appears superfluous.
+                                // if ( returnStmt->get_expr()->get_results().front()->get_isLvalue() ) {
+                                // by this point, a cast expr on a polymorphic return value is redundant
+                                while ( CastExpr *castExpr = dynamic_cast< CastExpr *>( returnStmt->get_expr() ) ) {
+                                        returnStmt->set_expr( castExpr->get_arg() );
+                                        returnStmt->get_expr()->set_env( castExpr->get_env() );
+                                        castExpr->set_env( 0 );
+                                        castExpr->set_arg( 0 );
+                                        delete castExpr;
+                                } //while
+                                TypeInstType *typeInst = dynamic_cast< TypeInstType *>( retval->get_type() );
+                                assert( typeInst );
+                                std::map< std::string, DeclarationWithType *>::const_iterator assignIter = assignOps.find( typeInst->get_name() );
+                                if ( assignIter == assignOps.end() ) {
+                                        throw SemanticError( "Attempt to return dtype or ftype object in ", returnStmt->get_expr() );
                                 } // if
-                                retStmt->set_expr( 0 );
+                                ApplicationExpr *assignExpr = new ApplicationExpr( new VariableExpr( assignIter->second ) );
+                                Expression *retParm = new NameExpr( retval->get_name() );
+                                retParm->get_results().push_back( new PointerType( Type::Qualifiers(), retval->get_type()->clone() ) );
+                                assignExpr->get_args().push_back( retParm );
+                                assignExpr->get_args().push_back( returnStmt->get_expr() );
+                                stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( assignExpr ) ) );
+                                // } else {
+                                //      useRetval = true;
+                                //      stmtsToAdd.push_back( new ExprStmt( noLabels, mutateExpression( returnStmt->get_expr() ) ) );
+                                //      useRetval = false;
+                                // } // if
+                                returnStmt->set_expr( 0 );
                         } else {
-                                retStmt->set_expr( mutateExpression( retStmt->get_expr() ) );
-                        } // if
-                        return retStmt;
+                                returnStmt->set_expr( mutateExpression( returnStmt->get_expr() ) );
+                        } // if
+                        return returnStmt;
                 }
 
@@ -906 +910 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
-  
+
                         Type *ret = Mutator::mutate( pointerType );
-  
+
                         scopeTyVars = oldtyVars;
                         return ret;
@@ -916 +920 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( functionType, scopeTyVars );
-  
+
                         Type *ret = Mutator::mutate( functionType );
-  
+
                         scopeTyVars = oldtyVars;
                         return ret;
@@ -933 +937 @@
 
 ////////////////////////////////////////// Pass2 ////////////////////////////////////////////////////
-
-                Pass2::Pass2() {}
 
                 void Pass2::addAdapters( FunctionType *functionType ) {
@@ -953 +955 @@
                                 }
                         }
-///  deleteAll( functions );
+//  deleteAll( functions );
                 }
 
@@ -987 +989 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
-  
+
                         Type *ret = Mutator::mutate( pointerType );
-  
+
                         scopeTyVars = oldtyVars;
                         return ret;
@@ -997 +999 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( funcType, scopeTyVars );
-  
+
+                        // move polymorphic return type to parameter list
                         std::string typeName;
                         if ( isPolyRet( funcType, typeName ) ) {
@@ -1005 +1008 @@
                                 funcType->get_returnVals().pop_front();
                         }
-  
+
+                        // add size/align and assertions for type parameters to parameter list
                         std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
                         std::list< DeclarationWithType *> inferredParams;
-                        ObjectDecl *newObj = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
-///   ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
+                        ObjectDecl newObj( "", DeclarationNode::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
+//   ObjectDecl *newFunPtr = new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) ), 0 );
                         for ( std::list< TypeDecl *>::const_iterator tyParm = funcType->get_forall().begin(); tyParm != funcType->get_forall().end(); ++tyParm ) {
-                                ObjectDecl *thisParm;
-                                // add all size parameters to parameter list
+                                ObjectDecl *sizeParm, *alignParm;
+                                // add all size and alignment parameters to parameter list
                                 if ( (*tyParm)->get_kind() == TypeDecl::Any ) {
-                                        thisParm = newObj->clone();
-                                        thisParm->set_name( (*tyParm)->get_name() );
-                                        last = funcType->get_parameters().insert( last, thisParm );
+                                        TypeInstType parmType( Type::Qualifiers(), (*tyParm)->get_name(), *tyParm );
+
+                                        sizeParm = newObj.clone();
+                                        sizeParm->set_name( sizeofName( &parmType ) );
+                                        last = funcType->get_parameters().insert( last, sizeParm );
+                                        ++last;
+
+                                        alignParm = newObj.clone();
+                                        alignParm->set_name( alignofName( &parmType ) );
+                                        last = funcType->get_parameters().insert( last, alignParm );
                                         ++last;
                                 }
                                 // move all assertions into parameter list
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
-///      *assert = (*assert)->acceptMutator( *this );
+//      *assert = (*assert)->acceptMutator( *this );
                                         inferredParams.push_back( *assert );
                                 }
                                 (*tyParm)->get_assertions().clear();
                         }
-                        delete newObj;
+
+                        // add size/align for generic types to parameter list
+                        std::set< std::string > seenTypes; //< sizeofName for generic types we've seen
+                        for ( std::list< DeclarationWithType* >::const_iterator fnParm = last; fnParm != funcType->get_parameters().end(); ++fnParm ) {
+                                Type *parmType = (*fnParm)->get_type();
+                                if ( ! dynamic_cast< TypeInstType* >( parmType ) && isPolyType( parmType, scopeTyVars ) ) {
+                                        std::string sizeName = sizeofName( parmType );
+                                        if ( seenTypes.count( sizeName ) ) continue;
+
+                                        ObjectDecl *sizeParm, *alignParm;
+                                        sizeParm = newObj.clone();
+                                        sizeParm->set_name( sizeName );
+                                        last = funcType->get_parameters().insert( last, sizeParm );
+                                        ++last;
+
+                                        alignParm = newObj.clone();
+                                        alignParm->set_name( alignofName( parmType ) );
+                                        last = funcType->get_parameters().insert( last, alignParm );
+                                        ++last;
+
+                                        seenTypes.insert( sizeName );
+                                }
+                        }
+
+                        // splice assertion parameters into parameter list
                         funcType->get_parameters().splice( last, inferredParams );
                         addAdapters( funcType );
                         mutateAll( funcType->get_returnVals(), *this );
                         mutateAll( funcType->get_parameters(), *this );
-  
+
                         scopeTyVars = oldtyVars;
                         return funcType;
@@ -1042 +1077 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( type, scopeTyVars );
-  
+
                         DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
                         ScrubTyVars::scrub( decl, scopeTyVars );
@@ -1063 +1098 @@
 
                 TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
-///   Initializer *init = 0;
-///   std::list< Expression *> designators;
-///   scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
-///   if ( typeDecl->get_base() ) {
-///     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
-///   }
-///   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
+//   Initializer *init = 0;
+//   std::list< Expression *> designators;
+//   scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
+//   if ( typeDecl->get_base() ) {
+//     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
+//   }
+//   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
 
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
@@ -1078 +1113 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
-  
+
                         Type *ret = Mutator::mutate( pointerType );
-  
+
                         scopeTyVars = oldtyVars;
                         return ret;
@@ -1088 +1123 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( functionType, scopeTyVars );
-  
+
                         Type *ret = Mutator::mutate( functionType );
-  
+
                         scopeTyVars = oldtyVars;
                         return ret;
@@ -1097 +1132 @@
                 Statement *Pass3::mutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
-                                if ( isPolyVal( objectDecl->get_type(), scopeTyVars ) ) {
+                                if ( isPolyType( objectDecl->get_type(), scopeTyVars ) ) {
                                         // change initialization of a polymorphic value object
                                         // to allocate storage with alloca
-                                        TypeInstType *typeInst = dynamic_cast< TypeInstType *>( objectDecl->get_type() );
-                                        assert( typeInst );
+                                        Type *declType = objectDecl->get_type();
                                         UntypedExpr *alloc = new UntypedExpr( new NameExpr( "__builtin_alloca" ) );
-                                        alloc->get_args().push_back( new NameExpr( typeInst->get_name() ) );
+                                        alloc->get_args().push_back( new NameExpr( sizeofName( declType ) ) );
 
                                         delete objectDecl->get_init();

src/GenPoly/FindFunction.h

@@ -23 +23 @@
         typedef bool (*FindFunctionPredicate)( FunctionType*, const TyVarMap& );
 
+        /// recursively walk `type`, placing all functions that match `predicate` under `tyVars` into `functions`
         void findFunction( Type *type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
+        /// like `findFunction`, but also replaces the function type with void ()(void)
         void findAndReplaceFunction( Type *&type, std::list< FunctionType* > &functions, const TyVarMap &tyVars, FindFunctionPredicate predicate );
 } // namespace GenPoly

src/GenPoly/GenPoly.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Rob Schluntz
-// Last Modified On : Tue Nov 24 15:23:08 2015
-// Update Count     : 11
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Dec 15 16:11:18 2015
+// Update Count     : 13
 //
 
 #include "GenPoly.h"
+
+#include "SymTab/Mangler.h"
+#include "SynTree/Expression.h"
 #include "SynTree/Type.h"
 
@@ -21 +24 @@
 
 namespace GenPoly {
-        // A function needs an adapter if it returns a polymorphic value or if any of its
-        // parameters have polymorphic type
         bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) {
-                if ( ! adaptee->get_returnVals().empty() && isPolyVal( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
+                if ( ! adaptee->get_returnVals().empty() && isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
                         return true;
                 } // if
                 for ( std::list< DeclarationWithType* >::const_iterator innerArg = adaptee->get_parameters().begin(); innerArg != adaptee->get_parameters().end(); ++innerArg ) {
-                        if ( isPolyVal( (*innerArg)->get_type(), tyVars ) ) {
+                        if ( isPolyType( (*innerArg)->get_type(), tyVars ) ) {
                                 return true;
                         } // if
@@ -66 +67 @@
         }
 
-        bool isPolyVal( Type *type, const TyVarMap &tyVars ) {
+        namespace {
+                /// Checks a parameter list for polymorphic parameters; will substitute according to env if present
+                bool hasPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
+                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
+                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                                assert(paramType && "Aggregate parameters should be type expressions");
+                                if ( isPolyType( paramType->get_type(), env ) ) return true;
+                        }
+                        return false;
+                }
+
+                /// Checks a parameter list for polymorphic parameters from tyVars; will substitute according to env if present
+                bool hasPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
+                        for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
+                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                                assert(paramType && "Aggregate parameters should be type expressions");
+                                if ( isPolyType( paramType->get_type(), tyVars, env ) ) return true;
+                        }
+                        return false;
+                }
+        }
+
+        Type *isPolyType( Type *type, const TypeSubstitution *env ) {
                 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
+                        if ( env ) {
+                                if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                        return isPolyType( newType, env );
+                                } // if
+                        } // if
+                        return type;
+                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->get_parameters(), env ) ) return type;
+                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->get_parameters(), env ) ) return type;
+                }
+                return 0;
+        }
+        
+        Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
+                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
+                        if ( env ) {
+                                if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                        return isPolyType( newType, tyVars, env );
+                                } // if
+                        } // if
                         if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
-                                return true;
+                                return type;
+                        }
+                } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->get_parameters(), tyVars, env ) ) return type;
+                } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->get_parameters(), tyVars, env ) ) return type;
+                }
+                return 0;
+        }
+
+        Type *isPolyPtr( Type *type, const TypeSubstitution *env ) {
+                if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
+                        return isPolyType( ptr->get_base(), env );
+                } else if ( env ) {
+                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
+                                if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                        return isPolyPtr( newType, env );
+                                } // if
                         } // if
                 } // if
-                return false;
+                return 0;
+        }
+        
+        Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
+                if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
+                        return isPolyType( ptr->get_base(), tyVars, env );
+                } else if ( env ) {
+                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType *>( type ) ) {
+                                if ( Type *newType = env->lookup( typeInst->get_name() ) ) {
+                                        return isPolyPtr( newType, tyVars, env );
+                                } // if
+                        } // if
+                } // if
+                return 0;
         }
 
-        bool isPolyObj( Type *type, const TyVarMap &tyVars ) {
-                if ( isPolyVal( type, tyVars ) ) {
-                        return true;
-                } else if ( PointerType *pt = dynamic_cast<PointerType*>( type ) ) {
-                        return isPolyObj( pt->get_base(), tyVars );
+        FunctionType * getFunctionType( Type *ty ) {
+                PointerType *ptrType;
+                if ( ( ptrType = dynamic_cast< PointerType* >( ty ) ) ) {
+                        return dynamic_cast< FunctionType* >( ptrType->get_base() ); // pointer if FunctionType, NULL otherwise
                 } else {
-                        return false;
+                        return dynamic_cast< FunctionType* >( ty ); // pointer if FunctionType, NULL otherwise
                 }
         }
@@ -91 +164 @@
                 os << std::endl;
         }
+
+        std::string sizeofName( Type *ty ) {
+                return std::string( "_sizeof_" ) + SymTab::Mangler::mangleType( ty );
+        }
+
+        std::string alignofName( Type *ty ) {
+                return std::string( "_alignof_" ) + SymTab::Mangler::mangleType( ty );
+        }
 } // namespace GenPoly
 

src/GenPoly/GenPoly.h

@@ -20 +20 @@
 #include <string>
 #include <iostream>
+
 #include "SynTree/Declaration.h"
+#include "SynTree/TypeSubstitution.h"
 
 namespace GenPoly {
         typedef std::map< std::string, TypeDecl::Kind > TyVarMap;
 
+        /// A function needs an adapter if it returns a polymorphic value or if any of its
+        /// parameters have polymorphic type
         bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVarr );
+
+        /// true iff function has polymorphic return type
         bool isPolyRet( FunctionType *function, std::string &name, const TyVarMap &otherTyVars );
         bool isPolyRet( FunctionType *function, std::string &name );
         bool isPolyRet( FunctionType *function, const TyVarMap &otherTyVars );
-//      bool isPolyFun( FunctionType *fun, const TyVarMap &tyVars );
-        bool isPolyVal( Type *type, const TyVarMap &tyVars );
 
-  // true if type variable or any number of pointers to type variable 
-  bool isPolyObj( Type *type, const TyVarMap &tyVars );
+        /// returns polymorphic type if is polymorphic type, NULL otherwise; will look up substitution in env if provided
+        Type *isPolyType( Type *type, const TypeSubstitution *env = 0 );
+        
+        /// returns polymorphic type if is polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
+        Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
+
+        /// returns polymorphic type if is pointer to polymorphic type, NULL otherwise; will look up substitution in env if provided
+        Type *isPolyPtr( Type *type, const TypeSubstitution *env = 0 );
+        
+        /// returns polymorphic type if is pointer to polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
+        Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
+
+        /// Returns a pointer to the base FunctionType if ty is the type of a function (or pointer to one), NULL otherwise
+        FunctionType * getFunctionType( Type *ty );
+
+        /// Prints type variable map
         void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap );
+
+        /// Gets the name of the sizeof parameter for the type
+        std::string sizeofName( Type *ty );
+
+        /// Gets the name of the alignof parameter for the type
+        std::string alignofName( Type *ty );
 } // namespace GenPoly
 

src/GenPoly/InstantiateGeneric.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// InstantiateGeneric.h --
+// InstantiateGeneric.cc --
 //
 // Author           : Aaron B. Moss
@@ -21 +21 @@
 
 #include "InstantiateGeneric.h"
-#include "PolyMutator.h"
+#include "DeclMutator.h"
 
 #include "ResolvExpr/typeops.h"
@@ -44 +44 @@
                 ConcreteType(const ConcreteType& that) : base(that.base), params() { cloneAll(that.params, params); }
 
-                /// Extracts types from a list of Expression* (which should be TypeExpr*)
-                ConcreteType(AggregateDecl *_base, const std::list< Expression* >& _params) : base(_base), params() {
-                        for ( std::list< Expression* >::const_iterator it = _params.begin(); it != _params.end(); ++it ) {
-                                TypeExpr *param = dynamic_cast< TypeExpr* >(*it);
-                                assert(param && "Aggregate parameters should be type expressions");
-                                params.push_back( param->get_type()->clone() );
+                /// Extracts types from a list of TypeExpr*
+                ConcreteType(AggregateDecl *_base, const std::list< TypeExpr* >& _params) : base(_base), params() {
+                        for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) {
+                                params.push_back( (*param)->get_type()->clone() );
                         }
                 }
@@ -66 +64 @@
 
                 bool operator== (const ConcreteType& that) const {
+                        if ( base != that.base ) return false;
+
                         SymTab::Indexer dummy;
-
-                        if ( base != that.base ) return false;
                         if ( params.size() != that.params.size() ) return false;
                         for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
@@ -79 +77 @@
                 std::list< Type* > params;  ///< Instantiation parameters
         };
-
+        
         /// Maps a concrete type to the instantiated struct type, accounting for scope
         class InstantiationMap {
-                /// Pair of concrete type and declaration that instantiates it
-                typedef std::pair< ConcreteType, AggregateDecl* > Instantiation;
+                /// Instantiation of a generic type, with key information to find it
+                struct Instantiation {
+                        ConcreteType key;     ///< Instantiation parameters for this type
+                        AggregateDecl *decl;  ///< Declaration of the instantiated generic type
+
+                        Instantiation() : key(), decl(0) {}
+                        Instantiation(const ConcreteType &_key, AggregateDecl *_decl) : key(_key), decl(_decl) {}
+                };
                 /// Map of generic types to instantiations of them
                 typedef std::map< AggregateDecl*, std::vector< Instantiation > > Scope;
@@ -107 +111 @@
                 /// Gets the declaration for the concrete instantiation of this type, assuming it has already been instantiated in the current scope.
                 /// Returns NULL on none such.
-                AggregateDecl* lookup( AggregateDecl *generic, std::list< Expression* >& params ) {
+                AggregateDecl* lookup( AggregateDecl *generic, const std::list< TypeExpr* >& params ) {
                         ConcreteType key(generic, params);
                         // scan scopes from innermost out
@@ -116 +120 @@
                                 // look through instantiations for matches to concrete type
                                 for ( std::vector< Instantiation >::const_iterator inst = insts->second.begin(); inst != insts->second.end(); ++inst ) {
-                                        if ( inst->first == key ) return inst->second;
+                                        if ( inst->key == key ) return inst->decl;
                                 }
                         }
@@ -123 +127 @@
                 }
         public:
-                StructDecl* lookup( StructInstType *inst ) { return (StructDecl*)lookup( inst->get_baseStruct(), inst->get_parameters() ); }
-                UnionDecl* lookup( UnionInstType *inst ) { return (UnionDecl*)lookup( inst->get_baseUnion(), inst->get_parameters() ); }
+                StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)lookup( inst->get_baseStruct(), typeSubs ); }
+                UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)lookup( inst->get_baseUnion(), typeSubs ); }
 
         private:
                 /// Adds a declaration for a concrete type to the current scope
-                void insert( AggregateDecl *generic, std::list< Expression* >& params, AggregateDecl *decl ) {
+                void insert( AggregateDecl *generic, const std::list< TypeExpr* > &params, AggregateDecl *decl ) {
                         ConcreteType key(generic, params);
-                        scopes.back()[generic].push_back( std::make_pair( key, decl ) );
+                        scopes.back()[generic].push_back( Instantiation( key, decl ) );
                 }
         public:
-                void insert( StructInstType *inst, StructDecl *decl ) { insert( inst->get_baseStruct(), inst->get_parameters(), decl ); }
-                void insert( UnionInstType *inst, UnionDecl *decl ) { insert( inst->get_baseUnion(), inst->get_parameters(), decl ); }
+                void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { insert( inst->get_baseStruct(), typeSubs, decl ); }
+                void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { insert( inst->get_baseUnion(), typeSubs, decl ); }
         };
 
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
-        class Instantiate : public PolyMutator {
+        class Instantiate : public DeclMutator {
+                /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap instantiations;
+                /// Namer for concrete types
                 UniqueName typeNamer;
 
         public:
-                Instantiate() : instantiations(), typeNamer("_conc_") {}
-
-                /// Mutates the whole translation unit, inserting new struct declarations as appropriate
-                void mutateAll( std::list< Declaration* >& translationUnit );
-                
+                Instantiate() : DeclMutator(), instantiations(), typeNamer("_conc_") {}
+
                 virtual Type* mutate( StructInstType *inst );
                 virtual Type* mutate( UnionInstType *inst );
+
+//              virtual Expression* mutate( MemberExpr *memberExpr );
                 
                 virtual void doBeginScope();
                 virtual void doEndScope();
-
-        private:
-                /// Adds a declaration to the current environment and the statements to add
-                void addDeclaration( AggregateDecl *decl ) {
-                        std::list< Label > nolabels;
-                        DeclStmt *stmt = new DeclStmt( nolabels, decl );
-                        PolyMutator::stmtsToAdd.push_back( stmt );
-                }
         };
         
         void instantiateGeneric( std::list< Declaration* >& translationUnit ) {
                 Instantiate instantiator;
-//              mutateAll( translationUnit, instantiator );
-                instantiator.mutateAll( translationUnit );
-        }
-
-        void Instantiate::mutateAll( std::list< Declaration* >& translationUnit ) {
-                // below copied and modified from Mutator.h:mutateAll()
-                SemanticError errors;
-                for ( std::list< Declaration* >::iterator decl = translationUnit.begin(); decl != translationUnit.end(); ++decl ) {
-                        try {
-                                if ( *decl ) {
-                                        *decl = dynamic_cast< Declaration* >( (*decl)->acceptMutator( *this ) );
-                                        assert( *decl );
-                                        // account for missing top-level declarations
-                                        for ( std::list< Statement* >::const_iterator stmt = PolyMutator::stmtsToAdd.begin(); stmt != PolyMutator::stmtsToAdd.end(); ++stmt ) {
-                                                DeclStmt *declStmt = dynamic_cast< DeclStmt* >( *stmt );
-                                                assert( declStmt );
-                                                translationUnit.insert( decl, declStmt->get_decl() );
-                                        }
-                                        PolyMutator::stmtsToAdd.clear();
-                                } // if
-                        } catch( SemanticError &e ) {
-                                errors.append( e );
-                        } // try
-                } // for
-                if ( ! errors.isEmpty() ) {
-                        throw errors;
-                } // if
-        }
-
-        /// Substitutes types of members of in according to baseParams => params, appending the result to out
-        void substituteMembers( const std::list< Declaration* >& in,
-                                                        const std::list< TypeDecl * >& baseParams, const std::list< Expression* >& params,
+                instantiator.mutateDeclarationList( translationUnit );
+        }
+
+        /// Makes substitutions of params into baseParams; returns true if all parameters substituted for a concrete type
+        bool makeSubstitutions( const std::list< TypeDecl* >& baseParams, const std::list< Expression* >& params, std::list< TypeExpr* >& out ) {
+                bool allConcrete = true;  // will finish the substitution list even if they're not all concrete
+
+                // substitute concrete types for given parameters, and incomplete types for placeholders
+                std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin();
+                std::list< Expression* >::const_iterator param = params.begin();
+                for ( ; baseParam != baseParams.end() && param != params.end(); ++baseParam, ++param ) {
+//                      switch ( (*baseParam)->get_kind() ) {
+//                      case TypeDecl::Any: {   // any type is a valid substitution here; complete types can be used to instantiate generics
+                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                                assert(paramType && "Aggregate parameters should be type expressions");
+                                out.push_back( paramType->clone() );
+                                // check that the substituted type isn't a type variable itself
+                                if ( dynamic_cast< TypeInstType* >( paramType->get_type() ) ) {
+                                        allConcrete = false;
+                                }
+//                              break;
+//                      }
+//                      case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
+//                              out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
+//                              break;
+//                      case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
+//                              out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
+//                              break;
+//                      }
+                }
+
+                // if any parameters left over, not done
+                if ( baseParam != baseParams.end() ) return false;
+//              // if not enough parameters given, substitute remaining incomplete types for placeholders
+//              for ( ; baseParam != baseParams.end(); ++baseParam ) {
+//                      switch ( (*baseParam)->get_kind() ) {
+//                      case TypeDecl::Any:    // no more substitutions here, fail early
+//                              return false;
+//                      case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
+//                              out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
+//                              break;
+//                      case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
+//                              out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
+//                              break;
+//                      }
+//              }
+
+                return allConcrete;
+        }
+
+        /// Substitutes types of members of in according to baseParams => typeSubs, appending the result to out
+        void substituteMembers( const std::list< Declaration* >& in, const std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs, 
                                                     std::list< Declaration* >& out ) {
                 // substitute types into new members
-                TypeSubstitution subs( baseParams.begin(), baseParams.end(), params.begin() );
+                TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
                 for ( std::list< Declaration* >::const_iterator member = in.begin(); member != in.end(); ++member ) {
                         Declaration *newMember = (*member)->clone();
@@ -215 +232 @@
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
+                assert( inst->get_baseParameters() && "Base struct has parameters" );
+
+                // check if type can be concretely instantiated; put substitutions into typeSubs
+                std::list< TypeExpr* > typeSubs;
+                if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) {
+                        deleteAll( typeSubs );
+                        return inst;
+                }
                 
                 // make concrete instantiation of generic type
-                StructDecl *concDecl = instantiations.lookup( inst );
+                StructDecl *concDecl = instantiations.lookup( inst, typeSubs );
                 if ( ! concDecl ) {
-                        assert( inst->get_baseParameters() && "Base struct has parameters" );
                         // set concDecl to new type, insert type declaration into statements to add
                         concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) );
-                        substituteMembers( inst->get_baseStruct()->get_members(),
-                                                                *inst->get_baseParameters(), inst->get_parameters(),
-                                                                concDecl->get_members() );
-                        addDeclaration( concDecl );
-                        instantiations.insert( inst, concDecl );
+                        substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs,        concDecl->get_members() );
+                        DeclMutator::addDeclaration( concDecl );
+                        instantiations.insert( inst, typeSubs, concDecl );
                 }
                 StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() );
                 newInst->set_baseStruct( concDecl );
+
+                deleteAll( typeSubs );
                 delete inst;
                 return newInst;
@@ -242 +266 @@
                 // exit early if no need for further mutation
                 if ( inst->get_parameters().empty() ) return inst;
-
+                assert( inst->get_baseParameters() && "Base union has parameters" );
+
+                // check if type can be concretely instantiated; put substitutions into typeSubs
+                std::list< TypeExpr* > typeSubs;
+                if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) {
+                        deleteAll( typeSubs );
+                        return inst;
+                }
+                
                 // make concrete instantiation of generic type
-                UnionDecl *concDecl = instantiations.lookup( inst );
+                UnionDecl *concDecl = instantiations.lookup( inst, typeSubs );
                 if ( ! concDecl ) {
                         // set concDecl to new type, insert type declaration into statements to add
-                        assert( inst->get_baseParameters() && "Base union has parameters" );
                         concDecl = new UnionDecl( typeNamer.newName( inst->get_name() ) );
-                        substituteMembers( inst->get_baseUnion()->get_members(),
-                                                                *inst->get_baseParameters(), inst->get_parameters(),
-                                                                concDecl->get_members() );
-                        addDeclaration( concDecl );
-                        instantiations.insert( inst, concDecl );
+                        substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
+                        DeclMutator::addDeclaration( concDecl );
+                        instantiations.insert( inst, typeSubs, concDecl );
                 }
                 UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() );
                 newInst->set_baseUnion( concDecl );
+
+                deleteAll( typeSubs );
                 delete inst;
                 return newInst;
         }
+
+//      /// Gets the base struct or union declaration for a member expression; NULL if not applicable
+//      AggregateDecl* getMemberBaseDecl( MemberExpr *memberExpr ) {
+//              // get variable for member aggregate
+//              VariableExpr *varExpr = dynamic_cast< VariableExpr* >( memberExpr->get_aggregate() );
+//              if ( ! varExpr ) return NULL;
+// 
+//              // get object for variable
+//              ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( varExpr->get_var() );
+//              if ( ! objectDecl ) return NULL;
+// 
+//              // get base declaration from object type
+//              Type *objectType = objectDecl->get_type();
+//              StructInstType *structType = dynamic_cast< StructInstType* >( objectType );
+//              if ( structType ) return structType->get_baseStruct();
+//              UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType );
+//              if ( unionType ) return unionType->get_baseUnion();
+// 
+//              return NULL;
+//      }
+// 
+//      /// Finds the declaration with the given name, returning decls.end() if none such
+//      std::list< Declaration* >::const_iterator findDeclNamed( const std::list< Declaration* > &decls, const std::string &name ) {
+//              for( std::list< Declaration* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
+//                      if ( (*decl)->get_name() == name ) return decl;
+//              }
+//              return decls.end();
+//      }
+//      
+//      Expression* Instantiate::mutate( MemberExpr *memberExpr ) {
+//              // mutate, exiting early if no longer MemberExpr
+//              Expression *expr = Mutator::mutate( memberExpr );
+//              memberExpr = dynamic_cast< MemberExpr* >( expr );
+//              if ( ! memberExpr ) return expr;
+// 
+//              // get declaration of member and base declaration of member, exiting early if not found
+//              AggregateDecl *memberBase = getMemberBaseDecl( memberExpr );
+//              if ( ! memberBase ) return memberExpr;
+//              DeclarationWithType *memberDecl = memberExpr->get_member();
+//              std::list< Declaration* >::const_iterator baseIt = findDeclNamed( memberBase->get_members(), memberDecl->get_name() );
+//              if ( baseIt == memberBase->get_members().end() ) return memberExpr;
+//              DeclarationWithType *baseDecl = dynamic_cast< DeclarationWithType* >( *baseIt );
+//              if ( ! baseDecl ) return memberExpr;
+// 
+//              // check if stated type of the member is not the type of the member's declaration; if so, need a cast
+//              // this *SHOULD* be safe, I don't think anything but the void-replacements I put in for dtypes would make it past the typechecker
+//              SymTab::Indexer dummy;
+//              if ( ResolvExpr::typesCompatible( memberDecl->get_type(), baseDecl->get_type(), dummy ) ) return memberExpr;
+//              else return new CastExpr( memberExpr, memberDecl->get_type() );
+//      }
         
         void Instantiate::doBeginScope() {
-                // push a new concrete type scope
+                DeclMutator::doBeginScope();
                 instantiations.beginScope();
         }
 
         void Instantiate::doEndScope() {
-                // pop the last concrete type scope
+                DeclMutator::doEndScope();
                 instantiations.endScope();
         }

src/GenPoly/Lvalue.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 19 07:41:33 2015
-// Update Count     : 1
+// Last Modified On : Tue Dec 15 15:33:13 2015
+// Update Count     : 3
 //
 
@@ -35 +35 @@
                 const std::list<Label> noLabels;
 
+                /// Replace uses of lvalue returns with appropriate pointers
                 class Pass1 : public Mutator {
                   public:
@@ -46 +47 @@
                 };
 
+                /// Replace declarations of lvalue returns with appropriate pointers
                 class Pass2 : public Visitor {
                   public:
@@ -120 +122 @@
                         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() );
-                                        castExpr->set_env( 0 );
-                                        castExpr->set_arg( 0 );
-                                        delete castExpr;
-                                } // while
                                 if ( retStmt->get_expr()->get_results().front()->get_isLvalue() ) {
+                                        // ***** Code Removal ***** because casts may be stripped already
+
+                                        // strip casts because not allowed to take address of cast
+                                        // while ( CastExpr *castExpr = dynamic_cast< CastExpr* >( retStmt->get_expr() ) ) {
+                                        //      retStmt->set_expr( castExpr->get_arg() );
+                                        //      retStmt->get_expr()->set_env( castExpr->get_env() );
+                                        //      castExpr->set_env( 0 );
+                                        //      castExpr->set_arg( 0 );
+                                        //      delete castExpr;
+                                        // } // while
                                         retStmt->set_expr( new AddressExpr( retStmt->get_expr()->acceptMutator( *this ) ) );
                                 } else {

src/GenPoly/PolyMutator.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Fri Aug 14 15:27:38 2015
-// Update Count     : 4
+// Last Modified On : Tue Dec 08 15:19:05 2015
+// Update Count     : 5
 //
 
@@ -51 +51 @@
                 virtual void doBeginScope() {}
                 virtual void doEndScope() {}
+                
+                static void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
           protected:
                 void mutateStatementList( std::list< Statement* > &statements );
                 Statement* mutateStatement( Statement *stmt );
                 Expression* mutateExpression( Expression *expr );
-                static void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
   
                 TyVarMap scopeTyVars;

src/GenPoly/ScrubTyVars.cc

@@ -13 +13 @@
 // Update Count     : 2
 //
+
+#include <sstream>
+#include <string>
 
 #include "GenPoly.h"
@@ -42 +45 @@
 
         Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) {
-                // sizeof( T ) => T parameter, which is the size of T
-                if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( szeof->get_type() ) ) {
-                        Expression *expr = new NameExpr( typeInst->get_name() );
+                // sizeof( T ) => _sizeof_T parameter, which is the size of T
+                if ( Type *polyType = isPolyType( szeof->get_type() ) ) {
+                        Expression *expr = new NameExpr( sizeofName( polyType ) );
                         return expr;
                 } else {
                         return Mutator::mutate( szeof );
+                } // if
+        }
+
+        Expression * ScrubTyVars::mutate( AlignofExpr *algnof ) {
+                // alignof( T ) => _alignof_T parameter, which is the alignment of T
+                if ( Type *polyType = isPolyType( algnof->get_type() ) ) {
+                        Expression *expr = new NameExpr( alignofName( polyType ) );
+                        return expr;
+                } else {
+                        return Mutator::mutate( algnof );
                 } // if
         }

src/GenPoly/ScrubTyVars.h

@@ -17 +17 @@
 #define _SCRUBTYVARS_H
 
+#include <string>
+
 #include "GenPoly.h"
 
@@ -26 +28 @@
           public:
                 ScrubTyVars( bool doAll, const TyVarMap &tyVars ): doAll( doAll ), tyVars( tyVars ) {}
-  
+
+                /// Like scrub( SynTreeClass* ), but only applies to type variables in `tyVars`
                 template< typename SynTreeClass >
                 static SynTreeClass *scrub( SynTreeClass *target, const TyVarMap &tyVars );
+                /// Replaces dtypes and ftypes with the appropriate void type, and sizeof expressions of polymorphic types with the proper variable
                 template< typename SynTreeClass >
                 static SynTreeClass *scrub( SynTreeClass *target );
@@ -34 +38 @@
                 virtual Type* mutate( TypeInstType *typeInst );
                 Expression* mutate( SizeofExpr *szeof );
+                Expression* mutate( AlignofExpr *algnof );
                 virtual Type* mutate( PointerType *pointer );
           private:

src/GenPoly/Specialize.cc

@@ -17 +17 @@
 
 #include "Specialize.h"
+#include "GenPoly.h"
 #include "PolyMutator.h"
 
@@ -87 +88 @@
         }
 
-        /// Returns a pointer to the base FunctionType if ty is the type of a function (or pointer to one), NULL otherwise
-        FunctionType * getFunctionType( Type *ty ) {
-                PointerType *ptrType;
-                if ( ( ptrType = dynamic_cast< PointerType* >( ty ) ) ) {
-                        return dynamic_cast< FunctionType* >( ptrType->get_base() ); // pointer if FunctionType, NULL otherwise
-                } else {
-                        return dynamic_cast< FunctionType* >( ty ); // pointer if FunctionType, NULL otherwise
-                }
-        }
-
         /// Generates a thunk that calls `actual` with type `funType` and returns its address
         Expression * Specialize::createThunkFunction( FunctionType *funType, Expression *actual, InferredParams *inferParams ) {

src/GenPoly/module.mk

@@ -23 +23 @@
        GenPoly/CopyParams.cc \
        GenPoly/FindFunction.cc \
-       GenPoly/InstantiateGeneric.cc
+       GenPoly/InstantiateGeneric.cc \
+       GenPoly/DeclMutator.cc

src/InitTweak/InitModel.h

@@ -72 +72 @@
                         void visit( ConstantExpr * );
                         void visit( SizeofExpr * ) { throw 0; }
+                        void visit( AlignofExpr * ) { throw 0; }
                         void visit( AttrExpr * ) { throw 0; }
                         void visit( LogicalExpr * ) { throw 0; }

src/InitTweak/RemoveInit.cc

@@ -7 +7 @@
 // RemoveInit.cc -- 
 //
-// Author           : Rodolfo G. Esteves
+// Author           : Rob Schluntz
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 19 16:39:32 2015
-// Update Count     : 1
+// Last Modified On : Tue Dec 15 15:37:26 2015
+// Update Count     : 15
 //
 
@@ -26 +26 @@
                 const std::list<Label> noLabels;
         }
+        
+        class RemoveInit : public Mutator {
+          public:
+                RemoveInit();
+                virtual ObjectDecl * mutate(ObjectDecl *objDecl);
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
+
+                virtual Statement * mutate( ReturnStmt * returnStmt );
+                
+                virtual CompoundStmt * mutate(CompoundStmt * compoundStmt);
+                
+          protected:
+                std::list< Statement* > stmtsToAddBefore;
+                std::list< Statement* > stmtsToAddAfter;
+                void mutateStatementList( std::list< Statement* > &statements );
+
+                std::list<DeclarationWithType*> returnVals;
+                UniqueName tempNamer;
+                std::string funcName;
+        };
 
         void tweak( std::list< Declaration * > translationUnit ) {
@@ -32 +52 @@
         }
 
+        RemoveInit::RemoveInit() : tempNamer( "_retVal" ) {}
+        
         void RemoveInit::mutateStatementList( std::list< Statement* > &statements ) {
                 for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
@@ -38 +60 @@
                         } // if
                         *i = (*i)->acceptMutator( *this );
+                        if ( ! stmtsToAddBefore.empty() ) {
+                                statements.splice( i, stmtsToAddBefore );
+                        } // if
                 } // for
                 if ( ! stmtsToAddAfter.empty() ) {
@@ -49 +74 @@
         }
 
-// in the case where an object has an initializer and a polymorphic type, insert an assignment
-// immediately after the declaration. This will (seemingly) cause the later phases to do the right
-// thing with the assignment
+        // in the case where an object has an initializer and a polymorphic type, insert an assignment immediately after the
+        // declaration. This will (seemingly) cause the later phases to do the right thing with the assignment
         ObjectDecl *RemoveInit::mutate( ObjectDecl *objDecl ) {
                 if (objDecl->get_init() && dynamic_cast<TypeInstType*>(objDecl->get_type())) {
@@ -63 +87 @@
                 return objDecl;
         }
+
+        Statement *RemoveInit::mutate( ReturnStmt *returnStmt ) {
+                // update for multiple return values
+                assert( returnVals.size() == 0 || returnVals.size() == 1 );
+                // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address
+                // is being returned
+                if ( returnStmt->get_expr() && returnVals.size() == 1 && funcName != "?=?" && ! returnVals.front()->get_type()->get_isLvalue()  ) {
+                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, returnVals.front()->get_type()->clone(), 0 );
+                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+                        
+                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+                        assign->get_args().push_back( new AddressExpr (new NameExpr( newObj->get_name() ) ) );
+                        assign->get_args().push_back( returnStmt->get_expr() );
+                        stmtsToAddBefore.push_back(new ExprStmt(noLabels, assign));
+
+                        returnStmt->set_expr( new VariableExpr( newObj ) );
+                } // if
+                return returnStmt;
+        }
+
+        DeclarationWithType* RemoveInit::mutate( FunctionDecl *functionDecl ) {
+                std::list<DeclarationWithType*> oldReturnVals = returnVals;
+                std::string oldFuncName = funcName;
+                
+                FunctionType * type = functionDecl->get_functionType();
+                returnVals = type->get_returnVals();
+                funcName = functionDecl->get_name();
+                DeclarationWithType * decl = Mutator::mutate( functionDecl );
+                returnVals = oldReturnVals;
+                funcName = oldFuncName;
+                return decl;
+        }
 } // namespace InitTweak
 

src/InitTweak/RemoveInit.h

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue May 19 16:40:11 2015
-// Update Count     : 1
+// Last Modified On : Fri Nov 27 17:00:47 2015
+// Update Count     : 2
 //
 
@@ -27 +27 @@
         /// Adds assignment statements for polymorphic type initializers
         void tweak( std::list< Declaration * > translationUnit );
-
-        class RemoveInit : public Mutator {
-          public:
-                // RemoveInit();
-                virtual ObjectDecl *mutate(ObjectDecl *objDecl);
-                virtual CompoundStmt *mutate(CompoundStmt *compoundStmt);
-          protected:
-                std::list< Statement* > stmtsToAddAfter;
-                void mutateStatementList( std::list< Statement* > &statements );
-        };
 } // namespace 
 

src/Makefile.in

@@ -122 +122 @@
         GenPoly/cfa_cpp-FindFunction.$(OBJEXT) \
         GenPoly/cfa_cpp-InstantiateGeneric.$(OBJEXT) \
+        GenPoly/cfa_cpp-DeclMutator.$(OBJEXT) \
         InitTweak/cfa_cpp-InitModel.$(OBJEXT) \
         InitTweak/cfa_cpp-InitExpander.$(OBJEXT) \
@@ -348 +349 @@
         GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
         GenPoly/CopyParams.cc GenPoly/FindFunction.cc \
-        GenPoly/InstantiateGeneric.cc InitTweak/InitModel.cc \
-        InitTweak/InitExpander.cc InitTweak/Mutate.cc \
-        InitTweak/Association.cc InitTweak/RemoveInit.cc \
-        Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \
-        Parser/ParseNode.cc Parser/DeclarationNode.cc \
-        Parser/ExpressionNode.cc Parser/StatementNode.cc \
-        Parser/InitializerNode.cc Parser/TypeData.cc \
-        Parser/LinkageSpec.cc Parser/parseutility.cc Parser/Parser.cc \
+        GenPoly/InstantiateGeneric.cc GenPoly/DeclMutator.cc \
+        InitTweak/InitModel.cc InitTweak/InitExpander.cc \
+        InitTweak/Mutate.cc InitTweak/Association.cc \
+        InitTweak/RemoveInit.cc Parser/parser.yy Parser/lex.ll \
+        Parser/TypedefTable.cc Parser/ParseNode.cc \
+        Parser/DeclarationNode.cc Parser/ExpressionNode.cc \
+        Parser/StatementNode.cc Parser/InitializerNode.cc \
+        Parser/TypeData.cc Parser/LinkageSpec.cc \
+        Parser/parseutility.cc Parser/Parser.cc \
         ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \
         ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \
@@ -411 +413 @@
           esac; \
         done; \
-        echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/Makefile'; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/Makefile'; \
         $(am__cd) $(top_srcdir) && \
-          $(AUTOMAKE) --gnu src/Makefile
+          $(AUTOMAKE) --foreign src/Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@@ -556 +558 @@
         GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/cfa_cpp-InstantiateGeneric.$(OBJEXT): GenPoly/$(am__dirstamp) \
+        GenPoly/$(DEPDIR)/$(am__dirstamp)
+GenPoly/cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
 InitTweak/$(am__dirstamp):
@@ -785 +789 @@
         -rm -f GenPoly/cfa_cpp-Box.$(OBJEXT)
         -rm -f GenPoly/cfa_cpp-CopyParams.$(OBJEXT)
+        -rm -f GenPoly/cfa_cpp-DeclMutator.$(OBJEXT)
         -rm -f GenPoly/cfa_cpp-FindFunction.$(OBJEXT)
         -rm -f GenPoly/cfa_cpp-GenPoly.$(OBJEXT)
@@ -895 +900 @@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/cfa_cpp-Box.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/cfa_cpp-CopyParams.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/cfa_cpp-DeclMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/cfa_cpp-FindFunction.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/cfa_cpp-GenPoly.Po@am__quote@
@@ -1376 +1382 @@
 @am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/cfa_cpp-InstantiateGeneric.obj `if test -f 'GenPoly/InstantiateGeneric.cc'; then $(CYGPATH_W) 'GenPoly/InstantiateGeneric.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/InstantiateGeneric.cc'; fi`
 
+GenPoly/cfa_cpp-DeclMutator.o: GenPoly/DeclMutator.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/cfa_cpp-DeclMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/cfa_cpp-DeclMutator.Tpo -c -o GenPoly/cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
+@am__fastdepCXX_TRUE@   $(am__mv) GenPoly/$(DEPDIR)/cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/cfa_cpp-DeclMutator.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='GenPoly/DeclMutator.cc' object='GenPoly/cfa_cpp-DeclMutator.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
+
+GenPoly/cfa_cpp-DeclMutator.obj: GenPoly/DeclMutator.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/cfa_cpp-DeclMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/cfa_cpp-DeclMutator.Tpo -c -o GenPoly/cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
+@am__fastdepCXX_TRUE@   $(am__mv) GenPoly/$(DEPDIR)/cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/cfa_cpp-DeclMutator.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='GenPoly/DeclMutator.cc' object='GenPoly/cfa_cpp-DeclMutator.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
+
 InitTweak/cfa_cpp-InitModel.o: InitTweak/InitModel.cc
 @am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT InitTweak/cfa_cpp-InitModel.o -MD -MP -MF InitTweak/$(DEPDIR)/cfa_cpp-InitModel.Tpo -c -o InitTweak/cfa_cpp-InitModel.o `test -f 'InitTweak/InitModel.cc' || echo '$(srcdir)/'`InitTweak/InitModel.cc

src/Parser/ExpressionNode.cc

@@ -586 +586 @@
                 }
           case OperatorNode::AlignOf:
+                {
+                        if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
+                                return new AlignofExpr( arg->get_decl()->buildType());
+                        } else {
+                                return new AlignofExpr( args.front());
+                        } // if
+                }
           case OperatorNode::SizeOf:
                 {
-///     bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf );
-
                         if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
                                 return new SizeofExpr( arg->get_decl()->buildType());

src/ResolvExpr/AlternativeFinder.cc

@@ -792 +792 @@
         }
 
+        void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
+                if ( alignofExpr->get_isType() ) {
+                        alternatives.push_back( Alternative( alignofExpr->clone(), env, Cost::zero ) );
+                } else {
+                        // find all alternatives for the argument to sizeof
+                        AlternativeFinder finder( indexer, env );
+                        finder.find( alignofExpr->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 alignof operand: ", alignofExpr->get_expr() );
+                        } // if
+                        // return the lowest cost alternative for the argument
+                        Alternative &choice = winners.front();
+                        alternatives.push_back( Alternative( new AlignofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
+                } // if
+        }
+
         void AlternativeFinder::resolveAttr( DeclarationWithType *funcDecl, FunctionType *function, Type *argType, const TypeEnvironment &env ) {
                 // assume no polymorphism

src/ResolvExpr/AlternativeFinder.h

@@ -56 +56 @@
                 virtual void visit( ConstantExpr *constantExpr ); 
                 virtual void visit( SizeofExpr *sizeofExpr );
+                virtual void visit( AlignofExpr *sizeofExpr );
                 virtual void visit( AttrExpr *attrExpr );
                 virtual void visit( LogicalExpr *logicalExpr );

src/SymTab/Indexer.cc

@@ -215 +215 @@
                 } else {
                         maybeAccept( sizeofExpr->get_expr(), *this );
+                }
+        }
+
+        void Indexer::visit( AlignofExpr *alignofExpr ) {
+                acceptAllNewScope( alignofExpr->get_results(), *this );
+                if ( alignofExpr->get_isType() ) {
+                        maybeAccept( alignofExpr->get_type(), *this );
+                } else {
+                        maybeAccept( alignofExpr->get_expr(), *this );
                 }
         }

src/SymTab/Indexer.h

@@ -54 +54 @@
                 virtual void visit( ConstantExpr *constantExpr ); 
                 virtual void visit( SizeofExpr *sizeofExpr );
+                virtual void visit( AlignofExpr *alignofExpr );
                 virtual void visit( AttrExpr *attrExpr );
                 virtual void visit( LogicalExpr *logicalExpr );

src/SymTab/Mangler.cc

@@ -30 +30 @@
 
 namespace SymTab {
-        Mangler::Mangler( bool mangleOverridable ) : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ) {
-        }
-
-//Mangler::Mangler( const Mangler & )
-//  : mangleName(), varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( isTopLevel )
-//{
-//}
+        std::string Mangler::mangleType( Type *ty ) {
+                Mangler mangler( false, true );
+                maybeAccept( ty, mangler );
+                return mangler.get_mangleName();
+        }
+        
+        Mangler::Mangler( bool mangleOverridable, bool typeMode )
+                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ) {}
+                
         Mangler::Mangler( const Mangler &rhs ) : mangleName() {
                 varNums = rhs.varNums;
@@ -42 +44 @@
                 isTopLevel = rhs.isTopLevel;
                 mangleOverridable = rhs.mangleOverridable;
+                typeMode = rhs.typeMode;
         }
 
@@ -152 +155 @@
         void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
                 printQualifiers( refType );
+
                 mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
         }
 
+        void Mangler::mangleGenericRef( ReferenceToType *refType, std::string prefix ) {
+                printQualifiers( refType );
+
+                std::ostringstream oldName( mangleName.str() );
+                mangleName.clear();
+
+                mangleName << prefix << refType->get_name();
+
+                std::list< Expression* >& params = refType->get_parameters();
+                if ( ! params.empty() ) {
+                        mangleName << "_";
+                        for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
+                                TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
+                                assert(paramType && "Aggregate parameters should be type expressions");
+                                maybeAccept( paramType->get_type(), *this );
+                        }
+                        mangleName << "_";
+                }
+
+                oldName << mangleName.str().length() << mangleName.str();
+                mangleName.str( oldName.str() );
+        }
+
         void Mangler::visit( StructInstType *aggregateUseType ) {
-                mangleRef( aggregateUseType, "s" );
+                if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
+                else mangleRef( aggregateUseType, "s" );
         }
 
         void Mangler::visit( UnionInstType *aggregateUseType ) {
-                mangleRef( aggregateUseType, "u" );
+                if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
+                else mangleRef( aggregateUseType, "u" );
         }
 
@@ -209 +238 @@
 
         void Mangler::printQualifiers( Type *type ) {
+                // skip if not including qualifiers
+                if ( typeMode ) return;
+                
                 if ( ! type->get_forall().empty() ) {
                         std::list< std::string > assertionNames;
@@ -227 +259 @@
                                 varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
-                                        Mangler sub_mangler( mangleOverridable );
+                                        Mangler sub_mangler( mangleOverridable, typeMode );
                                         sub_mangler.nextVarNum = nextVarNum;
                                         sub_mangler.isTopLevel = false;

src/SymTab/Mangler.h

@@ -22 +22 @@
 
 namespace SymTab {
+        /// Mangles names to a unique C identifier
         class Mangler : public Visitor {
           public:
+                /// Mangle syntax tree object; primary interface to clients
                 template< typename SynTreeClass >
-            static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true ); // interface to clients
+            static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true );
+                /// Mangle a type name; secondary interface
+                static std::string mangleType( Type* ty );
 
-///   using Visitor::visit;
                 virtual void visit( ObjectDecl *declaration );
                 virtual void visit( FunctionDecl *declaration );
@@ -45 +48 @@
                 std::string get_mangleName() { return mangleName.str(); }
           private:
-                std::ostringstream mangleName;
+                std::ostringstream mangleName;  ///< Mangled name being constructed
                 typedef std::map< std::string, std::pair< int, int > > VarMapType;
-                VarMapType varNums;
-                int nextVarNum;
-                bool isTopLevel;
-                bool mangleOverridable;
+                VarMapType varNums;             ///< Map of type variables to indices
+                int nextVarNum;                 ///< Next type variable index
+                bool isTopLevel;                ///< Is the Mangler at the top level
+                bool mangleOverridable;         ///< Specially mangle overridable built-in methods
+                bool typeMode;                  ///< Produce a unique mangled name for a type
   
-                Mangler( bool mangleOverridable );
+                Mangler( bool mangleOverridable, bool typeMode );
                 Mangler( const Mangler & );
   
                 void mangleDecl( DeclarationWithType *declaration );
                 void mangleRef( ReferenceToType *refType, std::string prefix );
+                void mangleGenericRef( ReferenceToType *refType, std::string prefix );
   
                 void printQualifiers( Type *type );
@@ -63 +68 @@
         template< typename SynTreeClass >
         std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable ) {
-                Mangler mangler( mangleOverridable );
+                Mangler mangler( mangleOverridable, false );
                 maybeAccept( decl, mangler );
                 return mangler.get_mangleName();

src/SymTab/Validate.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Fri Dec 18 14:32:59 2015
-// Update Count     : 268
+// Last Modified On : Thu Jan 07 11:27:49 2016
+// Update Count     : 269
 //
 
@@ -86 +86 @@
         };
 
-        /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers
+        /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
         class Pass1 : public Visitor {
                 typedef Visitor Parent;
@@ -161 +161 @@
         };
 
+        class ReturnChecker : public Visitor {
+          public:
+                /// Checks that return statements return nothing if their return type is void
+                /// and return something if the return type is non-void.
+                static void checkFunctionReturns( std::list< Declaration * > & translationUnit );
+
+          private:
+                virtual void visit( FunctionDecl * functionDecl );
+
+                virtual void visit( ReturnStmt * returnStmt );
+
+                std::list< DeclarationWithType * > returnVals;
+        };
+
         class EliminateTypedef : public Mutator {
           public:
-          EliminateTypedef() : scopeLevel( 0 ) {}
-            /// Replaces typedefs by forward declarations
+                EliminateTypedef() : scopeLevel( 0 ) {}
+                /// Replaces typedefs by forward declarations
                 static void eliminateTypedef( std::list< Declaration * > &translationUnit );
           private:
@@ -209 +223 @@
                 acceptAll( translationUnit, pass1 );
                 acceptAll( translationUnit, pass2 );
+                ReturnChecker::checkFunctionReturns( translationUnit );
                 AutogenerateRoutines::autogenerateRoutines( translationUnit );
                 acceptAll( translationUnit, pass3 );
@@ -850 +865 @@
         }
 
+        void ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) {
+                ReturnChecker checker;
+                acceptAll( translationUnit, checker );
+        }
+
+        void ReturnChecker::visit( FunctionDecl * functionDecl ) {
+                std::list< DeclarationWithType * > oldReturnVals = returnVals;
+                returnVals = functionDecl->get_functionType()->get_returnVals();
+                Visitor::visit( functionDecl );
+                returnVals = oldReturnVals;
+        }
+
+        void ReturnChecker::visit( ReturnStmt * returnStmt ) {
+                if ( returnStmt->get_expr() == NULL && returnVals.size() != 0 ) {
+                        throw SemanticError( "Non-void function returns no values: " , returnStmt );
+                } else if ( returnStmt->get_expr() != NULL && returnVals.size() == 0 ) {
+                        throw SemanticError( "void function returns values: " , returnStmt );
+                }
+        }
+
+
         bool isTypedef( Declaration *decl ) {
                 return dynamic_cast< TypedefDecl * >( decl );

src/SynTree/Declaration.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jul 13 17:58:38 2015
-// Update Count     : 10
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Dec 09 14:08:29 2015
+// Update Count     : 12
 //
 
@@ -55 +55 @@
 }
 
+std::ostream & operator<<( std::ostream & out, Declaration * decl ) {
+        decl->print( out );
+        return out;
+}
+
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Declaration.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jul 13 18:15:59 2015
-// Update Count     : 28
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Dec 09 14:08:22 2015
+// Update Count     : 32
 //
 
@@ -259 +259 @@
 };
 
+std::ostream & operator<<( std::ostream & out, Declaration * decl );
+
 #endif // DECLARATION_H
 

src/SynTree/Expression.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Wed Sep 02 12:07:10 2015
-// Update Count     : 33
+// Last Modified On : Wed Dec 09 14:10:29 2015
+// Update Count     : 34
 //
 
@@ -122 +122 @@
 void SizeofExpr::print( std::ostream &os, int indent) const {
         os << std::string( indent, ' ' ) << "Sizeof Expression on: ";
+
+        if (isType)
+                type->print(os, indent + 2);
+        else
+                expr->print(os, indent + 2);
+
+        os << std::endl;
+        Expression::print( os, indent );
+}
+
+AlignofExpr::AlignofExpr( Expression *expr_, Expression *_aname ) :
+                Expression( _aname ), expr(expr_), type(0), isType(false) {
+        add_result( new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ) );
+}
+
+AlignofExpr::AlignofExpr( Type *type_, Expression *_aname ) :
+                Expression( _aname ), expr(0), type(type_), isType(true) {
+        add_result( new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ) );
+}
+
+AlignofExpr::AlignofExpr( const AlignofExpr &other ) :
+        Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
+}
+
+AlignofExpr::~AlignofExpr() {
+        delete expr;
+        delete type;
+}
+
+void AlignofExpr::print( std::ostream &os, int indent) const {
+        os << std::string( indent, ' ' ) << "Alignof Expression on: ";
 
         if (isType)
@@ -345 +376 @@
 }
 
+std::ostream & operator<<( std::ostream & out, Expression * expr ) {
+        expr->print( out );
+        return out;
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Expression.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 24 13:49:28 2015
-// Update Count     : 18
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Dec 09 14:10:21 2015
+// Update Count     : 19
 //
 
@@ -23 +23 @@
 #include "Constant.h"
 
+/// Expression is the root type for all expressions
 class Expression {
   public:
@@ -47 +48 @@
 };
 
-// ParamEntry contains the i.d. of a declaration and a type that is derived from that declaration,
-// but subject to decay-to-pointer and type parameter renaming
-
+/// ParamEntry contains the i.d. of a declaration and a type that is derived from that declaration,
+/// but subject to decay-to-pointer and type parameter renaming
 struct ParamEntry {
         ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ) {}
@@ -65 +65 @@
 typedef std::map< UniqueId, ParamEntry > InferredParams;
 
-// ApplicationExpr represents the application of a function to a set of parameters.  This is the
-// result of running an UntypedExpr through the expression analyzer.
-
+/// ApplicationExpr represents the application of a function to a set of parameters.  This is the
+/// result of running an UntypedExpr through the expression analyzer.
 class ApplicationExpr : public Expression {
   public:
@@ -89 +88 @@
 };
 
-// UntypedExpr represents the application of a function to a set of parameters, but where the
-// particular overload for the function name has not yet been determined.  Most operators are
-// converted into functional form automatically, to permit operator overloading.
-
+/// UntypedExpr represents the application of a function to a set of parameters, but where the
+/// particular overload for the function name has not yet been determined.  Most operators are
+/// converted into functional form automatically, to permit operator overloading.
 class UntypedExpr : public Expression {
   public:
@@ -118 +116 @@
 };
 
-// this class contains a name whose meaning is still not determined
+/// NameExpr contains a name whose meaning is still not determined
 class NameExpr : public Expression {
   public:
@@ -139 +137 @@
 // function-call format.
 
-// AddressExpr represents a address-of expression, e.g. &e
+/// AddressExpr represents a address-of expression, e.g. &e
 class AddressExpr : public Expression {
   public:
@@ -174 +172 @@
 };
 
-// CastExpr represents a type cast expression, e.g. (int)e
+/// CastExpr represents a type cast expression, e.g. (int)e
 class CastExpr : public Expression {
   public:
@@ -193 +191 @@
 };
 
-// UntypedMemberExpr represents a member selection operation, e.g. q.p before processing by the expression analyzer
+/// UntypedMemberExpr represents a member selection operation, e.g. q.p before processing by the expression analyzer
 class UntypedMemberExpr : public Expression {
   public:
@@ -214 +212 @@
 };
 
-// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
+/// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
 class MemberExpr : public Expression {
   public:
@@ -235 +233 @@
 };
 
-// VariableExpr represents an expression that simply refers to the value of a named variable
+/// VariableExpr represents an expression that simply refers to the value of a named variable
 class VariableExpr : public Expression {
   public:
@@ -253 +251 @@
 };
 
-// ConstantExpr represents an expression that simply refers to the value of a constant 
+/// ConstantExpr represents an expression that simply refers to the value of a constant 
 class ConstantExpr : public Expression {
   public:
@@ -271 +269 @@
 };
 
-// SizeofExpr represents a sizeof expression (could be sizeof(int) or sizeof 3+4)
+/// SizeofExpr represents a sizeof expression (could be sizeof(int) or sizeof 3+4)
 class SizeofExpr : public Expression {
   public:
@@ -296 +294 @@
 };
 
-// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
+/// AlignofExpr represents an alignof expression
+class AlignofExpr : public Expression {
+  public:
+        AlignofExpr( Expression *expr, Expression *_aname = 0 );
+        AlignofExpr( const AlignofExpr &other );
+        AlignofExpr( Type *type, Expression *_aname = 0 );
+        virtual ~AlignofExpr();
+
+        Expression *get_expr() const { return expr; }
+        void set_expr( Expression *newValue ) { expr = newValue; }
+        Type *get_type() const { return type; }
+        void set_type( Type *newValue ) { type = newValue; }
+        bool get_isType() const { return isType; }
+        void set_isType( bool newValue ) { isType = newValue; }
+
+        virtual AlignofExpr *clone() const { return new AlignofExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *expr;
+        Type *type;
+        bool isType;
+};
+
+/// AttrExpr represents an @attribute expression (like sizeof, but user-defined)
 class AttrExpr : public Expression {
   public:
@@ -324 +347 @@
 };
 
-// LogicalExpr represents a short-circuit boolean expression (&& or ||)
+/// LogicalExpr represents a short-circuit boolean expression (&& or ||)
 class LogicalExpr : public Expression {
   public:
@@ -347 +370 @@
 };
 
-// ConditionalExpr represents the three-argument conditional ( p ? a : b )
+/// ConditionalExpr represents the three-argument conditional ( p ? a : b )
 class ConditionalExpr : public Expression {
   public:
@@ -371 +394 @@
 };
 
-// CommaExpr represents the sequence operator ( a, b )
+/// CommaExpr represents the sequence operator ( a, b )
 class CommaExpr : public Expression {
   public:
@@ -392 +415 @@
 };
 
-// TupleExpr represents a tuple expression ( [a, b, c] )
+/// TupleExpr represents a tuple expression ( [a, b, c] )
 class TupleExpr : public Expression {
   public:
@@ -410 +433 @@
 };
 
-// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
+/// SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
 class SolvedTupleExpr : public Expression {
   public:
@@ -428 +451 @@
 };
 
-// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
+/// TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
 class TypeExpr : public Expression {
   public:
@@ -446 +469 @@
 };
 
-// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
+/// AsmExpr represents a GCC 'asm constraint operand' used in an asm statement: [output] "=f" (result)
 class AsmExpr : public Expression {
   public:
@@ -472 +495 @@
 };
 
-// ValofExpr represents a GCC 'lambda expression'
+/// ValofExpr represents a GCC 'lambda expression'
 class UntypedValofExpr : public Expression {
   public:
@@ -488 +511 @@
         Statement *body;
 };
+
+std::ostream & operator<<( std::ostream & out, Expression * expr );
 
 #endif // EXPRESSION_H

src/SynTree/Mutator.cc

@@ -251 +251 @@
 }
 
+Expression *Mutator::mutate( AlignofExpr *alignofExpr ) {
+        mutateAll( alignofExpr->get_results(), *this );
+        if ( alignofExpr->get_isType() ) {
+                alignofExpr->set_type( maybeMutate( alignofExpr->get_type(), *this ) );
+        } else {
+                alignofExpr->set_expr( maybeMutate( alignofExpr->get_expr(), *this ) );
+        }
+        return alignofExpr;
+}
+
 Expression *Mutator::mutate( AttrExpr *attrExpr ) {
         mutateAll( attrExpr->get_results(), *this );

src/SynTree/Mutator.h

@@ -64 +64 @@
         virtual Expression* mutate( ConstantExpr *constantExpr ); 
         virtual Expression* mutate( SizeofExpr *sizeofExpr );
+        virtual Expression* mutate( AlignofExpr *alignofExpr );
         virtual Expression* mutate( AttrExpr *attrExpr );
         virtual Expression* mutate( LogicalExpr *logicalExpr );

src/SynTree/PointerType.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon May 18 10:15:16 2015
-// Update Count     : 2
+// Last Modified On : Tue Dec 15 15:39:10 2015
+// Update Count     : 5
 //
 
@@ -20 +20 @@
 PointerType::PointerType( const Type::Qualifiers &tq, Type *base )
         : Type( tq ), base( base ), dimension( 0 ), isVarLen( false ), isStatic( false ) {
-        base->set_isLvalue( false );
 }
 
 PointerType::PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic )
         : Type( tq ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
-        base->set_isLvalue( false );
 }
 

src/SynTree/Statement.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 25 12:19:50 2015
-// Update Count     : 53
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Dec 09 14:09:34 2015
+// Update Count     : 54
 //
 
@@ -337 +337 @@
 }
 
+std::ostream & operator<<( std::ostream & out, Statement * statement ) {
+        statement->print( out );
+        return out;
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Statement.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 25 18:25:37 2015
-// Update Count     : 44
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Dec 09 14:09:24 2015
+// Update Count     : 46
 //
 
@@ -396 +396 @@
 };
 
+std::ostream & operator<<( std::ostream & out, Statement * statement );
+
 #endif // STATEMENT_H
 

src/SynTree/SynTree.h

@@ -69 +69 @@
 class ConstantExpr;
 class SizeofExpr;
+class AlignofExpr;
 class AttrExpr;
 class LogicalExpr;

src/SynTree/Type.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jul  9 16:45:13 2015
-// Update Count     : 3
+// Last Modified By : Rob Schluntz
+// Last Modified On : Wed Dec 09 14:08:48 2015
+// Update Count     : 4
 //
 
@@ -80 +80 @@
 }
 
+std::ostream & operator<<( std::ostream & out, Type * type ) {
+        type->print( out );
+        return out;
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Type.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Type.h -- 
+// Type.h --
 //
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Nov 20 12:54:09 2015
-// Update Count     : 15
+// Last Modified By : Rob Schluntz
+// Last Modified On : Fri Dec 18 14:46:18 2015
+// Update Count     : 18
 //
 
@@ -23 +23 @@
 class Type {
   public:
-        struct Qualifiers {  
+        struct Qualifiers {
                 Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isAttribute( false ) {}
                 Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isAttribute ): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isAttribute( isAttribute ) {}
-        
+
                 Qualifiers &operator+=( const Qualifiers &other );
                 Qualifiers &operator-=( const Qualifiers &other );
@@ -36 +36 @@
                 bool operator<( const Qualifiers &other );
                 bool operator>( const Qualifiers &other );
-        
+
                 bool isConst;
                 bool isVolatile;
@@ -43 +43 @@
                 bool isAtomic;
                 bool isAttribute;
-        };      
+        };
 
         Type( const Qualifiers &tq );
@@ -85 +85 @@
 class BasicType : public Type {
   public:
-        enum Kind {  
+        enum Kind {
                 Bool,
                 Char,
@@ -108 +108 @@
                 LongDoubleImaginary,
                 NUMBER_OF_BASIC_TYPES
-        };  
+        };
 
         static const char *typeNames[];                                         // string names for basic types, MUST MATCH with Kind
@@ -149 +149 @@
   private:
         Type *base;
-        
+
         // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
         Expression *dimension;
@@ -188 +188 @@
         virtual ~FunctionType();
 
-        std::list<DeclarationWithType*>& get_returnVals() { return returnVals; }
-        std::list<DeclarationWithType*>& get_parameters() { return parameters; }
+        std::list<DeclarationWithType*> & get_returnVals() { return returnVals; }
+        std::list<DeclarationWithType*> & get_parameters() { return parameters; }
         bool get_isVarArgs() { return isVarArgs; }
         void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
@@ -217 +217 @@
         void set_name( std::string newValue ) { name = newValue; }
         std::list< Expression* >& get_parameters() { return parameters; }
-        
+
         virtual ReferenceToType *clone() const = 0;
         virtual void accept( Visitor &v ) = 0;
@@ -240 +240 @@
         /// Accesses generic parameters of base struct (NULL if none such)
         std::list<TypeDecl*> * get_baseParameters();
-        
+
         /// Looks up the members of this struct named "name" and places them into "foundDecls".
         /// Clones declarations into "foundDecls", caller responsible for freeing
@@ -250 +250 @@
   private:
         virtual std::string typeString() const;
-        
+
         // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
         // where the structure used in this type is actually defined
@@ -267 +267 @@
         /// Accesses generic parameters of base union (NULL if none such)
         std::list<TypeDecl*> * get_baseParameters();
-        
+
         /// looks up the members of this union named "name" and places them into "foundDecls"
         /// Clones declarations into "foundDecls", caller responsible for freeing
@@ -277 +277 @@
   private:
         virtual std::string typeString() const;
-        
+
         // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
         // where the union used in this type is actually defined
@@ -310 +310 @@
   private:
         virtual std::string typeString() const;
-        
+
         // this member is filled in by the validate pass, which instantiates the members of the correponding
         // aggregate with the actual type parameters specified for this use of the context
@@ -327 +327 @@
         bool get_isFtype() const { return isFtype; }
         void set_isFtype( bool newValue ) { isFtype = newValue; }
-        
+
         virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
         virtual void accept( Visitor &v ) { v.visit( this ); }
@@ -463 +463 @@
 }
 
+std::ostream & operator<<( std::ostream & out, Type * type );
+
 #endif // TYPE_H
 

src/SynTree/Visitor.cc

@@ -210 +210 @@
 }
 
+void Visitor::visit( AlignofExpr *alignofExpr ) {
+        acceptAll( alignofExpr->get_results(), *this );
+        if ( alignofExpr->get_isType() ) {
+                maybeAccept( alignofExpr->get_type(), *this );
+        } else {
+                maybeAccept( alignofExpr->get_expr(), *this );
+        }
+}
+
 void Visitor::visit( AttrExpr *attrExpr ) {
         acceptAll( attrExpr->get_results(), *this );

src/SynTree/Visitor.h

@@ -64 +64 @@
         virtual void visit( ConstantExpr *constantExpr ); 
         virtual void visit( SizeofExpr *sizeofExpr );
+        virtual void visit( AlignofExpr *alignofExpr );
         virtual void visit( AttrExpr *attrExpr );
         virtual void visit( LogicalExpr *logicalExpr );

src/Tuples/FlattenTuple.cc

@@ -46 +46 @@
         void FlattenTuple::CollectArgs::visit( ConstantExpr      *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( SizeofExpr        *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
+        void FlattenTuple::CollectArgs::visit( AlignofExpr       *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( AttrExpr          *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }
         void FlattenTuple::CollectArgs::visit( LogicalExpr       *expr )  {  currentArgs.insert( currentArgs.end(), expr );  }

src/Tuples/FlattenTuple.h

@@ -42 +42 @@
                         virtual void visit( ConstantExpr * ); 
                         virtual void visit( SizeofExpr * );
+                        virtual void visit( AlignofExpr * );
                         virtual void visit( AttrExpr * );
                         virtual void visit( LogicalExpr * );

src/driver/Makefile.in

@@ -195 +195 @@
           esac; \
         done; \
-        echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/driver/Makefile'; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/driver/Makefile'; \
         $(am__cd) $(top_srcdir) && \
-          $(AUTOMAKE) --gnu src/driver/Makefile
+          $(AUTOMAKE) --foreign src/driver/Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status

src/examples/Makefile.in

@@ -191 +191 @@
           esac; \
         done; \
-        echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/examples/Makefile'; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/examples/Makefile'; \
         $(am__cd) $(top_srcdir) && \
-          $(AUTOMAKE) --gnu src/examples/Makefile
+          $(AUTOMAKE) --foreign src/examples/Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status

src/examples/fstream_test.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed May 27 18:13:43 2015
-// Update Count     : 2
+// Last Modified On : Mon Nov 23 14:43:32 2015
+// Update Count     : 40
 //
 
@@ -20 +20 @@
         ifstream *sin = ifstream_stdin();
         int nombre;
-        sout << "Appuyez un nombre, s'il vous plâit:\n";
-        sin >> &nombre;
-        sout << "Vous avez appuyé: " << nombre << "\n";
+        sout | "Entrez un nombre, s'il vous plaît:\n";
+        sin  | &nombre;
+        sout | "Vous avez entré " | nombre | " stocké à l'adresse " | &nombre | endl;
+        sout | "nombre " | nombre | " est "
+                 | (nombre > 0 ? "plus grand que" :
+                   nombre == 0 ? "égal à" : "moins de")
+                 | " zéro" | endl;
+
+        sout | "Entrez trois nombres, s'il vous plaît:\n";
+        int i, j, k;
+        sin  | &i | &j | &k;
+        sout | "Vous avez entré " | "i:" | i | " j:" | j | " k:" | k | endl;
+
+        sout | 3 | ' ' | 3.5 | ' ' | 'a' | ' ' | "abc" | endl;
 }
 

src/examples/hello.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Nov 20 16:02:50 2015
-// Update Count     : 3
+// Last Modified On : Sun Nov 22 17:40:37 2015
+// Update Count     : 5
 //
 
@@ -19 +19 @@
         ofstream *sout = ofstream_stdout();
         ifstream *sin = ifstream_stdin();
-        sout << "Bonjour au monde!\n";
-        sout << 3 << " " << 3.5 << " " << 'a' << " " << "abc" << "\n";
-        int i, j, k;
-        sin >> &i >> &j >> &k;
-        sout << "i:" << i << " j:" << j << " k:" << k << "\n";
+        sout | "Bonjour au monde!\n";
 }
 

src/examples/iostream.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Nov 20 13:19:19 2015
-// Update Count     : 9
+// Last Modified On : Mon Dec  7 23:08:02 2015
+// Update Count     : 24
 //
 
@@ -21 +21 @@
 
 forall( dtype ostype | ostream( ostype ) )
-ostype * ?<<?( ostype *os, char c ) {
+ostype * ?|?( ostype *os, char c ) {
         return write( os, &c, 1 );
-} // ?<<?
+} // ?|?
 
 forall( dtype ostype | ostream( ostype ) )
-ostype * ?<<?( ostype *os, int i ) {
+ostype * ?|?( ostype *os, int i ) {
         char buffer[32];                                                                        // larger than the largest integer
         sprintf( buffer, "%d", i );
         return write( os, buffer, strlen( buffer ) );
-} // ?<<?
+} // ?|?
 
 forall( dtype ostype | ostream( ostype ) )
-ostype * ?<<?( ostype *os, double d ) {
+ostype * ?|?( ostype *os, double d ) {
         char buffer[32];                                                                        // larger than the largest double
         sprintf( buffer, "%g", d );
         return write( os, buffer, strlen( buffer ) );
-} // ?<<?
+} // ?|?
 
 forall( dtype ostype | ostream( ostype ) )
-ostype * ?<<?( ostype *os, const char *cp ) {
+ostype * ?|?( ostype *os, const char *cp ) {
         return write( os, cp, strlen( cp ) );
-} // ?<<?
+} // ?|?
 
 forall( dtype ostype | ostream( ostype ) )
-ostype * ?<<?( ostype *os, const void *p ) {
+ostype * ?|?( ostype *os, const void *p ) {
         char buffer[32];                                                                        // larger than the largest pointer
         sprintf( buffer, "%p", p );
         return write( os, buffer, strlen( buffer ) );
-} // ?<<?
+} // ?|?
+
+
+forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) ) 
+retostype * ?|?( ostype *os, retostype * (*manip)(ostype*) ) {
+  return manip(os);
+}
+
+forall( dtype ostype | ostream( ostype ) ) 
+ostype * endl( ostype * os ) {
+  os | "\n";
+  // flush
+  return os;
+} // endl
 
 forall( type elt_type | writeable( elt_type ),
@@ -56 +69 @@
 void write( iterator_type begin, iterator_type end, os_type *os ) {
         void print( elt_type i ) {
-                os << i << ' ';
+                os | i | ' ';
         }
         for_each( begin, end, print );
-} // ?<<?
+} // ?|?
 
 forall( type elt_type | writeable( elt_type ),
@@ -65 +78 @@
                 dtype os_type | ostream( os_type ) )
 void write_reverse( iterator_type begin, iterator_type end, os_type *os ) {
-        void print( elt_type i ) {
-                os << i << ' ';
-        }
+        void print( elt_type i ) { os | i | ' '; }
         for_each_reverse( begin, end, print );
-} // ?<<?
+} // ?|?
 
 
 forall( dtype istype | istream( istype ) )
-istype * ?>>?( istype *is, char *cp ) {
+istype * ?|?( istype *is, char *cp ) {
         return read( is, cp, 1 );
-} // ?>>?
+} // ?|?
 
 forall( dtype istype | istream( istype ) )
-istype * ?>>?( istype *is, int *ip ) {
+istype * ?|?( istype *is, int *ip ) {
         char cur;
   
         // skip some whitespace
         do {
-                is >> &cur;
+                is | &cur;
                 if ( fail( is ) || eof( is ) ) return is;
         } while ( !( cur >= '0' && cur <= '9' ) );
@@ -91 +102 @@
         while ( cur >= '0' && cur <= '9' ) {
                 *ip = *ip * 10 + ( cur - '0' );
-                is >> &cur;
+                is | &cur;
                 if ( fail( is ) || eof( is ) ) return is;
         }
@@ -97 +108 @@
         unread( is, cur );
         return is;
-} // ?>>?
+} // ?|?
 
 // Local Variables: //

src/examples/iostream.h

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov 19 17:56:51 2015
-// Update Count     : 5
+// Last Modified On : Mon Nov 23 14:15:25 2015
+// Update Count     : 17
 //
 
@@ -27 +27 @@
 
 context writeable( type T ) {
-        forall( dtype ostype | ostream( ostype ) ) ostype * ?<<?( ostype *, T );
+        forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, T );
 };
 
 // implement writable for some intrinsic types
 
-forall( dtype ostype | ostream( ostype ) ) ostype * ?<<?( ostype *, char );
-forall( dtype ostype | ostream( ostype ) ) ostype * ?<<?( ostype *, int );
-forall( dtype ostype | ostream( ostype ) ) ostype * ?<<?( ostype *, double );
-forall( dtype ostype | ostream( ostype ) ) ostype * ?<<?( ostype *, const char * );
-forall( dtype ostype | ostream( ostype ) ) ostype * ?<<?( ostype *, void * );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, char );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, int );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, double );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const char * );
+forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype *, const void * );
+
+forall( dtype ostype, dtype retostype | ostream( ostype ) | ostream( retostype ) ) retostype * ?|?( ostype *os, retostype * (* manip)(ostype*) );
+forall( dtype ostype | ostream( ostype ) ) ostype * endl( ostype * );
 
 // writes the range [begin, end) to the given stream
@@ -49 +52 @@
 void write_reverse( iterator_type begin, iterator_type end, os_type *os );
 
+//******************************************************************************
 
 context istream( dtype istype ) {
@@ -58 +62 @@
 
 context readable( type T ) {
-        forall( dtype istype | istream( istype ) ) istype * ?<<?( istype *, T );
+        forall( dtype istype | istream( istype ) ) istype * ?|?( istype *, T );
 };
 
 forall( dtype istype | istream( istype ) )
-istype * ?>>?( istype *, char * );
+istype * ?|?( istype *, char * );
 
 forall( dtype istype | istream( istype ) )
-istype * ?>>?( istype *, int * );
+istype * ?|?( istype *, int * );
 
 #endif // IOSTREAM_H

src/examples/sum.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 28 15:09:55 2015
-// Update Count     : 118
+// Last Modified On : Sat Nov 21 18:08:18 2015
+// Update Count     : 119
 //
 
@@ -53 +53 @@
         }
         sout << "sum from " << low << " to " << High << " is "
-                 << (int)sum( size, a ) << ", check " << (int)s << "\n";
+                 << (int)sum( size, a ) << ", check " << (int)s << endl;
 
         int s = 0, a[size];
@@ -62 +62 @@
         }
         sout << "sum from " << low << " to " << High << " is "
-                 << sum( size, (int *)a ) << ", check " << (int)s << "\n";
+                 << sum( size, (int *)a ) << ", check " << (int)s << endl;
 
         double s = 0.0, a[size];
@@ -72 +72 @@
         printf( "%g\n", sum( size, (double *)a ) );
 //      sout << "sum from " << low / 10.0 << " to " << High / 10.0 << " is "
-//               << sum( size, (double *)a ) << ", check " << (double)s << "\n";
+//               << sum( size, (double *)a ) << ", check " << (double)s << endl;
 
         float s = 0.0, a[size];
@@ -82 +82 @@
         printf( "%g\n", sum( size, (float *)a ) );
 //      sout << "sum from " << low / 10.0 << " to " << High / 10.0 << " is "
-//               << sum( size, (float *)a ) << ", check " << (float)s << "\n";
+//               << sum( size, (float *)a ) << ", check " << (float)s << endl;
 }
 

src/examples/vector_test.c

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov 19 17:54:34 2015
-// Update Count     : 9
+// Last Modified On : Tue Dec 15 16:02:56 2015
+// Update Count     : 13
 //
 
@@ -27 +27 @@
         int num;
 
-        sout << "enter N elements and C-d on a separate line:\n";
+        sout | "enter N elements and C-d on a separate line:" | endl;
         for ( ;; ) {
-                sin >> &num;
+                sin | &num;
           if ( fail( sin ) || eof( sin ) ) break;
                 append( &vec, num );
@@ -35 +35 @@
         // write out the numbers
 
-        sout << "Array elements:\n";
+        sout | "Array elements:" | endl;
         write( begin( vec ), end( vec ), sout );
-        sout << "\n";
+        sout | endl;
 
-        sout << "Array elements reversed:\n";
+        sout | "Array elements reversed:" | endl;
         write_reverse( begin( vec ), end( vec ), sout );
-        sout << "\n";
+        sout | endl;
 }
 

src/libcfa/Makefile.am

@@ -11 +11 @@
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
-## Last Modified On : Thu Jun  4 22:49:16 2015
-## Update Count     : 7
+## Last Modified On : Wed Dec 16 22:58:17 2015
+## Update Count     : 9
 ###############################################################################
 
@@ -44 +44 @@
 
 libcfa-prelude.c : ${srcdir}/prelude.cf
-        ${libdir}/cfa-cpp -l ${srcdir}/prelude.cf $@
+        ../cfa-cpp -l ${srcdir}/prelude.cf $@  # use src/cfa-cpp as not in lib until after install
 
 libcfa-prelude.o : libcfa-prelude.c

src/libcfa/Makefile.in

@@ -220 +220 @@
           esac; \
         done; \
-        echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/libcfa/Makefile'; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/libcfa/Makefile'; \
         $(am__cd) $(top_srcdir) && \
-          $(AUTOMAKE) --gnu src/libcfa/Makefile
+          $(AUTOMAKE) --foreign src/libcfa/Makefile
 .PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@@ -542 +542 @@
 
 libcfa-prelude.c : ${srcdir}/prelude.cf
-        ${libdir}/cfa-cpp -l ${srcdir}/prelude.cf $@
+        ../cfa-cpp -l ${srcdir}/prelude.cf $@  # use src/cfa-cpp as not in lib until after install
 
 libcfa-prelude.o : libcfa-prelude.c

src/main.cc

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Nov 19 22:31:40 2015
-// Update Count     : 168
+// Last Modified On : Thu Dec 17 12:59:06 2015
+// Update Count     : 179
 //
 
@@ -187 +187 @@
                 // read in the builtins and the prelude
                 if ( ! nopreludep ) {                                                   // include gcc builtins
-                        FILE * builtins = fopen( CFA_LIBDIR "/builtins.cf", "r" );
+                        // -l is for initial build ONLY and builtins.cf is not in the lib directory so access it here.
+                        FILE * builtins = fopen( libcfap ? "./builtins.cf" : CFA_LIBDIR "/builtins.cf", "r" );
                         if ( builtins == NULL ) {
                                 std::cerr << "Error: can't open builtins" << std::endl;
@@ -196 +197 @@
 
                         if ( ! libcfap ) {
-                                // read the prelude in, if we're not generating the cfa library
+                                // read the prelude in, if not generating the cfa library
                                 FILE * prelude = fopen( CFA_LIBDIR "/prelude.cf", "r" );
                                 if ( prelude == NULL ) {
@@ -203 +204 @@
                                 } // if
                     
-                    parse( prelude, LinkageSpec::Intrinsic );
+                                parse( prelude, LinkageSpec::Intrinsic );
                         } // if
                 } // if
 
-                if ( libcfap ) {
-                        parse( input, LinkageSpec::Intrinsic ); 
-                } else {
-                        parse( input, LinkageSpec::Cforall, grammarp ); 
-                }
+                parse( input, libcfap ? LinkageSpec::Intrinsic : LinkageSpec::Cforall, grammarp );      
   
                 if ( parsep ) {