Index: translator/SymTab/IdTable.cc
===================================================================
--- translator/SymTab/IdTable.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/IdTable.cc	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -139,5 +139,5 @@
 				std::stack<DeclEntry> stack = inner->second;
 				os << "dumping a stack" << std::endl;
-				while (! stack.empty()) {
+				while ( ! stack.empty()) {
 					DeclEntry d = stack.top();
 					os << outer->first << " (" << inner->first << ") (" << d.second << ") " << std::endl;
Index: translator/SymTab/IdTable.h
===================================================================
--- translator/SymTab/IdTable.h	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/IdTable.h	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:30:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 21:31:45 2015
-// Update Count     : 3
+// Last Modified On : Tue May 19 16:49:33 2015
+// Update Count     : 4
 //
 
@@ -25,6 +25,6 @@
 
 namespace SymTab {
-    class IdTable {
-      public:
+	class IdTable {
+	  public:
 		IdTable();
   
@@ -36,5 +36,5 @@
   
 		void dump( std::ostream &os ) const;			// debugging
-      private:
+	  private:
 		typedef std::pair< DeclarationWithType*, int > DeclEntry;
 		typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType;
@@ -43,5 +43,5 @@
 		OuterTableType table;
 		int scopeLevel;
-    };
+	};
 } // namespace SymTab
 
Index: translator/SymTab/Indexer.cc
===================================================================
--- translator/SymTab/Indexer.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/Indexer.cc	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:37:33 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 21:38:44 2015
-// Update Count     : 2
+// Last Modified On : Tue May 19 16:49:55 2015
+// Update Count     : 3
 //
 
@@ -26,9 +26,9 @@
 
 namespace SymTab {
-    Indexer::Indexer( bool useDebug ) : doDebug( useDebug ) {}
-
-    Indexer::~Indexer() {}
-
-    void Indexer::visit( ObjectDecl *objectDecl ) {
+	Indexer::Indexer( bool useDebug ) : doDebug( useDebug ) {}
+
+	Indexer::~Indexer() {}
+
+	void Indexer::visit( ObjectDecl *objectDecl ) {
 		maybeAccept( objectDecl->get_type(), *this );
 		maybeAccept( objectDecl->get_init(), *this );
@@ -38,7 +38,7 @@
 			idTable.addDecl( objectDecl );
 		} // if
-    }
-
-    void Indexer::visit( FunctionDecl *functionDecl ) {
+	}
+
+	void Indexer::visit( FunctionDecl *functionDecl ) {
 		if ( functionDecl->get_name() == "" ) return;
 		debugPrint( "Adding function " << functionDecl->get_name() << std::endl );
@@ -49,5 +49,5 @@
 		maybeAccept( functionDecl->get_statements(), *this );
 		leaveScope();
-    }
+	}
 
 /********
@@ -70,5 +70,5 @@
  */
 
-    void Indexer::visit( TypeDecl *typeDecl ) {
+	void Indexer::visit( TypeDecl *typeDecl ) {
 		// see A NOTE ON THE ORDER OF TRAVERSAL, above
 		// note that assertions come after the type is added to the symtab, since they aren't part
@@ -81,7 +81,7 @@
 		typeTable.add( typeDecl );
 		acceptAll( typeDecl->get_assertions(), *this );
-    }
-
-    void Indexer::visit( TypedefDecl *typeDecl ) {
+	}
+
+	void Indexer::visit( TypedefDecl *typeDecl ) {
 		enterScope();
 		acceptAll( typeDecl->get_parameters(), *this );
@@ -90,7 +90,7 @@
 		debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl );
 		typeTable.add( typeDecl );
-    }
-
-    void Indexer::visit( StructDecl *aggregateDecl ) {
+	}
+
+	void Indexer::visit( StructDecl *aggregateDecl ) {
 		// make up a forward declaration and add it before processing the members
 		StructDecl fwdDecl( aggregateDecl->get_name() );
@@ -107,7 +107,7 @@
 		// this addition replaces the forward declaration
 		structTable.add( aggregateDecl );
-    }
-
-    void Indexer::visit( UnionDecl *aggregateDecl ) {
+	}
+
+	void Indexer::visit( UnionDecl *aggregateDecl ) {
 		// make up a forward declaration and add it before processing the members
 		UnionDecl fwdDecl( aggregateDecl->get_name() );
@@ -123,14 +123,14 @@
 		debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl );
 		unionTable.add( aggregateDecl );
-    }
-
-    void Indexer::visit( EnumDecl *aggregateDecl ) {
+	}
+
+	void Indexer::visit( EnumDecl *aggregateDecl ) {
 		debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl );
 		enumTable.add( aggregateDecl );
 		// unlike structs, contexts, and unions, enums inject their members into the global scope
 		acceptAll( aggregateDecl->get_members(), *this );
-    }
-
-    void Indexer::visit( ContextDecl *aggregateDecl ) {
+	}
+
+	void Indexer::visit( ContextDecl *aggregateDecl ) {
 		enterScope();
 		acceptAll( aggregateDecl->get_parameters(), *this );
@@ -140,18 +140,18 @@
 		debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl );
 		contextTable.add( aggregateDecl );
-    }
-
-    void Indexer::visit( CompoundStmt *compoundStmt ) {
+	}
+
+	void Indexer::visit( CompoundStmt *compoundStmt ) {
 		enterScope();
 		acceptAll( compoundStmt->get_kids(), *this );
 		leaveScope();
-    }
-
-    void Indexer::visit( ContextInstType *contextInst ) {
+	}
+
+	void Indexer::visit( ContextInstType *contextInst ) {
 		acceptAll( contextInst->get_parameters(), *this );
 		acceptAll( contextInst->get_members(), *this );
-    }
-
-    void Indexer::visit( StructInstType *structInst ) {
+	}
+
+	void Indexer::visit( StructInstType *structInst ) {
 		if ( ! structTable.lookup( structInst->get_name() ) ) {
 			debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl );
@@ -161,7 +161,7 @@
 		acceptAll( structInst->get_parameters(), *this );
 		leaveScope();
-    }
-
-    void Indexer::visit( UnionInstType *unionInst ) {
+	}
+
+	void Indexer::visit( UnionInstType *unionInst ) {
 		if ( ! unionTable.lookup( unionInst->get_name() ) ) {
 			debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl );
@@ -171,43 +171,43 @@
 		acceptAll( unionInst->get_parameters(), *this );
 		leaveScope();
-    }
-
-    void Indexer::visit( ForStmt *forStmt ) {
-        // for statements introduce a level of scope
-        enterScope();
-        Visitor::visit( forStmt );
-        leaveScope();
-    }
-
-
-    void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &list ) const {
+	}
+
+	void Indexer::visit( ForStmt *forStmt ) {
+	    // for statements introduce a level of scope
+	    enterScope();
+	    Visitor::visit( forStmt );
+	    leaveScope();
+	}
+
+
+	void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &list ) const {
 		idTable.lookupId( id, list );
-    }
-
-    DeclarationWithType* Indexer::lookupId( const std::string &id) const {
+	}
+
+	DeclarationWithType* Indexer::lookupId( const std::string &id) const {
 		return idTable.lookupId(id);
-    }
-
-    NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
+	}
+
+	NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
 		return typeTable.lookup( id );
-    }
-
-    StructDecl *Indexer::lookupStruct( const std::string &id ) const {
+	}
+
+	StructDecl *Indexer::lookupStruct( const std::string &id ) const {
 		return structTable.lookup( id );
-    }
-
-    EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
+	}
+
+	EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
 		return enumTable.lookup( id );
-    }
-
-    UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
+	}
+
+	UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
 		return unionTable.lookup( id );
-    }
-
-    ContextDecl  * Indexer::lookupContext( const std::string &id ) const {
+	}
+
+	ContextDecl  * Indexer::lookupContext( const std::string &id ) const {
 		return contextTable.lookup( id );
-    }
-
-    void Indexer::enterScope() {
+	}
+
+	void Indexer::enterScope() {
 		if ( doDebug ) {
 			std::cout << "--- Entering scope" << std::endl;
@@ -219,7 +219,7 @@
 		unionTable.enterScope();
 		contextTable.enterScope();
-    }
-
-    void Indexer::leaveScope() {
+	}
+
+	void Indexer::leaveScope() {
 		using std::cout;
 		using std::endl;
@@ -240,22 +240,22 @@
 		unionTable.leaveScope();
 		contextTable.leaveScope();
-    }
-
-    void Indexer::print( std::ostream &os, int indent ) const {
-        using std::cerr;
-        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 );
+	}
+
+	void Indexer::print( std::ostream &os, int indent ) const {
+	    using std::cerr;
+	    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 );
@@ -266,5 +266,5 @@
 		contextTable.dump( os );
 #endif
-    }
+	}
 } // namespace SymTab
 
Index: translator/SymTab/Indexer.h
===================================================================
--- translator/SymTab/Indexer.h	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/Indexer.h	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:38:55 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 21:40:17 2015
-// Update Count     : 2
+// Last Modified On : Tue May 19 16:51:21 2015
+// Update Count     : 3
 //
 
@@ -27,51 +27,51 @@
 
 namespace SymTab {
-    class Indexer : public Visitor {
-      public:
-	Indexer( bool useDebug = false );
-	virtual ~Indexer();
+	class Indexer : public Visitor {
+	  public:
+		Indexer( bool useDebug = false );
+		virtual ~Indexer();
 
-	//using Visitor::visit;
-	virtual void visit( ObjectDecl *objectDecl );
-	virtual void visit( FunctionDecl *functionDecl );
-	virtual void visit( TypeDecl *typeDecl );
-	virtual void visit( TypedefDecl *typeDecl );
-	virtual void visit( StructDecl *aggregateDecl );
-	virtual void visit( UnionDecl *aggregateDecl );
-	virtual void visit( EnumDecl *aggregateDecl );
-	virtual void visit( ContextDecl *aggregateDecl );
+		//using Visitor::visit;
+		virtual void visit( ObjectDecl *objectDecl );
+		virtual void visit( FunctionDecl *functionDecl );
+		virtual void visit( TypeDecl *typeDecl );
+		virtual void visit( TypedefDecl *typeDecl );
+		virtual void visit( StructDecl *aggregateDecl );
+		virtual void visit( UnionDecl *aggregateDecl );
+		virtual void visit( EnumDecl *aggregateDecl );
+		virtual void visit( ContextDecl *aggregateDecl );
 
-	virtual void visit( CompoundStmt *compoundStmt );
+		virtual void visit( CompoundStmt *compoundStmt );
 
-	virtual void visit( ContextInstType *contextInst );
-	virtual void visit( StructInstType *contextInst );
-	virtual void visit( UnionInstType *contextInst );
+		virtual void visit( ContextInstType *contextInst );
+		virtual void visit( StructInstType *contextInst );
+		virtual void visit( UnionInstType *contextInst );
 
-	virtual void visit( ForStmt *forStmt );
+		virtual void visit( ForStmt *forStmt );
 
-	// when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer
-	// explicitly when scopes begin and end
-	void enterScope();
-	void leaveScope();
+		// when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer
+		// explicitly when scopes begin and end
+		void enterScope();
+		void leaveScope();
 
-	void lookupId( const std::string &id, std::list< DeclarationWithType* >& ) const;
-	DeclarationWithType* lookupId( const std::string &id) const;
-	NamedTypeDecl *lookupType( const std::string &id ) const;
-	StructDecl *lookupStruct( const std::string &id ) const;
-	EnumDecl *lookupEnum( const std::string &id ) const;
-	UnionDecl *lookupUnion( const std::string &id ) const;
-	ContextDecl *lookupContext( const std::string &id ) const;
+		void lookupId( const std::string &id, std::list< DeclarationWithType* >& ) const;
+		DeclarationWithType* lookupId( const std::string &id) const;
+		NamedTypeDecl *lookupType( const std::string &id ) const;
+		StructDecl *lookupStruct( const std::string &id ) const;
+		EnumDecl *lookupEnum( const std::string &id ) const;
+		UnionDecl *lookupUnion( const std::string &id ) const;
+		ContextDecl *lookupContext( const std::string &id ) const;
   
-	void print( std::ostream &os, int indent = 0 ) const;
-      private:
-	IdTable idTable;
-	TypeTable typeTable;
-	StructTable structTable;
-	EnumTable enumTable;
-	UnionTable unionTable;
-	ContextTable contextTable;
+		void print( std::ostream &os, int indent = 0 ) const;
+	  private:
+		IdTable idTable;
+		TypeTable typeTable;
+		StructTable structTable;
+		EnumTable enumTable;
+		UnionTable unionTable;
+		ContextTable contextTable;
   
-	bool doDebug;					// display debugging trace
-    };
+		bool doDebug;					// display debugging trace
+	};
 } // namespace SymTab
 
Index: translator/SymTab/Mangler.cc
===================================================================
--- translator/SymTab/Mangler.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/Mangler.cc	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:40:29 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 21:43:49 2015
-// Update Count     : 2
+// Last Modified On : Tue May 19 16:50:47 2015
+// Update Count     : 3
 //
 
@@ -30,5 +30,5 @@
 
 namespace SymTab {
-    Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true ) {
+	Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true ) {
 	}
 
@@ -37,11 +37,11 @@
 //{
 //}
-    Mangler::Mangler( const Mangler &rhs ) : mangleName() {
+	Mangler::Mangler( const Mangler &rhs ) : mangleName() {
 		varNums = rhs.varNums;
 		nextVarNum = rhs.nextVarNum;
 		isTopLevel = rhs.isTopLevel;
-    }
-
-    void Mangler::mangleDecl( DeclarationWithType *declaration ) {
+	}
+
+	void Mangler::mangleDecl( DeclarationWithType *declaration ) {
 		bool wasTopLevel = isTopLevel;
 		if ( isTopLevel ) {
@@ -60,20 +60,20 @@
 		maybeAccept( declaration->get_type(), *this );
 		isTopLevel = wasTopLevel;
-    }
-
-    void Mangler::visit( ObjectDecl *declaration ) {
+	}
+
+	void Mangler::visit( ObjectDecl *declaration ) {
 		mangleDecl( declaration );
-    }
-
-    void Mangler::visit( FunctionDecl *declaration ) {
+	}
+
+	void Mangler::visit( FunctionDecl *declaration ) {
 		mangleDecl( declaration );
-    }
-
-    void Mangler::visit( VoidType *voidType ) {
+	}
+
+	void Mangler::visit( VoidType *voidType ) {
 		printQualifiers( voidType );
 		mangleName << "v";
-    }
-
-    void Mangler::visit( BasicType *basicType ) {
+	}
+
+	void Mangler::visit( BasicType *basicType ) {
 		static const char *btLetter[] = {
 			"b",	// Bool
@@ -102,20 +102,20 @@
 		printQualifiers( basicType );
 		mangleName << btLetter[ basicType->get_kind() ];
-    }
-
-    void Mangler::visit( PointerType *pointerType ) {
+	}
+
+	void Mangler::visit( PointerType *pointerType ) {
 		printQualifiers( pointerType );
 		mangleName << "P";
 		maybeAccept( pointerType->get_base(), *this );
-    }
-
-    void Mangler::visit( ArrayType *arrayType ) {
+	}
+
+	void Mangler::visit( ArrayType *arrayType ) {
 		// TODO: encode dimension
 		printQualifiers( arrayType );
 		mangleName << "A0";
 		maybeAccept( arrayType->get_base(), *this );
-    }
-
-    namespace {
+	}
+
+	namespace {
 		inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
 			std::list< Type* > ret;
@@ -124,7 +124,7 @@
 			return ret;
 		}
-    }
-
-    void Mangler::visit( FunctionType *functionType ) {
+	}
+
+	void Mangler::visit( FunctionType *functionType ) {
 		printQualifiers( functionType );
 		mangleName << "F";
@@ -135,24 +135,24 @@
 		acceptAll( paramTypes, *this );
 		mangleName << "_";
-    }
-
-    void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
+	}
+
+	void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
 		printQualifiers( refType );
 		mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
-    }
-
-    void Mangler::visit( StructInstType *aggregateUseType ) {
+	}
+
+	void Mangler::visit( StructInstType *aggregateUseType ) {
 		mangleRef( aggregateUseType, "s" );
-    }
-
-    void Mangler::visit( UnionInstType *aggregateUseType ) {
+	}
+
+	void Mangler::visit( UnionInstType *aggregateUseType ) {
 		mangleRef( aggregateUseType, "u" );
-    }
-
-    void Mangler::visit( EnumInstType *aggregateUseType ) {
+	}
+
+	void Mangler::visit( EnumInstType *aggregateUseType ) {
 		mangleRef( aggregateUseType, "e" );
-    }
-
-    void Mangler::visit( TypeInstType *typeInst ) {
+	}
+
+	void Mangler::visit( TypeInstType *typeInst ) {
 		VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
 		if ( varNum == varNums.end() ) {
@@ -176,25 +176,25 @@
 			mangleName << std::string( numStream.str(), numStream.pcount() );
 		} // if
-    }
-
-    void Mangler::visit( TupleType *tupleType ) {
+	}
+
+	void Mangler::visit( TupleType *tupleType ) {
 		printQualifiers( tupleType );
 		mangleName << "T";
 		acceptAll( tupleType->get_types(), *this );
 		mangleName << "_";
-    }
-
-    void Mangler::visit( TypeDecl *decl ) {
+	}
+
+	void Mangler::visit( TypeDecl *decl ) {
 		static const char *typePrefix[] = { "BT", "BD", "BF" };
 		mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
-    }
-
-    void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
+	}
+
+	void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
 		for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
 			os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
 		} // for
-    }
-
-    void Mangler::printQualifiers( Type *type ) {
+	}
+
+	void Mangler::printQualifiers( Type *type ) {
 		if ( ! type->get_forall().empty() ) {
 			std::list< std::string > assertionNames;
@@ -242,5 +242,5 @@
 			mangleName << "A";
 		} // if
-    }
+	}
 } // namespace SymTab
 
Index: translator/SymTab/Mangler.h
===================================================================
--- translator/SymTab/Mangler.h	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/Mangler.h	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:44:03 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 21:45:05 2015
-// Update Count     : 2
+// Last Modified On : Tue May 19 16:49:21 2015
+// Update Count     : 3
 //
 
@@ -22,6 +22,6 @@
 
 namespace SymTab {
-    class Mangler : public Visitor {
-      public:
+	class Mangler : public Visitor {
+	  public:
 		template< typename SynTreeClass >
 	    static std::string mangle( SynTreeClass *decl ); // interface to clients
@@ -44,5 +44,5 @@
   
 		std::string get_mangleName() { return std::string( mangleName.str(), mangleName.pcount() ); }
-      private:
+	  private:
 		std::ostrstream mangleName;
 		typedef std::map< std::string, std::pair< int, int > > VarMapType;
@@ -58,12 +58,12 @@
   
 		void printQualifiers( Type *type );
-    }; // Mangler
+	}; // Mangler
 
-    template< typename SynTreeClass >
-    std::string Mangler::mangle( SynTreeClass *decl ) {
+	template< typename SynTreeClass >
+	std::string Mangler::mangle( SynTreeClass *decl ) {
 		Mangler mangler;
 		maybeAccept( decl, mangler );
 		return mangler.get_mangleName();
-    }
+	}
 } // SymTab
 
Index: translator/SymTab/StackTable.cc
===================================================================
--- translator/SymTab/StackTable.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/StackTable.cc	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:45:15 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 21:46:59 2015
-// Update Count     : 2
+// Last Modified On : Tue May 19 16:51:53 2015
+// Update Count     : 3
 //
 
@@ -19,15 +19,15 @@
 
 namespace SymTab {
-    template< typename Element, typename ConflictFunction >
-    StackTable< Element, ConflictFunction >::StackTable() : scopeLevel( 0 ) {
+	template< typename Element, typename ConflictFunction >
+	StackTable< Element, ConflictFunction >::StackTable() : scopeLevel( 0 ) {
 	}
 
-    template< typename Element, typename ConflictFunction >
-    void StackTable< Element, ConflictFunction >::enterScope() {
+	template< typename Element, typename ConflictFunction >
+	void StackTable< Element, ConflictFunction >::enterScope() {
 		scopeLevel++;
-    }
+	}
 
-    template< typename Element, typename ConflictFunction >
-    void StackTable< Element, ConflictFunction >::leaveScope() {
+	template< typename Element, typename ConflictFunction >
+	void StackTable< Element, ConflictFunction >::leaveScope() {
 		for ( typename TableType::iterator it = table.begin(); it != table.end(); ++it ) {
 			std::stack< Entry >& entry = it->second;
@@ -38,8 +38,8 @@
 		scopeLevel--;
 		assert( scopeLevel >= 0 );
-    }
+	}
 
-    template< typename Element, typename ConflictFunction >
-    void StackTable< Element, ConflictFunction >::add( Element *type ) {
+	template< typename Element, typename ConflictFunction >
+	void StackTable< Element, ConflictFunction >::add( Element *type ) {
 		std::stack< Entry >& entry = table[ type->get_name() ];
 		if ( ! entry.empty() && entry.top().second == scopeLevel ) {
@@ -48,13 +48,13 @@
 			entry.push( Entry( type, scopeLevel ) );
 		} // if
-    }
+	}
 
-    template< typename Element, typename ConflictFunction >
-    void StackTable< Element, ConflictFunction >::add( std::string fwdDeclName ) {
+	template< typename Element, typename ConflictFunction >
+	void StackTable< Element, ConflictFunction >::add( std::string fwdDeclName ) {
 		add( new Element( fwdDeclName ) );
-    }
+	}
 
-    template< typename Element, typename ConflictFunction >
-    Element *StackTable< Element, ConflictFunction >::lookup( std::string id ) const {
+	template< typename Element, typename ConflictFunction >
+	Element *StackTable< Element, ConflictFunction >::lookup( std::string id ) const {
 		typename TableType::const_iterator it = table.find( id );
 		if ( it == table.end() ) {
@@ -65,8 +65,8 @@
 			return 0;
 		} // if
-    }
+	}
 
-    template< typename Element, typename ConflictFunction >
-    void StackTable< Element, ConflictFunction >::dump( std::ostream &os ) const {
+	template< typename Element, typename ConflictFunction >
+	void StackTable< Element, ConflictFunction >::dump( std::ostream &os ) const {
 		for ( typename TableType::const_iterator it = table.begin(); it != table.end(); ++it ) {
 			const std::stack< Entry >& entry = it->second;
@@ -75,5 +75,5 @@
 			} // if
 		} // for
-    }
+	}
 } // namespace SymTab
 
Index: translator/SymTab/StackTable.h
===================================================================
--- translator/SymTab/StackTable.h	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/StackTable.h	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:47:10 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 21:48:15 2015
-// Update Count     : 3
+// Last Modified On : Tue May 19 16:50:36 2015
+// Update Count     : 4
 //
 
@@ -23,7 +23,7 @@
 
 namespace SymTab {
-    template< typename Element, typename ConflictFunction >
+	template< typename Element, typename ConflictFunction >
 	class StackTable {
-      public:
+	  public:
 		StackTable();
 
@@ -35,5 +35,5 @@
 
 		void dump( std::ostream &os ) const;			// debugging
-      private:
+	  private:
 		typedef std::pair< Element*, int > Entry;
 		typedef std::map< std::string, std::stack< Entry > > TableType;
@@ -42,5 +42,5 @@
 		TableType table;
 		int scopeLevel;
-    };
+	};
 } // SymTab
 
Index: translator/SymTab/TypeTable.h
===================================================================
--- translator/SymTab/TypeTable.h	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/TypeTable.h	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:48:32 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 21:49:49 2015
-// Update Count     : 2
+// Last Modified On : Tue May 19 16:50:25 2015
+// Update Count     : 3
 //
 
@@ -27,6 +27,6 @@
 
 namespace SymTab {
-    class TypeTableConflictFunction : public std::binary_function< NamedTypeDecl *, NamedTypeDecl *, NamedTypeDecl * > {
-      public:
+	class TypeTableConflictFunction : public std::binary_function< NamedTypeDecl *, NamedTypeDecl *, NamedTypeDecl * > {
+	  public:
 		NamedTypeDecl *operator()( NamedTypeDecl *existing, NamedTypeDecl *added ) {
 			if ( existing->get_base() == 0 ) {
@@ -40,7 +40,7 @@
 			return 0;
 		}
-    };
+	};
 
-    typedef StackTable< NamedTypeDecl, TypeTableConflictFunction > TypeTable;
+	typedef StackTable< NamedTypeDecl, TypeTableConflictFunction > TypeTable;
 } // namespace SymTab
 
Index: translator/SymTab/Validate.cc
===================================================================
--- translator/SymTab/Validate.cc	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/Validate.cc	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -10,6 +10,6 @@
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 21:53:16 2015
-// Update Count     : 2
+// Last Modified On : Tue May 19 16:50:09 2015
+// Update Count     : 3
 //
 
@@ -57,6 +57,6 @@
 
 namespace SymTab {
-    class HoistStruct : public Visitor {
-      public:
+	class HoistStruct : public Visitor {
+	  public:
 		static void hoistStruct( std::list< Declaration * > &translationUnit );
   
@@ -74,5 +74,5 @@
 		virtual void visit( CaseStmt *caseStmt );
 		virtual void visit( CatchStmt *catchStmt );
-      private:
+	  private:
 		HoistStruct();
 
@@ -81,17 +81,17 @@
 		std::list< Declaration * > declsToAdd;
 		bool inStruct;
-    };
-
-    class Pass1 : public Visitor {
+	};
+
+	class Pass1 : public Visitor {
 		typedef Visitor Parent;
 		virtual void visit( EnumDecl *aggregateDecl );
 		virtual void visit( FunctionType *func );
-    };
-  
-    class Pass2 : public Indexer {
+	};
+  
+	class Pass2 : public Indexer {
 		typedef Indexer Parent;
-      public:
+	  public:
 		Pass2( bool doDebug, const Indexer *indexer );
-      private:
+	  private:
 		virtual void visit( StructInstType *structInst );
 		virtual void visit( UnionInstType *unionInst );
@@ -107,19 +107,19 @@
 		ForwardStructsType forwardStructs;
 		ForwardUnionsType forwardUnions;
-    };
-
-    class Pass3 : public Indexer {
+	};
+
+	class Pass3 : public Indexer {
 		typedef Indexer Parent;
-      public:
+	  public:
 		Pass3( const Indexer *indexer );
-      private:
+	  private:
 		virtual void visit( ObjectDecl *object );
 		virtual void visit( FunctionDecl *func );
 
 		const Indexer *indexer;
-    };
-
-    class AddStructAssignment : public Visitor {
-      public:
+	};
+
+	class AddStructAssignment : public Visitor {
+	  public:
 		static void addStructAssignment( std::list< Declaration * > &translationUnit );
 
@@ -145,5 +145,5 @@
 
 		AddStructAssignment() : functionNesting( 0 ) {}
-      private:
+	  private:
 		template< typename StmtClass > void visitStatement( StmtClass *stmt );
   
@@ -151,10 +151,10 @@
 		std::set< std::string > structsDone;
 		unsigned int functionNesting;			// current level of nested functions
-    };
-
-    class EliminateTypedef : public Mutator {
-      public:
+	};
+
+	class EliminateTypedef : public Mutator {
+	  public:
 		static void eliminateTypedef( std::list< Declaration * > &translationUnit );
-      private:
+	  private:
 		virtual Declaration *mutate( TypedefDecl *typeDecl );
 		virtual TypeDecl *mutate( TypeDecl *typeDecl );
@@ -166,7 +166,7 @@
   
 		std::map< std::string, TypedefDecl * > typedefNames;
-    };
-
-    void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
+	};
+
+	void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
 		Pass1 pass1;
 		Pass2 pass2( doDebug, 0 );
@@ -178,7 +178,7 @@
 		AddStructAssignment::addStructAssignment( translationUnit );
 		acceptAll( translationUnit, pass3 );
-    }
-    
-    void validateType( Type *type, const Indexer *indexer ) {
+	}
+	
+	void validateType( Type *type, const Indexer *indexer ) {
 		Pass1 pass1;
 		Pass2 pass2( false, indexer );
@@ -187,8 +187,8 @@
 		type->accept( pass2 );
 		type->accept( pass3 );
-    }
-
-    template< typename Visitor >
-    void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor, bool addBefore ) {
+	}
+
+	template< typename Visitor >
+	void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor, bool addBefore ) {
 		std::list< Declaration * >::iterator i = translationUnit.begin();
 		while ( i != translationUnit.end() ) {
@@ -201,15 +201,15 @@
 			i = next;
 		} // while
-    }
-
-    void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
+	}
+
+	void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
 		HoistStruct hoister;
 		acceptAndAdd( translationUnit, hoister, true );
-    }
-
-    HoistStruct::HoistStruct() : inStruct( false ) {
-    }
-
-    void filter( std::list< Declaration * > &declList, bool (*pred)( Declaration * ), bool doDelete ) {
+	}
+
+	HoistStruct::HoistStruct() : inStruct( false ) {
+	}
+
+	void filter( std::list< Declaration * > &declList, bool (*pred)( Declaration * ), bool doDelete ) {
 		std::list< Declaration * >::iterator i = declList.begin();
 		while ( i != declList.end() ) {
@@ -224,12 +224,12 @@
 			i = next;
 		} // while
-    }
-
-    bool isStructOrUnion( Declaration *decl ) {
+	}
+
+	bool isStructOrUnion( Declaration *decl ) {
 		return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
-    }
-
-    template< typename AggDecl >
-    void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
+	}
+
+	template< typename AggDecl >
+	void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
 		if ( inStruct ) {
 			// Add elements in stack order corresponding to nesting structure.
@@ -243,47 +243,47 @@
 		// Always remove the hoisted aggregate from the inner structure.
 		filter( aggregateDecl->get_members(), isStructOrUnion, false );
-    }
-
-    void HoistStruct::visit( StructDecl *aggregateDecl ) {
+	}
+
+	void HoistStruct::visit( StructDecl *aggregateDecl ) {
 		handleAggregate( aggregateDecl );
-    }
-
-    void HoistStruct::visit( UnionDecl *aggregateDecl ) {
+	}
+
+	void HoistStruct::visit( UnionDecl *aggregateDecl ) {
 		handleAggregate( aggregateDecl );
-    }
-
-    void HoistStruct::visit( CompoundStmt *compoundStmt ) {
+	}
+
+	void HoistStruct::visit( CompoundStmt *compoundStmt ) {
 		addVisit( compoundStmt, *this );
-    }
-
-    void HoistStruct::visit( IfStmt *ifStmt ) {
+	}
+
+	void HoistStruct::visit( IfStmt *ifStmt ) {
 		addVisit( ifStmt, *this );
-    }
-
-    void HoistStruct::visit( WhileStmt *whileStmt ) {
+	}
+
+	void HoistStruct::visit( WhileStmt *whileStmt ) {
 		addVisit( whileStmt, *this );
-    }
-
-    void HoistStruct::visit( ForStmt *forStmt ) {
+	}
+
+	void HoistStruct::visit( ForStmt *forStmt ) {
 		addVisit( forStmt, *this );
-    }
-
-    void HoistStruct::visit( SwitchStmt *switchStmt ) {
+	}
+
+	void HoistStruct::visit( SwitchStmt *switchStmt ) {
 		addVisit( switchStmt, *this );
-    }
-
-    void HoistStruct::visit( ChooseStmt *switchStmt ) {
+	}
+
+	void HoistStruct::visit( ChooseStmt *switchStmt ) {
 		addVisit( switchStmt, *this );
-    }
-
-    void HoistStruct::visit( CaseStmt *caseStmt ) {
+	}
+
+	void HoistStruct::visit( CaseStmt *caseStmt ) {
 		addVisit( caseStmt, *this );
-    }
-
-    void HoistStruct::visit( CatchStmt *cathStmt ) {
+	}
+
+	void HoistStruct::visit( CatchStmt *cathStmt ) {
 		addVisit( cathStmt, *this );
-    }
-
-    void Pass1::visit( EnumDecl *enumDecl ) {
+	}
+
+	void Pass1::visit( EnumDecl *enumDecl ) {
 		// Set the type of each member of the enumeration to be EnumConstant
   
@@ -294,7 +294,7 @@
 		} // for
 		Parent::visit( enumDecl );
-    }
-
-    namespace {
+	}
+
+	namespace {
 		template< typename DWTIterator >
 		void fixFunctionList( DWTIterator begin, DWTIterator end, FunctionType *func ) {
@@ -323,14 +323,14 @@
 			} // if
 		}
-    }
-
-    void Pass1::visit( FunctionType *func ) {
+	}
+
+	void Pass1::visit( FunctionType *func ) {
 		// Fix up parameters and return types
 		fixFunctionList( func->get_parameters().begin(), func->get_parameters().end(), func );
 		fixFunctionList( func->get_returnVals().begin(), func->get_returnVals().end(), func );
 		Visitor::visit( func );
-    }
-
-    Pass2::Pass2( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
+	}
+
+	Pass2::Pass2( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
 		if ( other_indexer ) {
 			indexer = other_indexer;
@@ -338,7 +338,7 @@
 			indexer = this;
 		} // if
-    }
-
-    void Pass2::visit( StructInstType *structInst ) {
+	}
+
+	void Pass2::visit( StructInstType *structInst ) {
 		Parent::visit( structInst );
 		StructDecl *st = indexer->lookupStruct( structInst->get_name() );
@@ -352,7 +352,7 @@
 			forwardStructs[ structInst->get_name() ].push_back( structInst );
 		} // if
-    }
-
-    void Pass2::visit( UnionInstType *unionInst ) {
+	}
+
+	void Pass2::visit( UnionInstType *unionInst ) {
 		Parent::visit( unionInst );
 		UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
@@ -365,7 +365,7 @@
 			forwardUnions[ unionInst->get_name() ].push_back( unionInst );
 		} // if
-    }
-
-    void Pass2::visit( ContextInstType *contextInst ) {
+	}
+
+	void Pass2::visit( ContextInstType *contextInst ) {
 		Parent::visit( contextInst );
 		ContextDecl *ctx = indexer->lookupContext( contextInst->get_name() );
@@ -383,7 +383,7 @@
 		} // for
 		applySubstitution( ctx->get_parameters().begin(), ctx->get_parameters().end(), contextInst->get_parameters().begin(), ctx->get_members().begin(), ctx->get_members().end(), back_inserter( contextInst->get_members() ) );
-    }
-
-    void Pass2::visit( StructDecl *structDecl ) {
+	}
+
+	void Pass2::visit( StructDecl *structDecl ) {
 		if ( ! structDecl->get_members().empty() ) {
 			ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
@@ -396,7 +396,7 @@
 		} // if
 		Indexer::visit( structDecl );
-    }
-
-    void Pass2::visit( UnionDecl *unionDecl ) {
+	}
+
+	void Pass2::visit( UnionDecl *unionDecl ) {
 		if ( ! unionDecl->get_members().empty() ) {
 			ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
@@ -409,7 +409,7 @@
 		} // if
 		Indexer::visit( unionDecl );
-    }
-
-    void Pass2::visit( TypeInstType *typeInst ) {
+	}
+
+	void Pass2::visit( TypeInstType *typeInst ) {
 		if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
 			if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
@@ -417,7 +417,7 @@
 			} // if
 		} // if
-    }
-
-    Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
+	}
+
+	Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
 		if ( other_indexer ) {
 			indexer = other_indexer;
@@ -425,7 +425,7 @@
 			indexer = this;
 		} // if
-    }
-
-    void forallFixer( Type *func ) {
+	}
+
+	void forallFixer( Type *func ) {
 		// Fix up assertions
 		for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
@@ -454,7 +454,7 @@
 			} // while
 		} // for
-    }
-
-    void Pass3::visit( ObjectDecl *object ) {
+	}
+
+	void Pass3::visit( ObjectDecl *object ) {
 		forallFixer( object->get_type() );
 		if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
@@ -463,21 +463,21 @@
 		Parent::visit( object );
 		object->fixUniqueId();
-    }
-
-    void Pass3::visit( FunctionDecl *func ) {
+	}
+
+	void Pass3::visit( FunctionDecl *func ) {
 		forallFixer( func->get_type() );
 		Parent::visit( func );
 		func->fixUniqueId();
-    }
-
-    static const std::list< std::string > noLabels;
-
-    void AddStructAssignment::addStructAssignment( std::list< Declaration * > &translationUnit ) {
+	}
+
+	static const std::list< std::string > noLabels;
+
+	void AddStructAssignment::addStructAssignment( std::list< Declaration * > &translationUnit ) {
 		AddStructAssignment visitor;
 		acceptAndAdd( translationUnit, visitor, false );
-    }
-
-    template< typename OutputIterator >
-    void makeScalarAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, OutputIterator out ) {
+	}
+
+	template< typename OutputIterator >
+	void makeScalarAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, OutputIterator out ) {
 		ObjectDecl *obj = dynamic_cast<ObjectDecl *>( member );
 		// unnamed bit fields are not copied as they cannot be accessed
@@ -497,8 +497,8 @@
   
 		*out++ = new ExprStmt( noLabels, assignExpr );
-    }
-
-    template< typename OutputIterator >
-    void makeArrayAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, ArrayType *array, OutputIterator out ) {
+	}
+
+	template< typename OutputIterator >
+	void makeArrayAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, ArrayType *array, OutputIterator out ) {
 		static UniqueName indexName( "_index" );
   
@@ -539,7 +539,7 @@
   
 		*out++ = new ForStmt( noLabels, initStmt, cond, inc, new ExprStmt( noLabels, assignExpr ) );
-    }
-
-    Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
+	}
+
+	Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
 		FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
   
@@ -570,7 +570,7 @@
   
 		return assignDecl;
-    }
-
-    Declaration *makeUnionAssignment( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting ) {
+	}
+
+	Declaration *makeUnionAssignment( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting ) {
 		FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
   
@@ -598,7 +598,7 @@
   
 		return assignDecl;
-    }
-
-    void AddStructAssignment::visit( StructDecl *structDecl ) {
+	}
+
+	void AddStructAssignment::visit( StructDecl *structDecl ) {
 		if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
 			StructInstType *structInst = new StructInstType( Type::Qualifiers(), structDecl->get_name() );
@@ -607,7 +607,7 @@
 			structsDone.insert( structDecl->get_name() );
 		} // if
-    }
-
-    void AddStructAssignment::visit( UnionDecl *unionDecl ) {
+	}
+
+	void AddStructAssignment::visit( UnionDecl *unionDecl ) {
 		if ( ! unionDecl->get_members().empty() ) {
 			UnionInstType *unionInst = new UnionInstType( Type::Qualifiers(), unionDecl->get_name() );
@@ -615,7 +615,7 @@
 			declsToAdd.push_back( makeUnionAssignment( unionDecl, unionInst, functionNesting ) );
 		} // if
-    }
-
-    void AddStructAssignment::visit( TypeDecl *typeDecl ) {
+	}
+
+	void AddStructAssignment::visit( TypeDecl *typeDecl ) {
 		CompoundStmt *stmts = 0;
 		TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
@@ -636,7 +636,7 @@
 		FunctionDecl *func = new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::AutoGen, type, stmts, false );
 		declsToAdd.push_back( func );
-    }
-
-    void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
+	}
+
+	void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
 		if ( ! declsToAdd.empty() ) {
 			for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
@@ -645,26 +645,26 @@
 			declsToAdd.clear();
 		} // if
-    }
-
-    void AddStructAssignment::visit( FunctionType *) {
+	}
+
+	void AddStructAssignment::visit( FunctionType *) {
 		// ensure that we don't add assignment ops for types defined as part of the function
-    }
-
-    void AddStructAssignment::visit( PointerType *) {
+	}
+
+	void AddStructAssignment::visit( PointerType *) {
 		// ensure that we don't add assignment ops for types defined as part of the pointer
-    }
-
-    void AddStructAssignment::visit( ContextDecl *) {
+	}
+
+	void AddStructAssignment::visit( ContextDecl *) {
 		// ensure that we don't add assignment ops for types defined as part of the context
-    }
-
-    template< typename StmtClass >
-    inline void AddStructAssignment::visitStatement( StmtClass *stmt ) {
+	}
+
+	template< typename StmtClass >
+	inline void AddStructAssignment::visitStatement( StmtClass *stmt ) {
 		std::set< std::string > oldStructs = structsDone;
 		addVisit( stmt, *this );
 		structsDone = oldStructs;
-    }
-
-    void AddStructAssignment::visit( FunctionDecl *functionDecl ) {
+	}
+
+	void AddStructAssignment::visit( FunctionDecl *functionDecl ) {
 		maybeAccept( functionDecl->get_functionType(), *this );
 		acceptAll( functionDecl->get_oldDecls(), *this );
@@ -672,49 +672,49 @@
 		maybeAccept( functionDecl->get_statements(), *this );
 		functionNesting -= 1;
-    }
-
-    void AddStructAssignment::visit( CompoundStmt *compoundStmt ) {
+	}
+
+	void AddStructAssignment::visit( CompoundStmt *compoundStmt ) {
 		visitStatement( compoundStmt );
-    }
-
-    void AddStructAssignment::visit( IfStmt *ifStmt ) {
+	}
+
+	void AddStructAssignment::visit( IfStmt *ifStmt ) {
 		visitStatement( ifStmt );
-    }
-
-    void AddStructAssignment::visit( WhileStmt *whileStmt ) {
+	}
+
+	void AddStructAssignment::visit( WhileStmt *whileStmt ) {
 		visitStatement( whileStmt );
-    }
-
-    void AddStructAssignment::visit( ForStmt *forStmt ) {
+	}
+
+	void AddStructAssignment::visit( ForStmt *forStmt ) {
 		visitStatement( forStmt );
-    }
-
-    void AddStructAssignment::visit( SwitchStmt *switchStmt ) {
+	}
+
+	void AddStructAssignment::visit( SwitchStmt *switchStmt ) {
 		visitStatement( switchStmt );
-    }
-
-    void AddStructAssignment::visit( ChooseStmt *switchStmt ) {
+	}
+
+	void AddStructAssignment::visit( ChooseStmt *switchStmt ) {
 		visitStatement( switchStmt );
-    }
-
-    void AddStructAssignment::visit( CaseStmt *caseStmt ) {
+	}
+
+	void AddStructAssignment::visit( CaseStmt *caseStmt ) {
 		visitStatement( caseStmt );
-    }
-
-    void AddStructAssignment::visit( CatchStmt *cathStmt ) {
+	}
+
+	void AddStructAssignment::visit( CatchStmt *cathStmt ) {
 		visitStatement( cathStmt );
-    }
-
-    bool isTypedef( Declaration *decl ) {
+	}
+
+	bool isTypedef( Declaration *decl ) {
 		return dynamic_cast< TypedefDecl * >( decl );
-    }
-
-    void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
+	}
+
+	void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
 		EliminateTypedef eliminator;
 		mutateAll( translationUnit, eliminator );
 		filter( translationUnit, isTypedef, true );
-    }
-
-    Type *EliminateTypedef::mutate( TypeInstType *typeInst ) {
+	}
+
+	Type *EliminateTypedef::mutate( TypeInstType *typeInst ) {
 		std::map< std::string, TypedefDecl * >::const_iterator def = typedefNames.find( typeInst->get_name() );
 		if ( def != typedefNames.end() ) {
@@ -725,7 +725,7 @@
 		} // if
 		return typeInst;
-    }
-
-    Declaration *EliminateTypedef::mutate( TypedefDecl *tyDecl ) {
+	}
+
+	Declaration *EliminateTypedef::mutate( TypedefDecl *tyDecl ) {
 		Declaration *ret = Mutator::mutate( tyDecl );
 		typedefNames[ tyDecl->get_name() ] = tyDecl;
@@ -745,7 +745,7 @@
 			return ret;
 		} // if
-    }
-
-    TypeDecl *EliminateTypedef::mutate( TypeDecl *typeDecl ) {
+	}
+
+	TypeDecl *EliminateTypedef::mutate( TypeDecl *typeDecl ) {
 		std::map< std::string, TypedefDecl * >::iterator i = typedefNames.find( typeDecl->get_name() );
 		if ( i != typedefNames.end() ) {
@@ -753,28 +753,28 @@
 		} // if
 		return typeDecl;
-    }
-
-    DeclarationWithType *EliminateTypedef::mutate( FunctionDecl *funcDecl ) {
+	}
+
+	DeclarationWithType *EliminateTypedef::mutate( FunctionDecl *funcDecl ) {
 		std::map< std::string, TypedefDecl * > oldNames = typedefNames;
 		DeclarationWithType *ret = Mutator::mutate( funcDecl );
 		typedefNames = oldNames;
 		return ret;
-    }
-
-    ObjectDecl *EliminateTypedef::mutate( ObjectDecl *objDecl ) {
+	}
+
+	ObjectDecl *EliminateTypedef::mutate( ObjectDecl *objDecl ) {
 		std::map< std::string, TypedefDecl * > oldNames = typedefNames;
 		ObjectDecl *ret = Mutator::mutate( objDecl );
 		typedefNames = oldNames;
 		return ret;
-    }
-
-    Expression *EliminateTypedef::mutate( CastExpr *castExpr ) {
+	}
+
+	Expression *EliminateTypedef::mutate( CastExpr *castExpr ) {
 		std::map< std::string, TypedefDecl * > oldNames = typedefNames;
 		Expression *ret = Mutator::mutate( castExpr );
 		typedefNames = oldNames;
 		return ret;
-    }
-
-    CompoundStmt *EliminateTypedef::mutate( CompoundStmt *compoundStmt ) {
+	}
+
+	CompoundStmt *EliminateTypedef::mutate( CompoundStmt *compoundStmt ) {
 		std::map< std::string, TypedefDecl * > oldNames = typedefNames;
 		CompoundStmt *ret = Mutator::mutate( compoundStmt );
@@ -793,5 +793,5 @@
 		typedefNames = oldNames;
 		return ret;
-    }
+	}
 } // namespace SymTab
 
Index: translator/SymTab/Validate.h
===================================================================
--- translator/SymTab/Validate.h	(revision 0dd3a2faa6372da8704ff969a8bb37b5d340f350)
+++ translator/SymTab/Validate.h	(revision a08ba927e920255639a48d814cce47347723392a)
@@ -11,6 +11,6 @@
 // Created On       : Sun May 17 21:53:34 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun May 17 21:55:09 2015
-// Update Count     : 2
+// Last Modified On : Tue May 19 16:49:43 2015
+// Update Count     : 3
 //
 
@@ -21,8 +21,8 @@
 
 namespace SymTab {
-    class Indexer;
+	class Indexer;
 
-    void validate( std::list< Declaration * > &translationUnit, bool doDebug = false );
-    void validateType( Type *type, const Indexer *indexer );
+	void validate( std::list< Declaration * > &translationUnit, bool doDebug = false );
+	void validateType( Type *type, const Indexer *indexer );
 } // namespace SymTab