Index: translator/SynTree/Mutator.h
===================================================================
--- translator/SynTree/Mutator.h	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
+++ translator/SynTree/Mutator.h	(revision 51b734528489f81a5af985bfee9aa3b6625b9774)
@@ -0,0 +1,140 @@
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: Mutator.h,v 1.19 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+
+#include <cassert>
+
+#include "SynTree.h"
+#include "SemanticError.h"
+
+#ifndef SYNTREE_MUTATOR_H
+#define SYNTREE_MUTATOR_H
+
+
+class Mutator
+{
+protected:
+    Mutator();
+    virtual ~Mutator();
+
+public:
+    virtual ObjectDecl* mutate(ObjectDecl *objectDecl);
+    virtual DeclarationWithType* mutate(FunctionDecl *functionDecl);
+    virtual Declaration* mutate(StructDecl *aggregateDecl);
+    virtual Declaration* mutate(UnionDecl *aggregateDecl);
+    virtual Declaration* mutate(EnumDecl *aggregateDecl);
+    virtual Declaration* mutate(ContextDecl *aggregateDecl);
+    virtual TypeDecl* mutate(TypeDecl *typeDecl);
+    virtual Declaration* mutate(TypedefDecl *typeDecl);
+
+    virtual CompoundStmt* mutate(CompoundStmt *compoundStmt);
+    virtual Statement* mutate(ExprStmt *exprStmt);
+    virtual Statement* mutate(IfStmt *ifStmt);
+    virtual Statement* mutate(WhileStmt *whileStmt);
+    virtual Statement* mutate(ForStmt *forStmt);
+    virtual Statement* mutate(SwitchStmt *switchStmt);
+    virtual Statement* mutate(ChooseStmt *chooseStmt);
+    virtual Statement* mutate(FallthruStmt *fallthruStmt);
+    virtual Statement* mutate(CaseStmt *caseStmt);
+    virtual Statement* mutate(BranchStmt *branchStmt);
+    virtual Statement* mutate(ReturnStmt *returnStmt);
+    virtual Statement* mutate(TryStmt *returnStmt);
+    virtual Statement* mutate(CatchStmt *catchStmt);
+    virtual Statement* mutate(FinallyStmt *catchStmt);
+    virtual NullStmt* mutate(NullStmt *nullStmt);
+    virtual Statement* mutate(DeclStmt *declStmt);
+
+    virtual Expression* mutate(ApplicationExpr *applicationExpr);
+    virtual Expression* mutate(UntypedExpr *untypedExpr);
+    virtual Expression* mutate(NameExpr *nameExpr);
+    virtual Expression* mutate(AddressExpr *castExpr);
+    virtual Expression* mutate(LabelAddressExpr *labAddressExpr);
+    virtual Expression* mutate(CastExpr *castExpr);
+    virtual Expression* mutate(UntypedMemberExpr *memberExpr);
+    virtual Expression* mutate(MemberExpr *memberExpr);
+    virtual Expression* mutate(VariableExpr *variableExpr);
+    virtual Expression* mutate(ConstantExpr *constantExpr); 
+    virtual Expression* mutate(SizeofExpr *sizeofExpr);
+    virtual Expression* mutate(AttrExpr *attrExpr);
+    virtual Expression* mutate(LogicalExpr *logicalExpr);
+    virtual Expression* mutate(ConditionalExpr *conditionalExpr);
+    virtual Expression* mutate(CommaExpr *commaExpr);
+    virtual Expression* mutate(TupleExpr *tupleExpr);
+    virtual Expression* mutate(SolvedTupleExpr *tupleExpr);
+    virtual Expression* mutate(TypeExpr *typeExpr);
+    virtual Expression* mutate(UntypedValofExpr *valofExpr);
+
+    virtual Type* mutate(VoidType *basicType);
+    virtual Type* mutate(BasicType *basicType);
+    virtual Type* mutate(PointerType *pointerType);
+    virtual Type* mutate(ArrayType *arrayType);
+    virtual Type* mutate(FunctionType *functionType);
+    virtual Type* mutate(StructInstType *aggregateUseType);
+    virtual Type* mutate(UnionInstType *aggregateUseType);
+    virtual Type* mutate(EnumInstType *aggregateUseType);
+    virtual Type* mutate(ContextInstType *aggregateUseType);
+    virtual Type* mutate(TypeInstType *aggregateUseType);
+    virtual Type* mutate(TupleType *tupleType);
+    virtual Type* mutate(TypeofType *typeofType);
+    virtual Type* mutate(AttrType *attrType);
+
+    virtual Initializer* mutate(MemberInit *memberInit);
+    virtual Initializer* mutate(ElementInit *elementInit);
+    virtual Initializer* mutate(SingleInit *singleInit);
+    virtual Initializer* mutate(ListInit *listInit);
+
+    virtual Subrange *mutate(Subrange *subrange);
+
+    virtual Constant *mutate(Constant *constant);
+
+private:
+    virtual Declaration* handleAggregateDecl(AggregateDecl *aggregateDecl);
+    virtual Declaration* handleNamedTypeDecl(NamedTypeDecl *typeDecl);
+    virtual Type* handleReferenceToType(ReferenceToType *aggregateUseType);
+};
+
+template< typename TreeType, typename MutatorType >
+inline TreeType *
+maybeMutate( TreeType *tree, MutatorType &mutator )
+{
+    if( tree ) {
+	TreeType *newnode = dynamic_cast< TreeType* >( tree->acceptMutator( mutator ) );
+	assert( newnode );
+	return newnode;
+///	    return tree->acceptMutator( mutator );
+    } else {
+	return 0;
+    }
+}
+
+template< typename Container, typename MutatorType >
+inline void
+mutateAll( Container &container, MutatorType &mutator )
+{
+    SemanticError errors;
+    for( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+	try {
+	    if( *i ) {
+///		    *i = (*i)->acceptMutator( mutator );
+		*i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) );
+		assert( *i );
+	    }
+	} catch( SemanticError &e ) {
+	    errors.append( e );
+	}
+    }
+    if( !errors.isEmpty() ) {
+	throw errors;
+    }
+}
+
+
+
+#endif /* #ifndef SYNTREE_MUTATOR_H */
+
+// Local Variables: //
+// mode: c++ //
+// End:  //
