Changeset a08ba92 for translator/SymTab/Validate.cc

Timestamp:

May 19, 2015, 4:58:14 PM (11 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

843054c2

Parents:

01aeade

Message:

licencing: sixth groups of files

File:

• translator/SymTab/Validate.cc (modified) (38 diffs)

translator/SymTab/Validate.cc

@@ -10 +10 @@
 // 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 +57 @@
 
 namespace SymTab {
-    class HoistStruct : public Visitor {
-      public:
+        class HoistStruct : public Visitor {
+          public:
                 static void hoistStruct( std::list< Declaration * > &translationUnit );
   
@@ -74 +74 @@
                 virtual void visit( CaseStmt *caseStmt );
                 virtual void visit( CatchStmt *catchStmt );
-      private:
+          private:
                 HoistStruct();
 
@@ -81 +81 @@
                 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 +107 @@
                 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 +145 @@
 
                 AddStructAssignment() : functionNesting( 0 ) {}
-      private:
+          private:
                 template< typename StmtClass > void visitStatement( StmtClass *stmt );
   
@@ -151 +151 @@
                 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 +166 @@
   
                 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 +178 @@
                 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 +187 @@
                 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 +201 @@
                         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 +224 @@
                         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 +243 @@
                 // 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 +294 @@
                 } // for
                 Parent::visit( enumDecl );
-    }
-
-    namespace {
+        }
+
+        namespace {
                 template< typename DWTIterator >
                 void fixFunctionList( DWTIterator begin, DWTIterator end, FunctionType *func ) {
@@ -323 +323 @@
                         } // 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 +338 @@
                         indexer = this;
                 } // if
-    }
-
-    void Pass2::visit( StructInstType *structInst ) {
+        }
+
+        void Pass2::visit( StructInstType *structInst ) {
                 Parent::visit( structInst );
                 StructDecl *st = indexer->lookupStruct( structInst->get_name() );
@@ -352 +352 @@
                         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 +365 @@
                         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 +383 @@
                 } // 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 +396 @@
                 } // 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 +409 @@
                 } // 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 +417 @@
                         } // 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 +425 @@
                         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 +454 @@
                         } // 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 +463 @@
                 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 +497 @@
   
                 *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 +539 @@
   
                 *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 +570 @@
   
                 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 +598 @@
   
                 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 +607 @@
                         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 +615 @@
                         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 +636 @@
                 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 +645 @@
                         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 +672 @@
                 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 +725 @@
                 } // if
                 return typeInst;
-    }
-
-    Declaration *EliminateTypedef::mutate( TypedefDecl *tyDecl ) {
+        }
+
+        Declaration *EliminateTypedef::mutate( TypedefDecl *tyDecl ) {
                 Declaration *ret = Mutator::mutate( tyDecl );
                 typedefNames[ tyDecl->get_name() ] = tyDecl;
@@ -745 +745 @@
                         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 +753 @@
                 } // 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 +793 @@
                 typedefNames = oldNames;
                 return ret;
-    }
+        }
 } // namespace SymTab