Changes in / [ae357ec:b63e376]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/CodeGenerator.h (modified) (1 diff)
• CodeGen/GenType.cc (modified) (1 diff)
• GenPoly/Box.cc (modified) (13 diffs)
• GenPoly/DeclMutator.cc (modified) (8 diffs)
• GenPoly/DeclMutator.h (modified) (1 diff)
• GenPoly/InstantiateGeneric.cc (added)
• GenPoly/InstantiateGeneric.h (added)
• GenPoly/module.mk (modified) (1 diff)
• Makefile.in (modified) (12 diffs)
• SymTab/AggregateTable.h (added)
• SymTab/IdTable.cc (added)
• SymTab/IdTable.h (added)
• SymTab/Indexer.cc (modified) (15 diffs)
• SymTab/Indexer.h (modified) (3 diffs)
• SymTab/StackTable.cc (added)
• SymTab/StackTable.h (added)
• SymTab/TypeTable.h (added)
• SymTab/module.mk (modified) (1 diff)
• SynTree/Constant.cc (modified) (2 diffs)
• SynTree/Constant.h (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -21 +21 @@
 #include "Parser/ParseNode.h"
 
-#include "SynTree/Declaration.h"
+#include "SynTree/Type.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
-#include "SynTree/Type.h"
 
 #include "Common/utility.h"

src/CodeGen/CodeGenerator.h

@@ -19 +19 @@
 #include <list>
 
-#include "SynTree/Declaration.h"
 #include "SynTree/SynTree.h"
 #include "SynTree/Visitor.h"
-
 #include "SymTab/Indexer.h"
 

src/CodeGen/GenType.cc

@@ -19 +19 @@
 #include "GenType.h"
 #include "CodeGenerator.h"
-
-#include "SynTree/Declaration.h"
+#include "SynTree/Visitor.h"
+#include "SynTree/Type.h"
 #include "SynTree/Expression.h"
-#include "SynTree/Type.h"
-#include "SynTree/Visitor.h"
 
 namespace CodeGen {

src/GenPoly/Box.cc

@@ -14 +14 @@
 //
 
-#include <algorithm>
-#include <iterator>
-#include <list>
-#include <map>
 #include <set>
 #include <stack>
 #include <string>
-#include <utility>
-#include <vector>
+#include <iterator>
+#include <algorithm>
 #include <cassert>
 
 #include "Box.h"
-#include "DeclMutator.h"
+#include "InstantiateGeneric.h"
 #include "PolyMutator.h"
 #include "FindFunction.h"
-#include "ScopedMap.h"
 #include "ScrubTyVars.h"
 
@@ -35 +30 @@
 
 #include "SynTree/Constant.h"
-#include "SynTree/Declaration.h"
+#include "SynTree/Type.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Initializer.h"
+#include "SynTree/Statement.h"
 #include "SynTree/Mutator.h"
-#include "SynTree/Statement.h"
-#include "SynTree/Type.h"
-#include "SynTree/TypeSubstitution.h"
 
 #include "ResolvExpr/TypeEnvironment.h"
@@ -47 +40 @@
 #include "ResolvExpr/typeops.h"
 
-#include "SymTab/Indexer.h"
 #include "SymTab/Mangler.h"
 
@@ -62 +54 @@
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
-                /// Key for a unique concrete type; generic base type paired with type parameter list
-                struct ConcreteType {
-                        ConcreteType() : base(NULL), params() {}
-
-                        ConcreteType(AggregateDecl *_base, const std::list< Type* >& _params) : base(_base), params() { cloneAll(_params, params); }
-
-                        ConcreteType(const ConcreteType& that) : base(that.base), params() { cloneAll(that.params, params); }
-
-                        /// Extracts types from a list of TypeExpr*
-                        ConcreteType(AggregateDecl *_base, const std::list< TypeExpr* >& _params) : base(_base), params() {
-                                for ( std::list< TypeExpr* >::const_iterator param = _params.begin(); param != _params.end(); ++param ) {
-                                        params.push_back( (*param)->get_type()->clone() );
-                                }
-                        }
-
-                        ConcreteType& operator= (const ConcreteType& that) {
-                                deleteAll( params );
-                                params.clear();
-
-                                base = that.base;
-                                cloneAll( that.params, params );
-
-                                return *this;
-                        }
-
-                        ~ConcreteType() { deleteAll( params ); }
-
-                        bool operator== (const ConcreteType& that) const {
-                                if ( base != that.base ) return false;
-
-                                SymTab::Indexer dummy;
-                                if ( params.size() != that.params.size() ) return false;
-                                for ( std::list< Type* >::const_iterator it = params.begin(), jt = that.params.begin(); it != params.end(); ++it, ++jt ) {
-                                        if ( ! ResolvExpr::typesCompatible( *it, *jt, dummy ) ) return false;
-                                }
-                                return true;
-                        }
-
-                        AggregateDecl *base;        ///< Base generic type
-                        std::list< Type* > params;  ///< Instantiation parameters
-                };
-
-                /// Maps a concrete type to the some value, accounting for scope
-                template< typename Value >
-                class InstantiationMap {
-                        /// Information about a specific instantiation of a generic type
-                        struct Instantiation {
-                                ConcreteType key;  ///< Instantiation parameters for this type
-                                Value *value;      ///< Value for this instantiation
-
-                                Instantiation() : key(), value(0) {}
-                                Instantiation(const ConcreteType &_key, Value *_value) : key(_key), value(_value) {}
-                        };
-                        /// Map of generic types to instantiations of them
-                        typedef std::map< AggregateDecl*, std::vector< Instantiation > > Scope;
-
-                        std::vector< Scope > scopes;  ///< list of scopes, from outermost to innermost
-
-                public:
-                        /// Starts a new scope
-                        void beginScope() {
-                                Scope scope;
-                                scopes.push_back(scope);
-                        }
-
-                        /// Ends a scope
-                        void endScope() {
-                                scopes.pop_back();
-                        }
-
-                        /// Default constructor initializes with one scope
-                        InstantiationMap() { beginScope(); }
-
-//              private:
-                        /// Gets the value for the concrete instantiation of this type, assuming it has already been instantiated in the current scope.
-                        /// Returns NULL on none such.
-                        Value *lookup( AggregateDecl *generic, const std::list< TypeExpr* >& params ) {
-                                ConcreteType key(generic, params);
-                                // scan scopes from innermost out
-                                for ( typename std::vector< Scope >::const_reverse_iterator scope = scopes.rbegin(); scope != scopes.rend(); ++scope ) {
-                                        // skip scope if no instantiations of this generic type
-                                        typename Scope::const_iterator insts = scope->find( generic );
-                                        if ( insts == scope->end() ) continue;
-                                        // look through instantiations for matches to concrete type
-                                        for ( typename std::vector< Instantiation >::const_iterator inst = insts->second.begin(); inst != insts->second.end(); ++inst ) {
-                                                if ( inst->key == key ) return inst->value;
-                                        }
-                                }
-                                // no matching instantiation found
-                                return 0;
-                        }
-                public:
-//                      StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)lookup( inst->get_baseStruct(), typeSubs ); }
-//                      UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)lookup( inst->get_baseUnion(), typeSubs ); }
-
-//              private:
-                        /// Adds a value for a concrete type to the current scope
-                        void insert( AggregateDecl *generic, const std::list< TypeExpr* > &params, Value *value ) {
-                                ConcreteType key(generic, params);
-                                scopes.back()[generic].push_back( Instantiation( key, value ) );
-                        }
-//              public:
-//                      void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { insert( inst->get_baseStruct(), typeSubs, decl ); }
-//                      void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { insert( inst->get_baseUnion(), typeSubs, decl ); }
-                };
-
-                /// Adds layout-generation functions to polymorphic types
-                class LayoutFunctionBuilder : public DeclMutator {
-                        unsigned int functionNesting;  // current level of nested functions
-                public:
-                        LayoutFunctionBuilder() : functionNesting( 0 ) {}
-
-                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl );
-                        virtual Declaration *mutate( StructDecl *structDecl );
-                        virtual Declaration *mutate( UnionDecl *unionDecl );
-                };
-                
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
                 class Pass1 : public PolyMutator {
@@ -225 +100 @@
                         ObjectDecl *makeTemporary( Type *type );
 
+                        typedef std::map< std::string, DeclarationWithType *> AdapterMap;
                         std::map< std::string, DeclarationWithType *> assignOps;
                         ResolvExpr::TypeMap< DeclarationWithType > scopedAssignOps;
-                        ScopedMap< std::string, DeclarationWithType* > adapters;
+                        std::stack< AdapterMap > adapters;
                         DeclarationWithType *retval;
                         bool useRetval;
@@ -248 +124 @@
 
                         std::map< UniqueId, std::string > adapterName;
-                };
-
-                /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
-                class GenericInstantiator : public DeclMutator {
-                        /// Map of (generic type, parameter list) pairs to concrete type instantiations
-                        InstantiationMap< AggregateDecl > instantiations;
-                        /// Namer for concrete types
-                        UniqueName typeNamer;
-
-                public:
-                        GenericInstantiator() : DeclMutator(), instantiations(), typeNamer("_conc_") {}
-
-                        virtual Type* mutate( StructInstType *inst );
-                        virtual Type* mutate( UnionInstType *inst );
-
-        //              virtual Expression* mutate( MemberExpr *memberExpr );
-
-                        virtual void doBeginScope();
-                        virtual void doEndScope();
-                private:
-                        /// Wrap instantiation lookup for structs
-                        StructDecl* lookup( StructInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (StructDecl*)instantiations.lookup( inst->get_baseStruct(), typeSubs ); }
-                        /// Wrap instantiation lookup for unions
-                        UnionDecl* lookup( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs ) { return (UnionDecl*)instantiations.lookup( inst->get_baseUnion(), typeSubs ); }
-                        /// Wrap instantiation insertion for structs
-                        void insert( StructInstType *inst, const std::list< TypeExpr* > &typeSubs, StructDecl *decl ) { instantiations.insert( inst->get_baseStruct(), typeSubs, decl ); }
-                        /// Wrap instantiation insertion for unions
-                        void insert( UnionInstType *inst, const std::list< TypeExpr* > &typeSubs, UnionDecl *decl ) { instantiations.insert( inst->get_baseUnion(), typeSubs, decl ); }
                 };
 
@@ -311 +159 @@
         } // anonymous namespace
 
+        void printAllNotBuiltin( const std::list< Declaration *>& translationUnit, std::ostream &os ) {
+                for ( std::list< Declaration *>::const_iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
+                        if ( ! LinkageSpec::isBuiltin( (*i)->get_linkage() ) ) {
+                                (*i)->print( os );
+                                os << std::endl;
+                        } // if
+                } // for
+        }
+
         /// version of mutateAll with special handling for translation unit so you can check the end of the prelude when debugging
         template< typename MutatorType >
@@ -338 +195 @@
 
         void box( std::list< Declaration *>& translationUnit ) {
-                LayoutFunctionBuilder layoutBuilder;
                 Pass1 pass1;
                 Pass2 pass2;
-                GenericInstantiator instantiator;
                 MemberExprFixer memberFixer;
                 Pass3 pass3;
-                
-                layoutBuilder.mutateDeclarationList( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, pass1 );
                 mutateTranslationUnit/*All*/( translationUnit, pass2 );
-//              instantiateGeneric( translationUnit );
-                instantiator.mutateDeclarationList( translationUnit );
+                instantiateGeneric( translationUnit );
                 mutateTranslationUnit/*All*/( translationUnit, memberFixer );
                 mutateTranslationUnit/*All*/( translationUnit, pass3 );
         }
 
-        ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
-
-        DeclarationWithType *LayoutFunctionBuilder::mutate( FunctionDecl *functionDecl ) {
-                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
-                mutateAll( functionDecl->get_oldDecls(), *this );
-                ++functionNesting;
-                functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
-                --functionNesting;
-                return functionDecl;
-        }
-        
-        /// Get a list of type declarations that will affect a layout function
-        std::list< TypeDecl* > takeOtypeOnly( std::list< TypeDecl* > &decls ) {
-                std::list< TypeDecl * > otypeDecls;
-
-                for ( std::list< TypeDecl* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
-                        if ( (*decl)->get_kind() == TypeDecl::Any ) {
-                                otypeDecls.push_back( *decl );
-                        }
-                }
-                
-                return otypeDecls;
-        }
-
-        /// Adds parameters for otype layout to a function type
-        void addOtypeParams( FunctionType *layoutFnType, std::list< TypeDecl* > &otypeParams ) {
-                BasicType sizeAlignType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                
-                for ( std::list< TypeDecl* >::const_iterator param = otypeParams.begin(); param != otypeParams.end(); ++param ) {
-                        TypeInstType paramType( Type::Qualifiers(), (*param)->get_name(), *param );
-                        layoutFnType->get_parameters().push_back( new ObjectDecl( sizeofName( &paramType ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
-                        layoutFnType->get_parameters().push_back( new ObjectDecl( alignofName( &paramType ), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignType.clone(), 0 ) );
-                }
-        }
-
-        /// Builds a layout function declaration
-        FunctionDecl *buildLayoutFunctionDecl( const std::string &typeName, unsigned int functionNesting, FunctionType *layoutFnType ) {
-                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
-                // because each unit generates copies of the default routines for each aggregate.
-                FunctionDecl *layoutDecl = new FunctionDecl(
-                        "__layoutof_" + typeName, functionNesting > 0 ? DeclarationNode::NoStorageClass : DeclarationNode::Static, LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ), true, false );
-                layoutDecl->fixUniqueId();
-                return layoutDecl;
-        }
-
-        /// Makes a unary operation
-        Expression *makeOp( const std::string &name, Expression *arg ) {
-                UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( arg );
-                return expr;
-        }
-
-        /// Makes a binary operation
-        Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) {
-                UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( lhs );
-                expr->get_args().push_back( rhs );
-                return expr;
-        }
-
-        /// Returns the dereference of a local pointer variable
-        Expression *derefVar( ObjectDecl *var ) {
-                return makeOp( "*?", new VariableExpr( var ) );
-        }
-
-        /// makes an if-statement with a single-expression if-block and no then block
-        Statement *makeCond( Expression *cond, Expression *ifPart ) {
-                return new IfStmt( noLabels, cond, new ExprStmt( noLabels, ifPart ), 0 );
-        }
-
-        /// makes a statement that assigns rhs to lhs if lhs < rhs
-        Statement *makeAssignMax( Expression *lhs, Expression *rhs ) {
-                return makeCond( makeOp( "?<?", lhs, rhs ), makeOp( "?=?", lhs->clone(), rhs->clone() ) );
-        }
-
-        /// makes a statement that aligns lhs to rhs (rhs should be an integer power of two)
-        Statement *makeAlignTo( Expression *lhs, Expression *rhs ) {
-                // check that the lhs is zeroed out to the level of rhs
-                Expression *ifCond = makeOp( "?&?", lhs, makeOp( "?-?", rhs, new ConstantExpr( Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), "1" ) ) ) );
-                // if not aligned, increment to alignment
-                Expression *ifExpr = makeOp( "?+=?", lhs->clone(), makeOp( "?-?", rhs->clone(), ifCond->clone() ) );
-                return makeCond( ifCond, ifExpr );
-        }
-        
-        /// adds an expression to a compound statement
-        void addExpr( CompoundStmt *stmts, Expression *expr ) {
-                stmts->get_kids().push_back( new ExprStmt( noLabels, expr ) );
-        }
-
-        /// adds a statement to a compound statement
-        void addStmt( CompoundStmt *stmts, Statement *stmt ) {
-                stmts->get_kids().push_back( stmt );
-        }
-        
-        Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
-                // do not generate layout function for "empty" tag structs
-                if ( structDecl->get_members().empty() ) return structDecl;
-
-                // get parameters that can change layout, exiting early if none
-                std::list< TypeDecl* > otypeParams = takeOtypeOnly( structDecl->get_parameters() );
-                if ( otypeParams.empty() ) return structDecl;
-
-                // build layout function signature
-                FunctionType *layoutFnType = new FunctionType( Type::Qualifiers(), false );
-                BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
-                
-                ObjectDecl *sizeParam = new ObjectDecl( "__sizeof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
-                layoutFnType->get_parameters().push_back( sizeParam );
-                ObjectDecl *alignParam = new ObjectDecl( "__alignof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
-                layoutFnType->get_parameters().push_back( alignParam );
-                ObjectDecl *offsetParam = new ObjectDecl( "__offsetof_" + structDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
-                layoutFnType->get_parameters().push_back( offsetParam );
-                addOtypeParams( layoutFnType, otypeParams );
-
-                // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( structDecl->get_name(), functionNesting, layoutFnType );
-
-                // calculate struct layout in function body
-
-                // initialize size and alignment to 0 and 1 (will have at least one member to re-edit size
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "0" ) ) ) );
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
-                unsigned long n_members = 0;
-                bool firstMember = true;
-                for ( std::list< Declaration* >::const_iterator member = structDecl->get_members().begin(); member != structDecl->get_members().end(); ++member ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
-                        assert( dwt );
-                        Type *memberType = dwt->get_type();
-
-                        if ( firstMember ) {
-                                firstMember = false;
-                        } else {
-                                // make sure all members after the first (automatically aligned at 0) are properly padded for alignment
-                                addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), new AlignofExpr( memberType->clone() ) ) );
-                        }
-                        
-                        // place current size in the current offset index
-                        addExpr( layoutDecl->get_statements(), makeOp( "?=?", makeOp( "?[?]", new VariableExpr( offsetParam ), new ConstantExpr( Constant::from( n_members ) ) ),
-                                                                              derefVar( sizeParam ) ) );
-                        ++n_members;
-
-                        // add member size to current size
-                        addExpr( layoutDecl->get_statements(), makeOp( "?+=?", derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
-                        
-                        // take max of member alignment and global alignment
-                        addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
-                }
-                // make sure the type is end-padded to a multiple of its alignment
-                addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
-
-                addDeclarationAfter( layoutDecl );
-                return structDecl;
-        }
-        
-        Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) {
-                // do not generate layout function for "empty" tag unions
-                if ( unionDecl->get_members().empty() ) return unionDecl;
-                
-                // get parameters that can change layout, exiting early if none
-                std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() );
-                if ( otypeParams.empty() ) return unionDecl;
-
-                // build layout function signature
-                FunctionType *layoutFnType = new FunctionType( Type::Qualifiers(), false );
-                BasicType *sizeAlignType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                PointerType *sizeAlignOutType = new PointerType( Type::Qualifiers(), sizeAlignType );
-                
-                ObjectDecl *sizeParam = new ObjectDecl( "__sizeof_" + unionDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType, 0 );
-                layoutFnType->get_parameters().push_back( sizeParam );
-                ObjectDecl *alignParam = new ObjectDecl( "__alignof_" + unionDecl->get_name(), DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, sizeAlignOutType->clone(), 0 );
-                layoutFnType->get_parameters().push_back( alignParam );
-                addOtypeParams( layoutFnType, otypeParams );
-
-                // build function decl
-                FunctionDecl *layoutDecl = buildLayoutFunctionDecl( unionDecl->get_name(), functionNesting, layoutFnType );
-
-                // calculate union layout in function body
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( sizeParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
-                addExpr( layoutDecl->get_statements(), makeOp( "?=?", derefVar( alignParam ), new ConstantExpr( Constant( sizeAlignType->clone(), "1" ) ) ) );
-                for ( std::list< Declaration* >::const_iterator member = unionDecl->get_members().begin(); member != unionDecl->get_members().end(); ++member ) {
-                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member );
-                        assert( dwt );
-                        Type *memberType = dwt->get_type();
-                        
-                        // take max member size and global size
-                        addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( sizeParam ), new SizeofExpr( memberType->clone() ) ) );
-                        
-                        // take max of member alignment and global alignment
-                        addStmt( layoutDecl->get_statements(), makeAssignMax( derefVar( alignParam ), new AlignofExpr( memberType->clone() ) ) );
-                }
-                // make sure the type is end-padded to a multiple of its alignment
-                addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
-
-                addDeclarationAfter( layoutDecl );
-                return unionDecl;
-        }
-        
         ////////////////////////////////////////// Pass1 ////////////////////////////////////////////////////
 
@@ -591 +245 @@
                 }
 
-                Pass1::Pass1() : useRetval( false ), tempNamer( "_temp" ) {}
+                Pass1::Pass1() : useRetval( false ), tempNamer( "_temp" ) {
+                        adapters.push(AdapterMap());
+                }
 
                 /// Returns T if the given declaration is (*?=?)(T *, T) for some TypeInstType T (return not checked, but maybe should be), NULL otherwise
@@ -694 +350 @@
                                 } // for
 
+                                AdapterMap & adapters = Pass1::adapters.top();
                                 for ( std::list< FunctionType *>::iterator funType = functions.begin(); funType != functions.end(); ++funType ) {
                                         std::string mangleName = mangleAdapterName( *funType, scopeTyVars );
@@ -1115 +772 @@
                                         mangleName += makePolyMonoSuffix( originalFunction, exprTyVars );
 
-                                        typedef ScopedMap< std::string, DeclarationWithType* >::iterator AdapterIter;
-                                        AdapterIter adapter = adapters.find( mangleName );
+                                        AdapterMap & adapters = Pass1::adapters.top();
+                                        AdapterMap::iterator adapter = adapters.find( mangleName );
                                         if ( adapter == adapters.end() ) {
                                                 // adapter has not been created yet in the current scope, so define it
                                                 FunctionDecl *newAdapter = makeAdapter( *funType, realFunction, mangleName, exprTyVars );
-                                                std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
-                                                adapter = answer.first;
+                                                adapter = adapters.insert( adapters.begin(), std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
                                                 stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
                                         } // if
@@ -1500 +1156 @@
 
                 void Pass1::doBeginScope() {
-                        adapters.beginScope();
+                        // push a copy of the current map
+                        adapters.push(adapters.top());
                         scopedAssignOps.beginScope();
                 }
 
                 void Pass1::doEndScope() {
-                        adapters.endScope();
+                        adapters.pop();
                         scopedAssignOps.endScope();
                 }
@@ -1652 +1309 @@
                 }
 
-//////////////////////////////////////// GenericInstantiator //////////////////////////////////////////////////
-
-                /// Makes substitutions of params into baseParams; returns true if all parameters substituted for a concrete type
-                bool makeSubstitutions( const std::list< TypeDecl* >& baseParams, const std::list< Expression* >& params, std::list< TypeExpr* >& out ) {
-                        bool allConcrete = true;  // will finish the substitution list even if they're not all concrete
-
-                        // substitute concrete types for given parameters, and incomplete types for placeholders
-                        std::list< TypeDecl* >::const_iterator baseParam = baseParams.begin();
-                        std::list< Expression* >::const_iterator param = params.begin();
-                        for ( ; baseParam != baseParams.end() && param != params.end(); ++baseParam, ++param ) {
-        //                      switch ( (*baseParam)->get_kind() ) {
-        //                      case TypeDecl::Any: {   // any type is a valid substitution here; complete types can be used to instantiate generics
-                                        TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                        assert(paramType && "Aggregate parameters should be type expressions");
-                                        out.push_back( paramType->clone() );
-                                        // check that the substituted type isn't a type variable itself
-                                        if ( dynamic_cast< TypeInstType* >( paramType->get_type() ) ) {
-                                                allConcrete = false;
-                                        }
-        //                              break;
-        //                      }
-        //                      case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
-        //                              out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
-        //                              break;
-        //                      case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
-        //                              out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
-        //                              break;
-        //                      }
-                        }
-
-                        // if any parameters left over, not done
-                        if ( baseParam != baseParams.end() ) return false;
-        //              // if not enough parameters given, substitute remaining incomplete types for placeholders
-        //              for ( ; baseParam != baseParams.end(); ++baseParam ) {
-        //                      switch ( (*baseParam)->get_kind() ) {
-        //                      case TypeDecl::Any:    // no more substitutions here, fail early
-        //                              return false;
-        //                      case TypeDecl::Dtype:  // dtype can be consistently replaced with void [only pointers, which become void*]
-        //                              out.push_back( new TypeExpr( new VoidType( Type::Qualifiers() ) ) );
-        //                              break;
-        //                      case TypeDecl::Ftype:  // pointer-to-ftype can be consistently replaced with void (*)(void) [similar to dtype]
-        //                              out.push_back( new TypeExpr( new FunctionType( Type::Qualifiers(), false ) ) );
-        //                              break;
-        //                      }
-        //              }
-
-                        return allConcrete;
-                }
-
-                /// Substitutes types of members of in according to baseParams => typeSubs, appending the result to out
-                void substituteMembers( const std::list< Declaration* >& in, const std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs,
-                                                                std::list< Declaration* >& out ) {
-                        // substitute types into new members
-                        TypeSubstitution subs( baseParams.begin(), baseParams.end(), typeSubs.begin() );
-                        for ( std::list< Declaration* >::const_iterator member = in.begin(); member != in.end(); ++member ) {
-                                Declaration *newMember = (*member)->clone();
-                                subs.apply(newMember);
-                                out.push_back( newMember );
-                        }
-                }
-
-                Type* GenericInstantiator::mutate( StructInstType *inst ) {
-                        // mutate subtypes
-                        Type *mutated = Mutator::mutate( inst );
-                        inst = dynamic_cast< StructInstType* >( mutated );
-                        if ( ! inst ) return mutated;
-
-                        // exit early if no need for further mutation
-                        if ( inst->get_parameters().empty() ) return inst;
-                        assert( inst->get_baseParameters() && "Base struct has parameters" );
-
-                        // check if type can be concretely instantiated; put substitutions into typeSubs
-                        std::list< TypeExpr* > typeSubs;
-                        if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) {
-                                deleteAll( typeSubs );
-                                return inst;
-                        }
-
-                        // make concrete instantiation of generic type
-                        StructDecl *concDecl = lookup( inst, typeSubs );
-                        if ( ! concDecl ) {
-                                // set concDecl to new type, insert type declaration into statements to add
-                                concDecl = new StructDecl( typeNamer.newName( inst->get_name() ) );
-                                substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs,        concDecl->get_members() );
-                                DeclMutator::addDeclaration( concDecl );
-                                insert( inst, typeSubs, concDecl );
-                        }
-                        StructInstType *newInst = new StructInstType( inst->get_qualifiers(), concDecl->get_name() );
-                        newInst->set_baseStruct( concDecl );
-
-                        deleteAll( typeSubs );
-                        delete inst;
-                        return newInst;
-                }
-
-                Type* GenericInstantiator::mutate( UnionInstType *inst ) {
-                        // mutate subtypes
-                        Type *mutated = Mutator::mutate( inst );
-                        inst = dynamic_cast< UnionInstType* >( mutated );
-                        if ( ! inst ) return mutated;
-
-                        // exit early if no need for further mutation
-                        if ( inst->get_parameters().empty() ) return inst;
-                        assert( inst->get_baseParameters() && "Base union has parameters" );
-
-                        // check if type can be concretely instantiated; put substitutions into typeSubs
-                        std::list< TypeExpr* > typeSubs;
-                        if ( ! makeSubstitutions( *inst->get_baseParameters(), inst->get_parameters(), typeSubs ) ) {
-                                deleteAll( typeSubs );
-                                return inst;
-                        }
-
-                        // make concrete instantiation of generic type
-                        UnionDecl *concDecl = lookup( inst, typeSubs );
-                        if ( ! concDecl ) {
-                                // set concDecl to new type, insert type declaration into statements to add
-                                concDecl = new UnionDecl( typeNamer.newName( inst->get_name() ) );
-                                substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
-                                DeclMutator::addDeclaration( concDecl );
-                                insert( inst, typeSubs, concDecl );
-                        }
-                        UnionInstType *newInst = new UnionInstType( inst->get_qualifiers(), concDecl->get_name() );
-                        newInst->set_baseUnion( concDecl );
-
-                        deleteAll( typeSubs );
-                        delete inst;
-                        return newInst;
-                }
-
-        //      /// Gets the base struct or union declaration for a member expression; NULL if not applicable
-        //      AggregateDecl* getMemberBaseDecl( MemberExpr *memberExpr ) {
-        //              // get variable for member aggregate
-        //              VariableExpr *varExpr = dynamic_cast< VariableExpr* >( memberExpr->get_aggregate() );
-        //              if ( ! varExpr ) return NULL;
-        //
-        //              // get object for variable
-        //              ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( varExpr->get_var() );
-        //              if ( ! objectDecl ) return NULL;
-        //
-        //              // get base declaration from object type
-        //              Type *objectType = objectDecl->get_type();
-        //              StructInstType *structType = dynamic_cast< StructInstType* >( objectType );
-        //              if ( structType ) return structType->get_baseStruct();
-        //              UnionInstType *unionType = dynamic_cast< UnionInstType* >( objectType );
-        //              if ( unionType ) return unionType->get_baseUnion();
-        //
-        //              return NULL;
-        //      }
-        //
-        //      /// Finds the declaration with the given name, returning decls.end() if none such
-        //      std::list< Declaration* >::const_iterator findDeclNamed( const std::list< Declaration* > &decls, const std::string &name ) {
-        //              for( std::list< Declaration* >::const_iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
-        //                      if ( (*decl)->get_name() == name ) return decl;
-        //              }
-        //              return decls.end();
-        //      }
-        //
-        //      Expression* Instantiate::mutate( MemberExpr *memberExpr ) {
-        //              // mutate, exiting early if no longer MemberExpr
-        //              Expression *expr = Mutator::mutate( memberExpr );
-        //              memberExpr = dynamic_cast< MemberExpr* >( expr );
-        //              if ( ! memberExpr ) return expr;
-        //
-        //              // get declaration of member and base declaration of member, exiting early if not found
-        //              AggregateDecl *memberBase = getMemberBaseDecl( memberExpr );
-        //              if ( ! memberBase ) return memberExpr;
-        //              DeclarationWithType *memberDecl = memberExpr->get_member();
-        //              std::list< Declaration* >::const_iterator baseIt = findDeclNamed( memberBase->get_members(), memberDecl->get_name() );
-        //              if ( baseIt == memberBase->get_members().end() ) return memberExpr;
-        //              DeclarationWithType *baseDecl = dynamic_cast< DeclarationWithType* >( *baseIt );
-        //              if ( ! baseDecl ) return memberExpr;
-        //
-        //              // check if stated type of the member is not the type of the member's declaration; if so, need a cast
-        //              // this *SHOULD* be safe, I don't think anything but the void-replacements I put in for dtypes would make it past the typechecker
-        //              SymTab::Indexer dummy;
-        //              if ( ResolvExpr::typesCompatible( memberDecl->get_type(), baseDecl->get_type(), dummy ) ) return memberExpr;
-        //              else return new CastExpr( memberExpr, memberDecl->get_type() );
-        //      }
-
-                void GenericInstantiator::doBeginScope() {
-                        DeclMutator::doBeginScope();
-                        instantiations.beginScope();
-                }
-
-                void GenericInstantiator::doEndScope() {
-                        DeclMutator::doEndScope();
-                        instantiations.endScope();
-                }
-
 ////////////////////////////////////////// MemberExprFixer ////////////////////////////////////////////////////
 

src/GenPoly/DeclMutator.cc

@@ -24 +24 @@
         }
 
-        DeclMutator::DeclMutator() : Mutator(), declsToAdd(1), declsToAddAfter(1) {}
+        DeclMutator::DeclMutator() : Mutator(), declsToAdd(1) {}
 
         DeclMutator::~DeclMutator() {}
         
         void DeclMutator::mutateDeclarationList( std::list< Declaration* > &decls ) {
-                for ( std::list< Declaration* >::iterator decl = decls.begin(); ; ++decl ) {
-                        // splice in new declarations after previous decl
-                        decls.splice( decl, declsToAddAfter.back() );
-
-                        if ( decl == decls.end() ) break;
-                        
+                for ( std::list< Declaration* >::iterator decl = decls.begin(); decl != decls.end(); ++decl ) {
                         // run mutator on declaration
                         *decl = maybeMutate( *decl, *this );
@@ -44 +39 @@
 
         void DeclMutator::doBeginScope() {
-                // add new decl lists for inside of scope
+                // add new decl list for inside of scope
                 declsToAdd.resize( declsToAdd.size()+1 );
-                declsToAddAfter.resize( declsToAddAfter.size()+1 );
         }
 
@@ -55 +49 @@
                 newBack->splice( newBack->end(), *back );
                 declsToAdd.pop_back();
-                
-                back = declsToAddAfter.rbegin();
-                newBack = back + 1;
-                newBack->splice( newBack->end(), *back );
-                declsToAddAfter.pop_back();
         }
 
@@ -72 +61 @@
                 stmt = maybeMutate( stmt, *this );
                 // return if no declarations to add
-                if ( declsToAdd.back().empty() && declsToAddAfter.back().empty() ) {
-                        doEndScope();
-                        return stmt;
-                }
+                if ( declsToAdd.back().empty() ) return stmt;
 
                 // otherwise add declarations to new compound statement
@@ -85 +71 @@
                 declsToAdd.back().clear();
 
-                // add mutated statement
+                doEndScope();
+
+                // add mutated statement and return
                 compound->get_kids().push_back( stmt );
-
-                // add declarations after to new compound statement
-                for ( std::list< Declaration* >::iterator decl = declsToAddAfter.back().begin(); decl != declsToAddAfter.back().end(); ++decl ) {
-                        DeclStmt *declStmt = new DeclStmt( noLabels, *decl );
-                        compound->get_kids().push_back( declStmt );
-                }
-                declsToAddAfter.back().clear();
-
-                doEndScope();
                 return compound;
         }
@@ -101 +80 @@
         void DeclMutator::mutateStatementList( std::list< Statement* > &stmts ) {
                 doBeginScope();
-
                 
-                for ( std::list< Statement* >::iterator stmt = stmts.begin(); ; ++stmt ) {
-                        // add any new declarations after the previous statement
-                        for ( std::list< Declaration* >::iterator decl = declsToAddAfter.back().begin(); decl != declsToAddAfter.back().end(); ++decl ) {
-                                DeclStmt *declStmt = new DeclStmt( noLabels, *decl );
-                                stmts.insert( stmt, declStmt );
-                        }
-                        declsToAddAfter.back().clear();
-
-                        if ( stmt == stmts.end() ) break;
-                        
+                for ( std::list< Statement* >::iterator stmt = stmts.begin(); stmt != stmts.end(); ++stmt ) {
                         // run mutator on statement
                         *stmt = maybeMutate( *stmt, *this );
@@ -123 +92 @@
                         declsToAdd.back().clear();
                 }
-                
+
                 doEndScope();
         }
@@ -129 +98 @@
         void DeclMutator::addDeclaration( Declaration *decl ) {
                 declsToAdd.back().push_back( decl );
-        }
-
-        void DeclMutator::addDeclarationAfter( Declaration *decl ) {
-                declsToAddAfter.back().push_back( decl );
         }
 

src/GenPoly/DeclMutator.h

@@ -55 +55 @@
                 /// Add a declaration to the list to be added before the current position
                 void addDeclaration( Declaration* decl );
-                /// Add a declaration to the list to be added after the current position
-                void addDeclarationAfter( Declaration* decl );
         private:
                 /// A stack of declarations to add before the current declaration or statement
                 std::vector< std::list< Declaration* > > declsToAdd;
-                /// A stack of declarations to add after the current declaration or statement
-                std::vector< std::list< Declaration* > > declsToAddAfter;
         };
 } // namespace

src/GenPoly/module.mk

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

src/Makefile.in

@@ -122 +122 @@
         GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \
+        GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \
         InitTweak/driver_cfa_cpp-RemoveInit.$(OBJEXT) \
@@ -153 +154 @@
         ResolvExpr/driver_cfa_cpp-Occurs.$(OBJEXT) \
         ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT) \
+        SymTab/driver_cfa_cpp-IdTable.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Mangler.$(OBJEXT) \
@@ -345 +347 @@
         GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
         GenPoly/CopyParams.cc GenPoly/FindFunction.cc \
-        GenPoly/DeclMutator.cc InitTweak/RemoveInit.cc \
-        Parser/parser.yy Parser/lex.ll Parser/TypedefTable.cc \
-        Parser/ParseNode.cc Parser/DeclarationNode.cc \
-        Parser/ExpressionNode.cc Parser/StatementNode.cc \
-        Parser/InitializerNode.cc Parser/TypeData.cc \
-        Parser/LinkageSpec.cc Parser/parseutility.cc Parser/Parser.cc \
+        GenPoly/InstantiateGeneric.cc GenPoly/DeclMutator.cc \
+        InitTweak/RemoveInit.cc Parser/parser.yy Parser/lex.ll \
+        Parser/TypedefTable.cc Parser/ParseNode.cc \
+        Parser/DeclarationNode.cc Parser/ExpressionNode.cc \
+        Parser/StatementNode.cc Parser/InitializerNode.cc \
+        Parser/TypeData.cc Parser/LinkageSpec.cc \
+        Parser/parseutility.cc Parser/Parser.cc \
         ResolvExpr/AlternativeFinder.cc ResolvExpr/Alternative.cc \
         ResolvExpr/Unify.cc ResolvExpr/PtrsAssignable.cc \
@@ -359 +362 @@
         ResolvExpr/RenameVars.cc ResolvExpr/FindOpenVars.cc \
         ResolvExpr/PolyCost.cc ResolvExpr/Occurs.cc \
-        ResolvExpr/TypeEnvironment.cc SymTab/Indexer.cc \
-        SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \
-        SymTab/ImplementationType.cc SymTab/TypeEquality.cc \
-        SynTree/Type.cc SynTree/VoidType.cc SynTree/BasicType.cc \
-        SynTree/PointerType.cc SynTree/ArrayType.cc \
-        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
-        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
+        ResolvExpr/TypeEnvironment.cc SymTab/IdTable.cc \
+        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
+        SymTab/FixFunction.cc SymTab/ImplementationType.cc \
+        SymTab/TypeEquality.cc SynTree/Type.cc SynTree/VoidType.cc \
+        SynTree/BasicType.cc SynTree/PointerType.cc \
+        SynTree/ArrayType.cc SynTree/FunctionType.cc \
+        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
+        SynTree/TypeofType.cc SynTree/AttrType.cc \
         SynTree/VarArgsType.cc SynTree/Constant.cc \
         SynTree/Expression.cc SynTree/TupleExpr.cc \
@@ -552 +556 @@
         GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT):  \
+        GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
+GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT):  \
         GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
@@ -658 +664 @@
         @$(MKDIR_P) SymTab/$(DEPDIR)
         @: > SymTab/$(DEPDIR)/$(am__dirstamp)
+SymTab/driver_cfa_cpp-IdTable.$(OBJEXT): SymTab/$(am__dirstamp) \
+        SymTab/$(DEPDIR)/$(am__dirstamp)
 SymTab/driver_cfa_cpp-Indexer.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
@@ -788 +796 @@
         -rm -f GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT)
         -rm -f GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT)
+        -rm -f GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT)
         -rm -f GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT)
         -rm -f GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT)
@@ -823 +832 @@
         -rm -f ResolvExpr/driver_cfa_cpp-Unify.$(OBJEXT)
         -rm -f SymTab/driver_cfa_cpp-FixFunction.$(OBJEXT)
+        -rm -f SymTab/driver_cfa_cpp-IdTable.$(OBJEXT)
         -rm -f SymTab/driver_cfa_cpp-ImplementationType.$(OBJEXT)
         -rm -f SymTab/driver_cfa_cpp-Indexer.$(OBJEXT)
@@ -893 +903 @@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Lvalue.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po@am__quote@
@@ -928 +939 @@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Unify.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-FixFunction.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Po@am__quote@
@@ -1352 +1364 @@
 @am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-FindFunction.obj `if test -f 'GenPoly/FindFunction.cc'; then $(CYGPATH_W) 'GenPoly/FindFunction.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/FindFunction.cc'; fi`
 
+GenPoly/driver_cfa_cpp-InstantiateGeneric.o: GenPoly/InstantiateGeneric.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc
+@am__fastdepCXX_TRUE@   $(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='GenPoly/InstantiateGeneric.cc' object='GenPoly/driver_cfa_cpp-InstantiateGeneric.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc
+
+GenPoly/driver_cfa_cpp-InstantiateGeneric.obj: GenPoly/InstantiateGeneric.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.obj `if test -f 'GenPoly/InstantiateGeneric.cc'; then $(CYGPATH_W) 'GenPoly/InstantiateGeneric.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/InstantiateGeneric.cc'; fi`
+@am__fastdepCXX_TRUE@   $(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='GenPoly/InstantiateGeneric.cc' object='GenPoly/driver_cfa_cpp-InstantiateGeneric.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.obj `if test -f 'GenPoly/InstantiateGeneric.cc'; then $(CYGPATH_W) 'GenPoly/InstantiateGeneric.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/InstantiateGeneric.cc'; fi`
+
 GenPoly/driver_cfa_cpp-DeclMutator.o: GenPoly/DeclMutator.cc
 @am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
@@ -1785 +1811 @@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-TypeEnvironment.obj `if test -f 'ResolvExpr/TypeEnvironment.cc'; then $(CYGPATH_W) 'ResolvExpr/TypeEnvironment.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/TypeEnvironment.cc'; fi`
+
+SymTab/driver_cfa_cpp-IdTable.o: SymTab/IdTable.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-IdTable.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Tpo -c -o SymTab/driver_cfa_cpp-IdTable.o `test -f 'SymTab/IdTable.cc' || echo '$(srcdir)/'`SymTab/IdTable.cc
+@am__fastdepCXX_TRUE@   $(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='SymTab/IdTable.cc' object='SymTab/driver_cfa_cpp-IdTable.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-IdTable.o `test -f 'SymTab/IdTable.cc' || echo '$(srcdir)/'`SymTab/IdTable.cc
+
+SymTab/driver_cfa_cpp-IdTable.obj: SymTab/IdTable.cc
+@am__fastdepCXX_TRUE@   $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-IdTable.obj -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Tpo -c -o SymTab/driver_cfa_cpp-IdTable.obj `if test -f 'SymTab/IdTable.cc'; then $(CYGPATH_W) 'SymTab/IdTable.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/IdTable.cc'; fi`
+@am__fastdepCXX_TRUE@   $(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-IdTable.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      source='SymTab/IdTable.cc' object='SymTab/driver_cfa_cpp-IdTable.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-IdTable.obj `if test -f 'SymTab/IdTable.cc'; then $(CYGPATH_W) 'SymTab/IdTable.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/IdTable.cc'; fi`
 
 SymTab/driver_cfa_cpp-Indexer.o: SymTab/Indexer.cc

src/SymTab/Indexer.cc

@@ -14 +14 @@
 //
 
-#include "Indexer.h"
-
-#include <string>
-#include <typeinfo>
-#include <unordered_map>
-#include <utility>
-
-#include "Mangler.h"
-
-#include "Common/utility.h"
-
-#include "ResolvExpr/typeops.h"
-
 #include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
@@ -32 +19 @@
 #include "SynTree/Initializer.h"
 #include "SynTree/Statement.h"
+#include "Indexer.h"
+#include <typeinfo>
+#include "Common/utility.h"
 
 #define debugPrint(x) if ( doDebug ) { std::cout << x; }
@@ -43 +33 @@
         }
 
-        typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable;
-        typedef std::unordered_map< std::string, MangleTable > IdTable;
-        typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable;
-        typedef std::unordered_map< std::string, StructDecl* > StructTable;
-        typedef std::unordered_map< std::string, EnumDecl* > EnumTable;
-        typedef std::unordered_map< std::string, UnionDecl* > UnionTable;
-        typedef std::unordered_map< std::string, TraitDecl* > TraitTable;
-
-        void dump( const IdTable &table, std::ostream &os ) {
-                for ( IdTable::const_iterator id = table.begin(); id != table.end(); ++id ) {
-                        for ( MangleTable::const_iterator mangle = id->second.begin(); mangle != id->second.end(); ++mangle ) {
-                                os << mangle->second << std::endl;
-                        }
-                }
-        }
-        
-        template< typename Decl >
-        void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) {
-                for ( typename std::unordered_map< std::string, Decl* >::const_iterator it = table.begin(); it != table.end(); ++it ) {
-                        os << it->second << std::endl;
-                } // for
-        }
-        
-        struct Indexer::Impl {
-                Impl( unsigned long _scope ) : refCount(1), scope( _scope ), size( 0 ), base(),
-                                idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
-                Impl( unsigned long _scope, Indexer &&_base ) : refCount(1), scope( _scope ), size( 0 ), base( _base ),
-                                idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
-                unsigned long refCount;   ///< Number of references to these tables
-                unsigned long scope;      ///< Scope these tables are associated with
-                unsigned long size;       ///< Number of elements stored in this table
-                const Indexer base;       ///< Base indexer this extends
-                
-                IdTable idTable;          ///< Identifier namespace
-                TypeTable typeTable;      ///< Type namespace
-                StructTable structTable;  ///< Struct namespace
-                EnumTable enumTable;      ///< Enum namespace
-                UnionTable unionTable;    ///< Union namespace
-                TraitTable traitTable;    ///< Trait namespace
-        };
-
-        Indexer::Impl *Indexer::newRef( Indexer::Impl *toClone ) {
-                if ( ! toClone ) return 0;
-
-                // shorten the search chain by skipping empty links
-                Indexer::Impl *ret = toClone->size == 0 ? toClone->base.tables : toClone;
-                if ( ret ) { ++ret->refCount; }
-
-                return ret;
-        }
-
-        void Indexer::deleteRef( Indexer::Impl *toFree ) {
-                if ( ! toFree ) return;
-
-                if ( --toFree->refCount == 0 ) delete toFree;
-        }
-
-        void Indexer::makeWritable() {
-                if ( ! tables ) {
-                        // create indexer if not yet set
-                        tables = new Indexer::Impl( scope );
-                } else if ( tables->refCount > 1 || tables->scope != scope ) {
-                        // make this indexer the base of a fresh indexer at the current scope
-                        tables = new Indexer::Impl( scope, std::move( *this ) );
-                }
-        }
-
-        Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {}
-
-        Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {}
-
-        Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) {
-                that.tables = 0;
-        }
-
-        Indexer::~Indexer() {
-                deleteRef( tables );
-        }
-
-        Indexer& Indexer::operator= ( const Indexer &that ) {
-                deleteRef( tables );
-
-                tables = newRef( that.tables );
-                scope = that.scope;
-                doDebug = that.doDebug;
-
-                return *this;
-        }
-
-        Indexer& Indexer::operator= ( Indexer &&that ) {
-                deleteRef( tables );
-
-                tables = that.tables;
-                scope = that.scope;
-                doDebug = that.doDebug;
-
-                that.tables = 0;
-
-                return *this;
-        }
+        Indexer::Indexer( bool useDebug ) : doDebug( useDebug ) {}
+
+        Indexer::~Indexer() {}
 
         void Indexer::visit( ObjectDecl *objectDecl ) {
@@ -152 +45 @@
                 if ( objectDecl->get_name() != "" ) {
                         debugPrint( "Adding object " << objectDecl->get_name() << std::endl );
-                        addId( objectDecl );
+                        idTable.addDecl( objectDecl );
                 } // if
         }
@@ -159 +52 @@
                 if ( functionDecl->get_name() == "" ) return;
                 debugPrint( "Adding function " << functionDecl->get_name() << std::endl );
-                addId( functionDecl );
+                idTable.addDecl( functionDecl );
                 enterScope();
                 maybeAccept( functionDecl->get_functionType(), *this );
@@ -197 +90 @@
                 leaveScope();
                 debugPrint( "Adding type " << typeDecl->get_name() << std::endl );
-                addType( typeDecl );
+                typeTable.add( typeDecl );
                 acceptAll( typeDecl->get_assertions(), *this );
         }
@@ -207 +100 @@
                 leaveScope();
                 debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl );
-                addType( typeDecl );
+                typeTable.add( typeDecl );
         }
 
@@ -215 +108 @@
                 cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
                 debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl );
-                addStruct( &fwdDecl );
+                structTable.add( &fwdDecl );
   
                 enterScope();
@@ -224 +117 @@
                 debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl );
                 // this addition replaces the forward declaration
-                addStruct( aggregateDecl );
+                structTable.add( aggregateDecl );
         }
 
@@ -232 +125 @@
                 cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
                 debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl );
-                addUnion( &fwdDecl );
+                unionTable.add( &fwdDecl );
   
                 enterScope();
@@ -240 +133 @@
   
                 debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl );
-                addUnion( aggregateDecl );
+                unionTable.add( aggregateDecl );
         }
 
         void Indexer::visit( EnumDecl *aggregateDecl ) {
                 debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl );
-                addEnum( aggregateDecl );
+                enumTable.add( aggregateDecl );
                 // unlike structs, contexts, and unions, enums inject their members into the global scope
                 acceptAll( aggregateDecl->get_members(), *this );
@@ -257 +150 @@
   
                 debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl );
-                addTrait( aggregateDecl );
+                contextTable.add( aggregateDecl );
         }
 
@@ -406 +299 @@
 
         void Indexer::visit( StructInstType *structInst ) {
-                if ( ! lookupStruct( structInst->get_name() ) ) {
+                if ( ! structTable.lookup( structInst->get_name() ) ) {
                         debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl );
-                        addStruct( structInst->get_name() );
+                        structTable.add( structInst->get_name() );
                 }
                 enterScope();
@@ -416 +309 @@
 
         void Indexer::visit( UnionInstType *unionInst ) {
-                if ( ! lookupUnion( unionInst->get_name() ) ) {
+                if ( ! unionTable.lookup( unionInst->get_name() ) ) {
                         debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl );
-                        addUnion( unionInst->get_name() );
+                        unionTable.add( unionInst->get_name() );
                 }
                 enterScope();
@@ -432 +325 @@
         }
 
-        
-
-        void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const {
-                if ( ! tables ) return;
-
-                IdTable::const_iterator decls = tables->idTable.find( id );
-                if ( decls != tables->idTable.end() ) {
-                        const MangleTable &mangleTable = decls->second;
-                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                out.push_back( decl->second );
-                        }
-                }
-                
-                // get declarations from base indexers
-                tables->base.lookupId( id, out );
+
+        void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &list ) const {
+                idTable.lookupId( id, list );
+        }
+
+        DeclarationWithType* Indexer::lookupId( const std::string &id) const {
+                return idTable.lookupId(id);
         }
 
         NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                TypeTable::const_iterator ret = tables->typeTable.find( id );
-                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupType( id );
+                return typeTable.lookup( id );
         }
 
         StructDecl *Indexer::lookupStruct( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                StructTable::const_iterator ret = tables->structTable.find( id );
-                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStruct( id );
+                return structTable.lookup( id );
         }
 
         EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                EnumTable::const_iterator ret = tables->enumTable.find( id );
-                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnum( id );
+                return enumTable.lookup( id );
         }
 
         UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                UnionTable::const_iterator ret = tables->unionTable.find( id );
-                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnion( id );
-        }
-
-        TraitDecl *Indexer::lookupTrait( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                TraitTable::const_iterator ret = tables->traitTable.find( id );
-                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTrait( id );
-        }
-
-        DeclarationWithType *Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                IdTable::const_iterator decls = tables->idTable.find( id );
-                if ( decls != tables->idTable.end() ) {
-                        const MangleTable &mangleTable = decls->second;
-                        MangleTable::const_iterator decl = mangleTable.find( mangleName );
-                        if ( decl != mangleTable.end() ) return decl->second;
-                }
-
-                return tables->base.lookupIdAtScope( id, mangleName, scope );
-        }
-
-        bool Indexer::hasCDeclWithName( const std::string &id ) const {
-                if ( ! tables ) return false;
-
-                IdTable::const_iterator decls = tables->idTable.find( id );
-                if ( decls != tables->idTable.end() ) {
-                        const MangleTable &mangleTable = decls->second;
-                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                if ( decl->second->get_linkage() == LinkageSpec::C ) return true;
-                        }
-                }
-
-                return tables->base.hasCDeclWithName( id );
-        }
-        
-        NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                TypeTable::const_iterator ret = tables->typeTable.find( id );
-                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupTypeAtScope( id, scope );
-        }
-        
-        StructDecl *Indexer::lookupStructAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                StructTable::const_iterator ret = tables->structTable.find( id );
-                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStructAtScope( id, scope );
-        }
-        
-        EnumDecl *Indexer::lookupEnumAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                EnumTable::const_iterator ret = tables->enumTable.find( id );
-                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnumAtScope( id, scope );
-        }
-        
-        UnionDecl *Indexer::lookupUnionAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                UnionTable::const_iterator ret = tables->unionTable.find( id );
-                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnionAtScope( id, scope );
-        }
-        
-        TraitDecl *Indexer::lookupTraitAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                TraitTable::const_iterator ret = tables->traitTable.find( id );
-                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTraitAtScope( id, scope );
-        }
-
-        bool addedIdConflicts( DeclarationWithType *existing, DeclarationWithType *added ) {
-                // if we're giving the same name mangling to things of different types then there is something wrong
-                assert( (dynamic_cast<ObjectDecl*>( added ) && dynamic_cast<ObjectDecl*>( existing ) )
-                        || (dynamic_cast<FunctionDecl*>( added ) && dynamic_cast<FunctionDecl*>( existing ) ) );
-
-                if ( LinkageSpec::isOverridable( existing->get_linkage() ) ) {
-                        // new definition shadows the autogenerated one, even at the same scope
-                        return false;
-                } else if ( added->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( added->get_type(), existing->get_type(), Indexer() ) ) {
-                        // typesCompatible doesn't really do the right thing here. When checking compatibility of function types,
-                        // we should ignore outermost pointer qualifiers, except _Atomic?
-                        FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( added );
-                        FunctionDecl *oldentry = dynamic_cast< FunctionDecl* >( existing );
-                        if ( newentry && oldentry ) {
-                                if ( newentry->get_statements() && oldentry->get_statements() ) {
-                                        throw SemanticError( "duplicate function definition for ", added );
-                                } // if
-                        } else {
-                                // two objects with the same mangled name defined in the same scope.
-                                // both objects must be marked extern or both must be intrinsic for this to be okay
-                                // xxx - perhaps it's actually if either is intrinsic then this is okay?
-                                //       might also need to be same storage class?
-                                ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( added );
-                                ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( existing );
-                                if ( newobj->get_storageClass() != DeclarationNode::Extern && oldobj->get_storageClass() != DeclarationNode::Extern ) {
-                                        throw SemanticError( "duplicate object definition for ", added );
-                                } // if
-                        } // if
-                } else {
-                        throw SemanticError( "duplicate definition for ", added );
-                } // if
-
-                return true;
-        }
-        
-        void Indexer::addId( DeclarationWithType *decl ) {
-                makeWritable();
-
-                const std::string &name = decl->get_name();
-                std::string mangleName;
-                if ( decl->get_linkage() == LinkageSpec::C ) {
-                        mangleName = name;
-                } else if ( LinkageSpec::isOverridable( decl->get_linkage() ) ) {
-                        // mangle the name without including the appropriate suffix, so overridable routines are placed into the
-                        // same "bucket" as their user defined versions.
-                        mangleName = Mangler::mangle( decl, false );
-                } else {
-                        mangleName = Mangler::mangle( decl );
-                } // if
-
-                DeclarationWithType *existing = lookupIdAtScope( name, mangleName, scope );
-                if ( ! existing || ! addedIdConflicts( existing, decl ) ) {
-                        // this ensures that no two declarations with the same unmangled name both have C linkage
-                        if ( decl->get_linkage() == LinkageSpec::C && hasCDeclWithName( name ) ) {
-                                throw SemanticError( "invalid overload of C function ", decl );
-                        }
-                        
-                        tables->idTable[ name ][ mangleName ] = decl;
-                        ++tables->size;
-                }
-        }
-
-        bool addedTypeConflicts( NamedTypeDecl *existing, NamedTypeDecl *added ) {
-                if ( existing->get_base() == 0 ) {
-                        return false;
-                } else if ( added->get_base() == 0 ) {
-                        return true;
-                } else {
-                        throw SemanticError( "redeclaration of ", added );
-                }
-        }
-        
-        void Indexer::addType( NamedTypeDecl *decl ) {
-                makeWritable();
-
-                const std::string &id = decl->get_name();
-                TypeTable::iterator existing = tables->typeTable.find( id );
-                if ( existing == tables->typeTable.end() ) {
-                        NamedTypeDecl *parent = tables->base.lookupTypeAtScope( id, scope );
-                        if ( ! parent || ! addedTypeConflicts( parent, decl ) ) {
-                                tables->typeTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedTypeConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
-        }
-
-        bool addedDeclConflicts( AggregateDecl *existing, AggregateDecl *added ) {
-                if ( existing->get_members().empty() ) {
-                        return false;
-                } else if ( ! added->get_members().empty() ) {
-                        throw SemanticError( "redeclaration of ", added );
-                } // if
-                return true;
-        }
-
-        void Indexer::addStruct( const std::string &id ) {
-                addStruct( new StructDecl( id ) );
-        }
-        
-        void Indexer::addStruct( StructDecl *decl ) {
-                makeWritable();
-
-                const std::string &id = decl->get_name();
-                StructTable::iterator existing = tables->structTable.find( id );
-                if ( existing == tables->structTable.end() ) {
-                        StructDecl *parent = tables->base.lookupStructAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->structTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
-        }
-        
-        void Indexer::addEnum( EnumDecl *decl ) {
-                makeWritable();
-
-                const std::string &id = decl->get_name();
-                EnumTable::iterator existing = tables->enumTable.find( id );
-                if ( existing == tables->enumTable.end() ) {
-                        EnumDecl *parent = tables->base.lookupEnumAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->enumTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
-        }
-
-        void Indexer::addUnion( const std::string &id ) {
-                addUnion( new UnionDecl( id ) );
-        }
-        
-        void Indexer::addUnion( UnionDecl *decl ) {
-                makeWritable();
-
-                const std::string &id = decl->get_name();
-                UnionTable::iterator existing = tables->unionTable.find( id );
-                if ( existing == tables->unionTable.end() ) {
-                        UnionDecl *parent = tables->base.lookupUnionAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->unionTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
-        }
-        
-        void Indexer::addTrait( TraitDecl *decl ) {
-                makeWritable();
-
-                const std::string &id = decl->get_name();
-                TraitTable::iterator existing = tables->traitTable.find( id );
-                if ( existing == tables->traitTable.end() ) {
-                        TraitDecl *parent = tables->base.lookupTraitAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->traitTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
+                return unionTable.lookup( id );
+        }
+
+        TraitDecl  * Indexer::lookupTrait( const std::string &id ) const {
+                return contextTable.lookup( id );
         }
 
         void Indexer::enterScope() {
-                ++scope;
-                
                 if ( doDebug ) {
-                        std::cout << "--- Entering scope " << scope << std::endl;
-                }
+                        std::cout << "--- Entering scope" << std::endl;
+                }
+                idTable.enterScope();
+                typeTable.enterScope();
+                structTable.enterScope();
+                enumTable.enterScope();
+                unionTable.enterScope();
+                contextTable.enterScope();
         }
 
         void Indexer::leaveScope() {
                 using std::cout;
-
-                assert( scope > 0 && "cannot leave initial scope" );
-                --scope;
-
-                while ( tables && tables->scope > scope ) {
-                        if ( doDebug ) {
-                                cout << "--- Leaving scope " << tables->scope << " containing" << std::endl;
-                                dump( tables->idTable, cout );
-                                dump( tables->typeTable, cout );
-                                dump( tables->structTable, cout );
-                                dump( tables->enumTable, cout );
-                                dump( tables->unionTable, cout );
-                                dump( tables->traitTable, cout );
-                        }
-
-                        // swap tables for base table until we find one at an appropriate scope
-                        Indexer::Impl *base = newRef( tables->base.tables );
-                        deleteRef( tables );
-                        tables = base;
-                }
+                using std::endl;
+  
+                if ( doDebug ) {
+                        cout << "--- Leaving scope containing" << endl;
+                        idTable.dump( cout );
+                        typeTable.dump( cout );
+                        structTable.dump( cout );
+                        enumTable.dump( cout );
+                        unionTable.dump( cout );
+                        contextTable.dump( cout );
+                }
+                idTable.leaveScope();
+                typeTable.leaveScope();
+                structTable.leaveScope();
+                enumTable.leaveScope();
+                unionTable.leaveScope();
+                contextTable.leaveScope();
         }
 
         void Indexer::print( std::ostream &os, int indent ) const {
             using std::cerr;
-
-            cerr << "===idTable===" << std::endl;
-            if ( tables ) dump( tables->idTable, os );
-            cerr << "===typeTable===" << std::endl;
-            if ( tables ) dump( tables->typeTable, os );
-            cerr << "===structTable===" << std::endl;
-            if ( tables ) dump( tables->structTable, os );
-            cerr << "===enumTable===" << std::endl;
-            if ( tables ) dump( tables->enumTable, os );
-            cerr << "===unionTable===" << std::endl;
-            if ( tables ) dump( tables->unionTable, os );
-            cerr << "===contextTable===" << std::endl;
-            if ( tables ) dump( tables->traitTable, os );
+            using std::endl;
+
+            cerr << "===idTable===" << endl;
+            idTable.dump( os );
+            cerr << "===typeTable===" << endl;
+            typeTable.dump( os );
+            cerr << "===structTable===" << endl;
+            structTable.dump( os );
+            cerr << "===enumTable===" << endl;
+            enumTable.dump( os );
+            cerr << "===unionTable===" << endl;
+            unionTable.dump( os );
+            cerr << "===contextTable===" << endl;
+            contextTable.dump( os );
+#if 0
+                idTable.dump( os );
+                typeTable.dump( os );
+                structTable.dump( os );
+                enumTable.dump( os );
+                unionTable.dump( os );
+                contextTable.dump( os );
+#endif
         }
 } // namespace SymTab

src/SymTab/Indexer.h

@@ -21 +21 @@
 
 #include "SynTree/Visitor.h"
+#include "IdTable.h"
+#include "AggregateTable.h"
+#include "TypeTable.h"
 
 namespace SymTab {
@@ -26 +29 @@
           public:
                 Indexer( bool useDebug = false );
-
-                Indexer( const Indexer &that );
-                Indexer( Indexer &&that );
                 virtual ~Indexer();
-                Indexer& operator= ( const Indexer &that );
-                Indexer& operator= ( Indexer &&that );
 
                 //using Visitor::visit;
@@ -80 +78 @@
                 void leaveScope();
 
-                /// Gets all declarations with the given ID
-                void lookupId( const std::string &id, std::list< DeclarationWithType* > &out ) const;
-                /// Gets the top-most type declaration with the given ID
+                void lookupId( const std::string &id, std::list< DeclarationWithType* >& ) const;
+                DeclarationWithType* lookupId( const std::string &id) const;
                 NamedTypeDecl *lookupType( const std::string &id ) const;
-                /// Gets the top-most struct declaration with the given ID
                 StructDecl *lookupStruct( const std::string &id ) const;
-                /// Gets the top-most enum declaration with the given ID
                 EnumDecl *lookupEnum( const std::string &id ) const;
-                /// Gets the top-most union declaration with the given ID
                 UnionDecl *lookupUnion( const std::string &id ) const;
-                /// Gets the top-most trait declaration with the given ID
                 TraitDecl *lookupTrait( const std::string &id ) const;
   
                 void print( std::ostream &os, int indent = 0 ) const;
           private:
-                /// looks up a specific mangled ID at the given scope
-                DeclarationWithType *lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
-                /// returns true if there exists a declaration with C linkage and the given name
-                bool hasCDeclWithName( const std::string &id ) const;
-                // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope)
-                NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const;
-                StructDecl *lookupStructAtScope( const std::string &id, unsigned long scope ) const;
-                EnumDecl *lookupEnumAtScope( const std::string &id, unsigned long scope ) const;
-                UnionDecl *lookupUnionAtScope( const std::string &id, unsigned long scope ) const;
-                TraitDecl *lookupTraitAtScope( const std::string &id, unsigned long scope ) const;
-                
-                void addId( DeclarationWithType *decl );
-                void addType( NamedTypeDecl *decl );
-                void addStruct( const std::string &id );
-                void addStruct( StructDecl *decl );
-                void addEnum( EnumDecl *decl );
-                void addUnion( const std::string &id );
-                void addUnion( UnionDecl *decl );
-                void addTrait( TraitDecl *decl );
-                
-                struct Impl;
-                Impl *tables;         ///< Copy-on-write instance of table data structure
-                unsigned long scope;  ///< Scope index of this pointer
-                bool doDebug;         ///< Display debugging trace?
-
-                /// Takes a new ref to a table (returns null if null)
-                static Impl *newRef( Impl *toClone );
-                /// Clears a ref to a table (does nothing if null)
-                static void deleteRef( Impl *toFree );
-
-                /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)
-                void makeWritable();
+                IdTable idTable;
+                TypeTable typeTable;
+                StructTable structTable;
+                EnumTable enumTable;
+                UnionTable unionTable;
+                TraitTable contextTable;
+  
+                bool doDebug;                                   // display debugging trace
         };
 } // namespace SymTab

src/SymTab/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += SymTab/Indexer.cc \
+SRC += SymTab/IdTable.cc \
+       SymTab/Indexer.cc \
        SymTab/Mangler.cc \
        SymTab/Validate.cc \

src/SynTree/Constant.cc

@@ -16 +16 @@
 #include <iostream>
 #include <list>
-#include <string>
 
 #include "Constant.h"
@@ -29 +28 @@
 
 Constant::~Constant() { delete type; }
-
-Constant Constant::from( int i ) {
-        return Constant( new BasicType( Type::Qualifiers(), BasicType::SignedInt ), std::to_string( i ) );
-}
-
-Constant Constant::from( unsigned long i ) {
-        return Constant( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), std::to_string( i ) );
-}
-
-Constant Constant::from( double d ) {
-        return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ) );
-}
 
 Constant *Constant::clone() const { assert( false ); return 0; }

src/SynTree/Constant.h

@@ -32 +32 @@
         void set_value( std::string newValue ) { value = newValue; }
 
-        /// generates an integer constant of the given int
-        static Constant from( int i );
-        /// generates an integer constant of the given unsigned long int
-        static Constant from( unsigned long i );
-        /// generates a floating point constant of the given double
-        static Constant from( double d );
-
         virtual Constant *clone() const;
         virtual void accept( Visitor &v ) { v.visit( this ); }