Changeset ae63a18

Timestamp:

Dec 18, 2015, 2:56:11 PM (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, string, with_gc

Children:

8762501

Parents:

baf7fee (diff), c23f807 (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:

resolving conflicts

Files:

• configure (modified) (1 diff)
• configure.ac (modified) (1 diff)
• doc/refrat/refrat.tex (modified) (1 diff)
• src/GenPoly/Box.cc (modified) (56 diffs)
• src/GenPoly/GenPoly.cc (modified) (4 diffs)
• src/GenPoly/GenPoly.h (modified) (1 diff)
• src/GenPoly/InstantiateGeneric.cc (modified) (8 diffs)
• src/GenPoly/Lvalue.cc (modified) (2 diffs)
• src/GenPoly/ScrubTyVars.cc (modified) (2 diffs)
• src/GenPoly/ScrubTyVars.h (modified) (2 diffs)
• src/GenPoly/Specialize.cc (modified) (2 diffs)
• src/InitTweak/RemoveInit.cc (modified) (6 diffs)
• src/InitTweak/RemoveInit.h (modified) (2 diffs)
• src/Makefile.in (modified) (1 diff)
• src/SymTab/Mangler.cc (modified) (5 diffs)
• src/SymTab/Mangler.h (modified) (3 diffs)
• src/SynTree/PointerType.cc (modified) (2 diffs)
• src/SynTree/Type.h (modified) (15 diffs)
• 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/tests/log.txt (deleted)
• 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)

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/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"
@@ -61 +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();
@@ -92 +93 @@
                 class Pass2 : public PolyMutator {
                   public:
-                        Pass2();
                         template< typename DeclClass >
                         DeclClass *handleDecl( DeclClass *decl, Type *type );
@@ -103 +103 @@
                   private:
                         void addAdapters( FunctionType *functionType );
-  
+
                         std::map< UniqueId, std::string > adapterName;
                 };
@@ -151 +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 {
@@ -164 +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
@@ -181 +181 @@
                 }
 
-                Pass1::Pass1()
-                        : useRetval( false ), tempNamer( "_temp" ) {
+                Pass1::Pass1() : useRetval( false ), tempNamer( "_temp" ) {
                         adapters.push(AdapterMap());
                 }
@@ -194 +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
@@ -231 +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() == "" ) {
@@ -238 +241 @@
                                         } // if
                                 } // if
-        
+
                                 FunctionType *functionType = functionDecl->get_functionType();
                                 makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
@@ -263 +266 @@
 
                                 functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
-  
+
                                 scopeTyVars = oldtyVars;
                                 assignOps = oldassignOps;
@@ -279 +282 @@
 
                 TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
-///     std::cerr << "add " << typeDecl->get_name() << "\n";
                         scopeTyVars[ typeDecl->get_name() ] = typeDecl->get_kind();
                         return Mutator::mutate( typeDecl );
@@ -305 +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;
@@ -313 +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 );
@@ -318 +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 );
+                                }
+                        }
                 }
 
@@ -326 +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;
                 }
 
@@ -377 +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
@@ -385 +406 @@
                         appExpr->get_args().push_front( appExpr->get_function() );
                         appExpr->set_function( new NameExpr( adapterName ) );
-  
+
                         return ret;
                 }
@@ -391 +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() ) {
@@ -411 +432 @@
                                 } // if
                         } // if
-///   }
+//   }
                 }
 
@@ -428 +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 );
@@ -469 +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
@@ -479 +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( "*?" ) );
@@ -495 +504 @@
                                         return deref;
                                 } // if
-///     }
+//     }
                         } // if
                         return new VariableExpr( param );
@@ -520 +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();
@@ -534 +543 @@
                                 } // for
                         } // for
-  
+
                         std::list< DeclarationWithType *>::iterator arg = realType->get_parameters().begin();
                         std::list< DeclarationWithType *>::iterator param = adapterType->get_parameters().begin();
@@ -542 +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" );
@@ -591 +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 );
 
@@ -614 +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 ) {
@@ -653 +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() ) {
@@ -670 +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() ) {
@@ -703 +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();
@@ -718 +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 ) {
@@ -732 +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
@@ -738 +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() ) {
@@ -756 +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
@@ -770 +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
@@ -795 +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() );
@@ -801 +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 ) ) {
@@ -824 +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 );
 
@@ -841 +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() == "*?" ) {
@@ -856 +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();
@@ -869 +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;
                 }
 
@@ -909 +910 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
-  
+
                         Type *ret = Mutator::mutate( pointerType );
-  
+
                         scopeTyVars = oldtyVars;
                         return ret;
@@ -919 +920 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( functionType, scopeTyVars );
-  
+
                         Type *ret = Mutator::mutate( functionType );
-  
+
                         scopeTyVars = oldtyVars;
                         return ret;
@@ -936 +937 @@
 
 ////////////////////////////////////////// Pass2 ////////////////////////////////////////////////////
-
-                Pass2::Pass2() {}
 
                 void Pass2::addAdapters( FunctionType *functionType ) {
@@ -956 +955 @@
                                 }
                         }
-///  deleteAll( functions );
+//  deleteAll( functions );
                 }
 
@@ -990 +989 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
-  
+
                         Type *ret = Mutator::mutate( pointerType );
-  
+
                         scopeTyVars = oldtyVars;
                         return ret;
@@ -1000 +999 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( funcType, scopeTyVars );
-  
+
+                        // move polymorphic return type to parameter list
                         std::string typeName;
                         if ( isPolyRet( funcType, typeName ) ) {
@@ -1008 +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 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;
                                 }
@@ -1029 +1037 @@
                                 (*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;
@@ -1045 +1077 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( type, scopeTyVars );
-  
+
                         DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
                         ScrubTyVars::scrub( decl, scopeTyVars );
@@ -1081 +1113 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( pointerType, scopeTyVars );
-  
+
                         Type *ret = Mutator::mutate( pointerType );
-  
+
                         scopeTyVars = oldtyVars;
                         return ret;
@@ -1091 +1123 @@
                         TyVarMap oldtyVars = scopeTyVars;
                         makeTyVarMap( functionType, scopeTyVars );
-  
+
                         Type *ret = Mutator::mutate( functionType );
-  
+
                         scopeTyVars = oldtyVars;
                         return ret;
@@ -1100 +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/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

@@ -77 +77 @@
                 std::list< Type* > params;  ///< Instantiation parameters
         };
-
+        
         /// Maps a concrete type to the instantiated struct type, accounting for scope
         class InstantiationMap {
@@ -143 +143 @@
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
         class Instantiate : public DeclMutator {
+                /// Map of (generic type, parameter list) pairs to concrete type instantiations
                 InstantiationMap instantiations;
+                /// Namer for concrete types
                 UniqueName typeNamer;
 
@@ -149 +151 @@
                 Instantiate() : DeclMutator(), instantiations(), typeNamer("_conc_") {}
 
-//              virtual Declaration* mutate( StructDecl *aggregateDecl );
-//              virtual Declaration* mutate( UnionDecl *aggregateDecl );
-
                 virtual Type* mutate( StructInstType *inst );
                 virtual Type* mutate( UnionInstType *inst );
+
+//              virtual Expression* mutate( MemberExpr *memberExpr );
                 
                 virtual void doBeginScope();
@@ -166 +167 @@
         /// 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
+                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
@@ -172 +173 @@
                 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
+//                      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");
@@ -179 +180 @@
                                 // check that the substituted type isn't a type variable itself
                                 if ( dynamic_cast< TypeInstType* >( paramType->get_type() ) ) {
-                                        allConcrete = false;
+                                        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 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;
-        }
-        
+//                              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, 
@@ -288 +291 @@
                 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() {
                 DeclMutator::doBeginScope();
-                // push a new concrete type scope
                 instantiations.beginScope();
         }
@@ -297 +349 @@
         void Instantiate::doEndScope() {
                 DeclMutator::doEndScope();
-                // pop the last concrete type scope
                 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
 //
 
@@ -122 +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/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

@@ -16 +16 @@
 #ifndef _SCRUBTYVARS_H
 #define _SCRUBTYVARS_H
+
+#include <string>
 
 #include "GenPoly.h"
@@ -36 +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/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

@@ -413 +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

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/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/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 : Rob Schluntz
-// Last Modified On : Wed Dec 09 14:08:41 2015
-// Update Count     : 17
+// 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 ); }

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 ) {