Index: translator/SynTree/Initializer.cc
===================================================================
--- translator/SynTree/Initializer.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
+++ translator/SynTree/Initializer.cc	(revision d9a0e763800888addddd70d8848a8f432b825e4b)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: Initializer.cc,v 1.10 2005/08/29 20:59:25 rcbilson Exp $
- *
- */
-
 #include "Initializer.h"
 #include "Expression.h"
@@ -11,14 +4,10 @@
 
 
-Initializer::Initializer( )
-{
-}
+Initializer::Initializer() {}
 
-Initializer::~Initializer( )
-{
-}
+Initializer::~Initializer() {}
 
 std::string Initializer::designator_name( Expression *des ) {
-    if( NameExpr *n = dynamic_cast<NameExpr *>(des) )
+    if ( NameExpr *n = dynamic_cast<NameExpr *>(des) )
 	return n->get_name();
     else
@@ -26,55 +15,37 @@
 }
 
-void 
-Initializer::print( std::ostream &os, int indent )
-{
+void Initializer::print( std::ostream &os, int indent ) {}
+
+SingleInit::SingleInit( Expression *v, std::list< Expression *> &_designators ) : value ( v ), designators( _designators ) { 
 }
 
-SingleInit::SingleInit( Expression *v, std::list< Expression *> &_designators )
-    : value ( v ), designators( _designators )
-{ 
-}
-
-SingleInit::SingleInit ( const SingleInit &other )
-    : value ( other.value )
-{
+SingleInit::SingleInit( const SingleInit &other ) : value ( other.value ) {
     cloneAll(other.designators, designators );
 }
 
-SingleInit::~SingleInit()
-{
-}
+SingleInit::~SingleInit() {}
 
 SingleInit *SingleInit::clone() const { return new SingleInit( *this); }
 
-void SingleInit::print( std::ostream &os, int indent )
-{
+void SingleInit::print( std::ostream &os, int indent ) {
     os << std::endl << std::string(indent, ' ' ) << "Simple Initializer: ";
     value->print( os, indent+2 );
 
-    if ( ! designators.empty() )
-	{
-	    os << std::endl << std::string(indent + 2, ' ' ) << "designated by: "  ;
-	    for ( std::list < Expression * >::iterator i = designators.begin(); i != designators.end(); i++ )
-		( *i )->print(os, indent + 4 );
-	}
+    if ( ! designators.empty() ) {
+	os << std::endl << std::string(indent + 2, ' ' ) << "designated by: "  ;
+	for ( std::list < Expression * >::iterator i = designators.begin(); i != designators.end(); i++ )
+	    ( *i )->print(os, indent + 4 );
+    }
 }
 
-MemberInit::MemberInit( Expression *_value, std::string _member )
-    : member ( _member ), value ( _value )
-{
-}
+MemberInit::MemberInit( Expression *_value, std::string _member ) : member ( _member ), value ( _value ) {}
 
-MemberInit::~MemberInit()
-{
-}
+MemberInit::~MemberInit() {}
 
-MemberInit * MemberInit::clone() const
-{
+MemberInit * MemberInit::clone() const {
     return new MemberInit( *this );
 }
 
-void MemberInit::print( std::ostream &os, int indent )
-{
+void MemberInit::print( std::ostream &os, int indent ) {
     os << "Member Initializer";
     value->print( os, indent+2 );
@@ -82,21 +53,16 @@
 
 ListInit::ListInit( std::list<Initializer*> &_initializers, std::list<Expression *> &_designators )
-    : initializers( _initializers ), designators( _designators )
-{
+    : initializers( _initializers ), designators( _designators ) {
 }
 
-ListInit::~ListInit()
-{
-}
+ListInit::~ListInit() {}
 
-ListInit *ListInit::clone() const
-{
+ListInit *ListInit::clone() const {
     return new ListInit( *this );
 }
 
-void ListInit::print( std::ostream &os, int indent )
-{
+void ListInit::print( std::ostream &os, int indent ) {
     os << std::endl << std::string(indent, ' ') << "Compound initializer:  "; 
-    if( ! designators.empty() ) {
+    if ( ! designators.empty() ) {
 	os << std::string(indent + 2, ' ' ) << "designated by: [";
 	for ( std::list < Expression * >::iterator i = designators.begin();
Index: translator/SynTree/Initializer.h
===================================================================
--- translator/SynTree/Initializer.h	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
+++ translator/SynTree/Initializer.h	(revision d9a0e763800888addddd70d8848a8f432b825e4b)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: Initializer.h,v 1.14 2005/08/29 20:59:25 rcbilson Exp $
- *
- */
-
 #ifndef INITIALIZER_H
 #define INITIALIZER_H
@@ -17,7 +10,6 @@
 
 // Initializer: base class for object initializers (provide default values)
-class Initializer
-{
-public:
+class Initializer {
+  public:
     //	Initializer( std::string _name = std::string(""), int _pos = 0 );
     Initializer( );
@@ -41,6 +33,5 @@
     virtual Initializer *acceptMutator( Mutator &m ) = 0;
     virtual void print( std::ostream &os, int indent = 0 );
-    
-private:
+  private:
     //	std::string name;
     //	int pos;
@@ -48,7 +39,6 @@
 
 // SingleInit represents an initializer for a common object (e.g., int x = 4)
-class SingleInit : public Initializer
-{
-public:
+class SingleInit : public Initializer {
+  public:
     SingleInit( Expression *value, std::list< Expression *> &designators );
     SingleInit( const SingleInit &other );
@@ -65,6 +55,5 @@
     virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 );
-    
-private:
+  private:
     //Constant *value;
     Expression *value;	// has to be a compile-time constant
@@ -72,9 +61,7 @@
 };
 
-// MemberInit represents an initializer for a member of an aggregate object
-// (e.g., struct q { int a } x = { a: 4 } )
-class MemberInit : public Initializer
-{
-public:
+// MemberInit represents an initializer for a member of an aggregate object (e.g., struct q { int a; } x = { a : 4 } )
+class MemberInit : public Initializer {
+  public:
     MemberInit( Expression *value, std::string member = std::string("") );
     virtual ~MemberInit();
@@ -89,15 +76,12 @@
     virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 );
-    
-private:
+  private:
     std::string member;
     Expression *value;
 };
 
-// ElementInit represents an initializer of an element of an array
-// (e.g., [10] int x = { [7]: 4 }
-class ElementInit : public Initializer
-{
-public:
+// ElementInit represents an initializer of an element of an array (e.g., [10] int x = { [7] : 4 }
+class ElementInit : public Initializer {
+  public:
     ElementInit( Expression *value );
     virtual ~ElementInit();
@@ -112,17 +96,15 @@
     virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 );
-    
-private:
+  private:
     int index;
     Expression *value;
 };
 
-// ListInit represents an initializer that is composed recursively of a list of initializers; this
-// is used to initialize an array or aggregate
-class ListInit : public Initializer
-{
-public:
+// ListInit represents an initializer that is composed recursively of a list of initializers; this is used to initialize
+// an array or aggregate
+class ListInit : public Initializer {
+  public:
     ListInit( std::list<Initializer*> &, 
-	    std::list<Expression *> &designators = *(new std::list<Expression *>()) );
+	      std::list<Expression *> &designators = *(new std::list<Expression *>()) );
     virtual ~ListInit();
 
@@ -139,16 +121,8 @@
     virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 );
-    
-private:
+  private:
     std::list<Initializer*> initializers;  // order *is* important
     std::list<Expression *> designators;
 };
 
-
-#endif /* #ifndef INITIALIZER_H */
-
-/*
-    Local Variables:
-    mode: c++
-    End:
-*/
+#endif // INITIALIZER_H
Index: translator/SynTree/Mutator.cc
===================================================================
--- translator/SynTree/Mutator.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
+++ translator/SynTree/Mutator.cc	(revision d9a0e763800888addddd70d8848a8f432b825e4b)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: Mutator.cc,v 1.30 2005/08/29 20:59:25 rcbilson Exp $
- *
- */
-
 #include <cassert>
 #include "Mutator.h"
@@ -16,15 +9,9 @@
 #include "utility.h"
 
-Mutator::Mutator()
-{
-}
-
-Mutator::~Mutator()
-{
-}
-
-ObjectDecl*
-Mutator::mutate(ObjectDecl *objectDecl)
-{
+Mutator::Mutator() {}
+
+Mutator::~Mutator() {}
+
+ObjectDecl *Mutator::mutate( ObjectDecl *objectDecl ) {
     objectDecl->set_type( maybeMutate( objectDecl->get_type(), *this ) );
     objectDecl->set_init( maybeMutate( objectDecl->get_init(), *this ) );
@@ -33,7 +20,5 @@
 }
 
-DeclarationWithType*
-Mutator::mutate(FunctionDecl *functionDecl)
-{
+DeclarationWithType *Mutator::mutate( FunctionDecl *functionDecl ) {
     functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
     mutateAll( functionDecl->get_oldDecls(), *this );
@@ -42,7 +27,5 @@
 }
 
-Declaration*
-Mutator::handleAggregateDecl(AggregateDecl *aggregateDecl)
-{
+Declaration *Mutator::handleAggregateDecl( AggregateDecl *aggregateDecl ) {
     mutateAll( aggregateDecl->get_parameters(), *this );
     mutateAll( aggregateDecl->get_members(), *this );
@@ -50,35 +33,25 @@
 }
 
-Declaration* 
-Mutator::mutate(StructDecl *aggregateDecl)
-{
+Declaration *Mutator::mutate( StructDecl *aggregateDecl ) {
     handleAggregateDecl( aggregateDecl );
     return aggregateDecl;
 }
 
-Declaration* 
-Mutator::mutate(UnionDecl *aggregateDecl)
-{
+Declaration *Mutator::mutate( UnionDecl *aggregateDecl ) {
     handleAggregateDecl( aggregateDecl );
     return aggregateDecl;
 }
 
-Declaration* 
-Mutator::mutate(EnumDecl *aggregateDecl)
-{
+Declaration *Mutator::mutate( EnumDecl *aggregateDecl ) {
     handleAggregateDecl( aggregateDecl );
     return aggregateDecl;
 }
 
-Declaration* 
-Mutator::mutate(ContextDecl *aggregateDecl)
-{
+Declaration *Mutator::mutate( ContextDecl *aggregateDecl ) {
     handleAggregateDecl( aggregateDecl );
     return aggregateDecl;
 }
 
-Declaration*
-Mutator::handleNamedTypeDecl(NamedTypeDecl *typeDecl)
-{
+Declaration *Mutator::handleNamedTypeDecl( NamedTypeDecl *typeDecl ) {
     mutateAll( typeDecl->get_parameters(), *this );
     mutateAll( typeDecl->get_assertions(), *this );
@@ -87,62 +60,46 @@
 }
 
-TypeDecl* 
-Mutator::mutate(TypeDecl *typeDecl)
-{
+TypeDecl *Mutator::mutate( TypeDecl *typeDecl ) {
     handleNamedTypeDecl( typeDecl );
     return typeDecl;
 }
 
-Declaration* 
-Mutator::mutate(TypedefDecl *typeDecl)
-{
+Declaration *Mutator::mutate( TypedefDecl *typeDecl ) {
     handleNamedTypeDecl( typeDecl );
     return typeDecl;
 }
 
-CompoundStmt*
-Mutator::mutate(CompoundStmt *compoundStmt)
-{
+CompoundStmt *Mutator::mutate( CompoundStmt *compoundStmt ) {
     mutateAll( compoundStmt->get_kids(), *this );
     return compoundStmt;
 }
 
-Statement*
-Mutator::mutate(ExprStmt *exprStmt)
-{
+Statement *Mutator::mutate( ExprStmt *exprStmt ) {
     exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
     return exprStmt;
 }
 
-Statement*
-Mutator::mutate(IfStmt *ifStmt)
-{
-    ifStmt->set_condition(  maybeMutate( ifStmt->get_condition(), *this ) );
-    ifStmt->set_thenPart(  maybeMutate( ifStmt->get_thenPart(), *this ) );
-    ifStmt->set_elsePart(  maybeMutate( ifStmt->get_elsePart(), *this ) );
+Statement *Mutator::mutate( IfStmt *ifStmt ) {
+    ifStmt->set_condition( maybeMutate( ifStmt->get_condition(), *this ) );
+    ifStmt->set_thenPart( maybeMutate( ifStmt->get_thenPart(), *this ) );
+    ifStmt->set_elsePart( maybeMutate( ifStmt->get_elsePart(), *this ) );
     return ifStmt;
 }
 
-Statement*
-Mutator::mutate(WhileStmt *whileStmt)
-{
-    whileStmt->set_condition(  maybeMutate( whileStmt->get_condition(), *this ) );
-    whileStmt->set_body(    maybeMutate( whileStmt->get_body(), *this ) );
+Statement *Mutator::mutate( WhileStmt *whileStmt ) {
+    whileStmt->set_condition( maybeMutate( whileStmt->get_condition(), *this ) );
+    whileStmt->set_body( maybeMutate( whileStmt->get_body(), *this ) );
     return whileStmt;
 }
 
-Statement*
-Mutator::mutate(ForStmt *forStmt)
-{
-    forStmt->set_initialization(    maybeMutate( forStmt->get_initialization(), *this ) );
-    forStmt->set_condition(  maybeMutate( forStmt->get_condition(), *this ) );
-    forStmt->set_increment(  maybeMutate( forStmt->get_increment(), *this ) );
-    forStmt->set_body(	maybeMutate( forStmt->get_body(), *this ) );
+Statement *Mutator::mutate( ForStmt *forStmt ) {
+    forStmt->set_initialization( maybeMutate( forStmt->get_initialization(), *this ) );
+    forStmt->set_condition( maybeMutate( forStmt->get_condition(), *this ) );
+    forStmt->set_increment( maybeMutate( forStmt->get_increment(), *this ) );
+    forStmt->set_body( maybeMutate( forStmt->get_body(), *this ) );
     return forStmt;
 }
 
-Statement*
-Mutator::mutate(SwitchStmt *switchStmt)
-{
+Statement *Mutator::mutate( SwitchStmt *switchStmt ) {
     switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
     mutateAll( switchStmt->get_branches(), *this );
@@ -150,22 +107,16 @@
 }
 
-Statement*
-Mutator::mutate(ChooseStmt *switchStmt)
-{
-    switchStmt->set_condition(	maybeMutate( switchStmt->get_condition(), *this ) );
+Statement *Mutator::mutate( ChooseStmt *switchStmt ) {
+    switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
     mutateAll( switchStmt->get_branches(), *this );
     return switchStmt;
 }
 
-Statement*
-Mutator::mutate(FallthruStmt *fallthruStmt)
-{
+Statement *Mutator::mutate( FallthruStmt *fallthruStmt ) {
     return fallthruStmt;
 }
 
-Statement*
-Mutator::mutate(CaseStmt *caseStmt)
-{
-    caseStmt->set_condition(	maybeMutate( caseStmt->get_condition(), *this ) );
+Statement *Mutator::mutate( CaseStmt *caseStmt ) {
+    caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
     mutateAll (caseStmt->get_statements(), *this );
 
@@ -173,20 +124,14 @@
 }
 
-Statement*
-Mutator::mutate(BranchStmt *branchStmt)
-{
+Statement *Mutator::mutate( BranchStmt *branchStmt ) {
     return branchStmt;
 }
 
-Statement*
-Mutator::mutate(ReturnStmt *returnStmt)
-{
-    returnStmt->set_expr(  maybeMutate( returnStmt->get_expr(), *this ) );
+Statement *Mutator::mutate( ReturnStmt *returnStmt ) {
+    returnStmt->set_expr( maybeMutate( returnStmt->get_expr(), *this ) );
     return returnStmt;
 }
 
-Statement*
-Mutator::mutate(TryStmt *tryStmt)
-{
+Statement *Mutator::mutate( TryStmt *tryStmt ) {
     tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
     mutateAll( tryStmt->get_catchers(), *this );
@@ -194,7 +139,5 @@
 }
 
-Statement*
-Mutator::mutate(CatchStmt *catchStmt)
-{
+Statement *Mutator::mutate( CatchStmt *catchStmt ) {
     catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
     catchStmt->set_body( maybeMutate( catchStmt->get_body(), *this ) );
@@ -202,36 +145,26 @@
 }
 
-Statement*
-Mutator::mutate(FinallyStmt *finalStmt)
-{
+Statement *Mutator::mutate( FinallyStmt *finalStmt ) {
     finalStmt->set_block( maybeMutate( finalStmt->get_block(), *this ) );
     return finalStmt;
 }
 
-NullStmt*
-Mutator::mutate(NullStmt *nullStmt)
-{
+NullStmt *Mutator::mutate( NullStmt *nullStmt ) {
     return nullStmt;
 }
 
-Statement*
-Mutator::mutate(DeclStmt *declStmt)
-{
+Statement *Mutator::mutate( DeclStmt *declStmt ) {
     declStmt->set_decl( maybeMutate( declStmt->get_decl(), *this ) );
     return declStmt;
 }
 
-Expression*
-Mutator::mutate(ApplicationExpr *applicationExpr)
-{
+Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
     mutateAll( applicationExpr->get_results(), *this );
-    applicationExpr->set_function(  maybeMutate( applicationExpr->get_function(), *this ) );
+    applicationExpr->set_function( maybeMutate( applicationExpr->get_function(), *this ) );
     mutateAll( applicationExpr->get_args(), *this );
     return applicationExpr;
 }
 
-Expression*
-Mutator::mutate(UntypedExpr *untypedExpr)
-{
+Expression *Mutator::mutate( UntypedExpr *untypedExpr ) {
     mutateAll( untypedExpr->get_results(), *this );
     mutateAll( untypedExpr->get_args(), *this );
@@ -239,61 +172,45 @@
 }
 
-Expression*
-Mutator::mutate(NameExpr *nameExpr)
-{
+Expression *Mutator::mutate( NameExpr *nameExpr ) {
     mutateAll( nameExpr->get_results(), *this );
     return nameExpr;
 }
 
-Expression*
-Mutator::mutate(AddressExpr *addressExpr)
-{
+Expression *Mutator::mutate( AddressExpr *addressExpr ) {
     mutateAll( addressExpr->get_results(), *this );
-    addressExpr->set_arg(  maybeMutate( addressExpr->get_arg(), *this ) );
+    addressExpr->set_arg( maybeMutate( addressExpr->get_arg(), *this ) );
     return addressExpr;
 }
 
-Expression*
-Mutator::mutate(LabelAddressExpr *labelAddressExpr)
-{
+Expression *Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
     mutateAll( labelAddressExpr->get_results(), *this );
-    labelAddressExpr->set_arg(	maybeMutate( labelAddressExpr->get_arg(), *this ) );
+    labelAddressExpr->set_arg( maybeMutate( labelAddressExpr->get_arg(), *this ) );
     return labelAddressExpr;
 }
 
-Expression*
-Mutator::mutate(CastExpr *castExpr)
-{
+Expression *Mutator::mutate( CastExpr *castExpr ) {
     mutateAll( castExpr->get_results(), *this );
-    castExpr->set_arg(	maybeMutate( castExpr->get_arg(), *this ) );
+    castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
     return castExpr;
 }
 
-Expression*
-Mutator::mutate(UntypedMemberExpr *memberExpr)
-{
+Expression *Mutator::mutate( UntypedMemberExpr *memberExpr ) {
     mutateAll( memberExpr->get_results(), *this );
-    memberExpr->set_aggregate(	maybeMutate( memberExpr->get_aggregate(), *this ) );
+    memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
     return memberExpr;
 }
 
-Expression*
-Mutator::mutate(MemberExpr *memberExpr)
-{
+Expression *Mutator::mutate( MemberExpr *memberExpr ) {
     mutateAll( memberExpr->get_results(), *this );
-    memberExpr->set_aggregate(	maybeMutate( memberExpr->get_aggregate(), *this ) );
+    memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
     return memberExpr;
 }
 
-Expression*
-Mutator::mutate(VariableExpr *variableExpr)
-{
+Expression *Mutator::mutate( VariableExpr *variableExpr ) {
     mutateAll( variableExpr->get_results(), *this );
     return variableExpr;
 }
 
-Expression*
-Mutator::mutate(ConstantExpr *constantExpr)
-{
+Expression *Mutator::mutate( ConstantExpr *constantExpr ) {
     mutateAll( constantExpr->get_results(), *this );
 //  maybeMutate( constantExpr->get_constant(), *this )
@@ -301,59 +218,47 @@
 }
 
-Expression*
-Mutator::mutate(SizeofExpr *sizeofExpr)
-{
+Expression *Mutator::mutate( SizeofExpr *sizeofExpr ) {
     mutateAll( sizeofExpr->get_results(), *this );
-    if( sizeofExpr->get_isType() ) {
-	sizeofExpr->set_type(	 maybeMutate( sizeofExpr->get_type(), *this ) );
+    if ( sizeofExpr->get_isType() ) {
+	sizeofExpr->set_type( maybeMutate( sizeofExpr->get_type(), *this ) );
     } else {
-	sizeofExpr->set_expr(	 maybeMutate( sizeofExpr->get_expr(), *this ) );
+	sizeofExpr->set_expr( maybeMutate( sizeofExpr->get_expr(), *this ) );
     }
     return sizeofExpr;
 }
 
-Expression*
-Mutator::mutate(AttrExpr *attrExpr)
-{
+Expression *Mutator::mutate( AttrExpr *attrExpr ) {
     mutateAll( attrExpr->get_results(), *this );
-    if( attrExpr->get_isType() ) {
-	attrExpr->set_type(	 maybeMutate( attrExpr->get_type(), *this ) );
+    if ( attrExpr->get_isType() ) {
+	attrExpr->set_type( maybeMutate( attrExpr->get_type(), *this ) );
     } else {
-	attrExpr->set_expr(	 maybeMutate( attrExpr->get_expr(), *this ) );
+	attrExpr->set_expr( maybeMutate( attrExpr->get_expr(), *this ) );
     }
     return attrExpr;
 }
 
-Expression*
-Mutator::mutate(LogicalExpr *logicalExpr)
-{
+Expression *Mutator::mutate( LogicalExpr *logicalExpr ) {
     mutateAll( logicalExpr->get_results(), *this );
-    logicalExpr->set_arg1(  maybeMutate( logicalExpr->get_arg1(), *this ) );
-    logicalExpr->set_arg2(  maybeMutate( logicalExpr->get_arg2(), *this ) );
+    logicalExpr->set_arg1( maybeMutate( logicalExpr->get_arg1(), *this ) );
+    logicalExpr->set_arg2( maybeMutate( logicalExpr->get_arg2(), *this ) );
     return logicalExpr;
 }
 
-Expression*
-Mutator::mutate(ConditionalExpr *conditionalExpr)
-{
+Expression *Mutator::mutate( ConditionalExpr *conditionalExpr ) {
     mutateAll( conditionalExpr->get_results(), *this );
-    conditionalExpr->set_arg1(	maybeMutate( conditionalExpr->get_arg1(), *this ) );
-    conditionalExpr->set_arg2(	maybeMutate( conditionalExpr->get_arg2(), *this ) );
-    conditionalExpr->set_arg3(	maybeMutate( conditionalExpr->get_arg3(), *this ) );
+    conditionalExpr->set_arg1( maybeMutate( conditionalExpr->get_arg1(), *this ) );
+    conditionalExpr->set_arg2( maybeMutate( conditionalExpr->get_arg2(), *this ) );
+    conditionalExpr->set_arg3( maybeMutate( conditionalExpr->get_arg3(), *this ) );
     return conditionalExpr;
 }
 
-Expression*
-Mutator::mutate(CommaExpr *commaExpr)
-{
+Expression *Mutator::mutate( CommaExpr *commaExpr ) {
     mutateAll( commaExpr->get_results(), *this );
-    commaExpr->set_arg1(    maybeMutate( commaExpr->get_arg1(), *this ) );
-    commaExpr->set_arg2(    maybeMutate( commaExpr->get_arg2(), *this ) );
+    commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
+    commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
     return commaExpr;
 }
 
-Expression*
-Mutator::mutate(TupleExpr *tupleExpr)
-{
+Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
     mutateAll( tupleExpr->get_results(), *this );
     mutateAll( tupleExpr->get_exprs(), *this );
@@ -361,7 +266,5 @@
 }
 
-Expression*
-Mutator::mutate(SolvedTupleExpr *tupleExpr)
-{
+Expression *Mutator::mutate( SolvedTupleExpr *tupleExpr ) {
     mutateAll( tupleExpr->get_results(), *this );
     mutateAll( tupleExpr->get_exprs(), *this );
@@ -369,7 +272,5 @@
 }
 
-Expression*
-Mutator::mutate(TypeExpr *typeExpr)
-{
+Expression *Mutator::mutate( TypeExpr *typeExpr ) {
     mutateAll( typeExpr->get_results(), *this );
     typeExpr->set_type( maybeMutate( typeExpr->get_type(), *this ) );
@@ -377,28 +278,20 @@
 }
 
-Expression*
-Mutator::mutate(UntypedValofExpr *valofExpr)
-{
+Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
     mutateAll( valofExpr->get_results(), *this );
     return valofExpr;
 }
 
-Type*
-Mutator::mutate(VoidType *voidType)
-{
+Type *Mutator::mutate( VoidType *voidType ) {
     mutateAll( voidType->get_forall(), *this );
     return voidType;
 }
 
-Type*
-Mutator::mutate(BasicType *basicType)
-{
+Type *Mutator::mutate( BasicType *basicType ) {
     mutateAll( basicType->get_forall(), *this );
     return basicType;
 }
 
-Type*
-Mutator::mutate(PointerType *pointerType)
-{
+Type *Mutator::mutate( PointerType *pointerType ) {
     mutateAll( pointerType->get_forall(), *this );
     pointerType->set_base( maybeMutate( pointerType->get_base(), *this ) );
@@ -406,7 +299,5 @@
 }
 
-Type*
-Mutator::mutate(ArrayType *arrayType)
-{
+Type *Mutator::mutate( ArrayType *arrayType ) {
     mutateAll( arrayType->get_forall(), *this );
     arrayType->set_dimension( maybeMutate( arrayType->get_dimension(), *this ) );
@@ -415,7 +306,5 @@
 }
 
-Type*
-Mutator::mutate(FunctionType *functionType)
-{
+Type *Mutator::mutate( FunctionType *functionType ) {
     mutateAll( functionType->get_forall(), *this );
     mutateAll( functionType->get_returnVals(), *this );
@@ -424,7 +313,5 @@
 }
 
-Type*
-Mutator::handleReferenceToType(ReferenceToType *aggregateUseType)
-{
+Type *Mutator::handleReferenceToType( ReferenceToType *aggregateUseType ) {
     mutateAll( aggregateUseType->get_forall(), *this );
     mutateAll( aggregateUseType->get_parameters(), *this );
@@ -432,28 +319,20 @@
 }
 
-Type* 
-Mutator::mutate(StructInstType *aggregateUseType)
-{
-    handleReferenceToType( aggregateUseType );
-    return aggregateUseType;
-}
-
-Type* 
-Mutator::mutate(UnionInstType *aggregateUseType)
-{
-    handleReferenceToType( aggregateUseType );
-    return aggregateUseType;
-}
-
-Type* 
-Mutator::mutate(EnumInstType *aggregateUseType)
-{
-    handleReferenceToType( aggregateUseType );
-    return aggregateUseType;
-}
-
-Type* 
-Mutator::mutate(ContextInstType *aggregateUseType)
-{
+Type *Mutator::mutate( StructInstType *aggregateUseType ) {
+    handleReferenceToType( aggregateUseType );
+    return aggregateUseType;
+}
+
+Type *Mutator::mutate( UnionInstType *aggregateUseType ) {
+    handleReferenceToType( aggregateUseType );
+    return aggregateUseType;
+}
+
+Type *Mutator::mutate( EnumInstType *aggregateUseType ) {
+    handleReferenceToType( aggregateUseType );
+    return aggregateUseType;
+}
+
+Type *Mutator::mutate( ContextInstType *aggregateUseType ) {
     handleReferenceToType( aggregateUseType );
     mutateAll( aggregateUseType->get_members(), *this );
@@ -461,14 +340,10 @@
 }
 
-Type* 
-Mutator::mutate(TypeInstType *aggregateUseType)
-{
-    handleReferenceToType( aggregateUseType );
-    return aggregateUseType;
-}
-
-Type*
-Mutator::mutate(TupleType *tupleType)
-{
+Type *Mutator::mutate( TypeInstType *aggregateUseType ) {
+    handleReferenceToType( aggregateUseType );
+    return aggregateUseType;
+}
+
+Type *Mutator::mutate( TupleType *tupleType ) {
     mutateAll( tupleType->get_forall(), *this );
     mutateAll( tupleType->get_types(), *this );
@@ -476,7 +351,5 @@
 }
 
-Type*
-Mutator::mutate(TypeofType *typeofType)
-{
+Type *Mutator::mutate( TypeofType *typeofType ) {
     assert( typeofType->get_expr() );
     typeofType->set_expr( typeofType->get_expr()->acceptMutator( *this ) );
@@ -484,8 +357,6 @@
 }
 
-Type*
-Mutator::mutate(AttrType *attrType)
-{
-    if( attrType->get_isType() ) {
+Type *Mutator::mutate( AttrType *attrType ) {
+    if ( attrType->get_isType() ) {
 	assert( attrType->get_type() );
 	attrType->set_type( attrType->get_type()->acceptMutator( *this ) );
@@ -497,28 +368,20 @@
 }
 
-Initializer*
-Mutator::mutate(MemberInit *memberInit)
-{
+Initializer *Mutator::mutate( MemberInit *memberInit ) {
     memberInit->set_value( memberInit->get_value()->acceptMutator( *this ) );
     return memberInit;
 }
 
-Initializer*
-Mutator::mutate(ElementInit *elementInit)
-{
+Initializer *Mutator::mutate( ElementInit *elementInit ) {
     elementInit->set_value( elementInit->get_value()->acceptMutator( *this ) );
     return elementInit;
 }
 
-Initializer*
-Mutator::mutate(SingleInit *singleInit)
-{
+Initializer *Mutator::mutate( SingleInit *singleInit ) {
     singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
     return singleInit;
 }
 
-Initializer*
-Mutator::mutate(ListInit *listInit)
-{
+Initializer *Mutator::mutate( ListInit *listInit ) {
     mutateAll( listInit->get_designators(), *this );
     mutateAll( listInit->get_initializers(), *this );
@@ -526,14 +389,9 @@
 }
 
-Subrange *
-Mutator::mutate(Subrange *subrange)
-{
+Subrange *Mutator::mutate( Subrange *subrange ) {
     return subrange;
 }
 
-Constant *
-Mutator::mutate(Constant *constant)
-{
+Constant *Mutator::mutate( Constant *constant ) {
     return constant;
 }
-
Index: translator/SynTree/Mutator.h
===================================================================
--- translator/SynTree/Mutator.h	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
+++ translator/SynTree/Mutator.h	(revision d9a0e763800888addddd70d8848a8f432b825e4b)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: Mutator.h,v 1.19 2005/08/29 20:59:25 rcbilson Exp $
- *
- */
-
 #include <cassert>
 
@@ -14,92 +7,86 @@
 #define SYNTREE_MUTATOR_H
 
-
-class Mutator
-{
-protected:
+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 );
 
-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 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 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 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 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 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);
+    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 ) {
+inline TreeType *maybeMutate( TreeType *tree, MutatorType &mutator ) {
+    if ( tree ) {
 	TreeType *newnode = dynamic_cast< TreeType* >( tree->acceptMutator( mutator ) );
 	assert( newnode );
@@ -112,11 +99,9 @@
 
 template< typename Container, typename MutatorType >
-inline void
-mutateAll( Container &container, MutatorType &mutator )
-{
+inline void mutateAll( Container &container, MutatorType &mutator ) {
     SemanticError errors;
-    for( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+    for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
 	try {
-	    if( *i ) {
+	    if ( *i ) {
 ///		    *i = (*i)->acceptMutator( mutator );
 		*i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) );
@@ -127,12 +112,10 @@
 	}
     }
-    if( !errors.isEmpty() ) {
+    if ( !errors.isEmpty() ) {
 	throw errors;
     }
 }
 
-
-
-#endif /* #ifndef SYNTREE_MUTATOR_H */
+#endif // SYNTREE_MUTATOR_H
 
 // Local Variables: //
Index: translator/SynTree/ObjectDecl.cc
===================================================================
--- translator/SynTree/ObjectDecl.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
+++ translator/SynTree/ObjectDecl.cc	(revision d9a0e763800888addddd70d8848a8f432b825e4b)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: ObjectDecl.cc,v 1.8 2005/08/29 20:59:25 rcbilson Exp $
- *
- */
-
 #include "Declaration.h"
 #include "Type.h"
@@ -14,15 +7,12 @@
 
 ObjectDecl::ObjectDecl( const std::string &name, StorageClass sc, LinkageSpec::Type linkage, Expression *bitfieldWidth, Type *type, Initializer *init )
-    : Parent( name, sc, linkage ), type( type ), init( init ), bitfieldWidth( bitfieldWidth )
-{
+    : Parent( name, sc, linkage ), type( type ), init( init ), bitfieldWidth( bitfieldWidth ) {
 }
 
 ObjectDecl::ObjectDecl( const ObjectDecl &other )
-    : Parent( other ), type( maybeClone( other.type ) ), init( maybeClone( other.init ) ), bitfieldWidth( maybeClone( other.bitfieldWidth ) )
-{
+    : Parent( other ), type( maybeClone( other.type ) ), init( maybeClone( other.init ) ), bitfieldWidth( maybeClone( other.bitfieldWidth ) ) {
 }
 
-ObjectDecl::~ObjectDecl()
-{
+ObjectDecl::~ObjectDecl() {
     delete type;
     delete init;
@@ -30,26 +20,29 @@
 }
 
-void 
-ObjectDecl::print( std::ostream &os, int indent ) const
-{
-    if( get_name() != "" ) {
+void ObjectDecl::print( std::ostream &os, int indent ) const {
+    if ( get_name() != "" ) {
 	os << get_name() << ": a ";
     }
-    if( get_linkage() != LinkageSpec::Cforall ) {
+
+    if ( get_linkage() != LinkageSpec::Cforall ) {
 	os << LinkageSpec::toString( get_linkage() ) << " ";
     }
-    if( get_storageClass() != NoStorageClass ) {
+
+    if ( get_storageClass() != NoStorageClass ) {
 	os << storageClassName[ get_storageClass() ] << ' ';
     }
-    if( get_type() ) {
+
+    if ( get_type() ) {
 	get_type()->print( os, indent );
     } else {
 	os << "untyped entity ";
     }
-    if( init ) {
+
+    if ( init ) {
 	os << "with initializer ";
 	init->print( os, indent );
     }
-    if( bitfieldWidth ) {
+
+    if ( bitfieldWidth ) {
 	os << "with bitfield width ";
 	bitfieldWidth->print( os );
@@ -57,22 +50,22 @@
 }
 
-void 
-ObjectDecl::printShort( std::ostream &os, int indent ) const
-{
-    if( get_name() != "" ) {
+void ObjectDecl::printShort( std::ostream &os, int indent ) const {
+    if ( get_name() != "" ) {
 	os << get_name() << ": a ";
     }
-    if( get_storageClass() != NoStorageClass ) {
+
+    if ( get_storageClass() != NoStorageClass ) {
 	os << storageClassName[ get_storageClass() ] << ' ';
     }
-    if( get_type() ) {
+
+    if ( get_type() ) {
 	get_type()->print( os, indent );
     } else {
 	os << "untyped entity ";
     }
-    if( bitfieldWidth ) {
+
+    if ( bitfieldWidth ) {
 	os << "with bitfield width ";
 	bitfieldWidth->print( os );
     }
 }
-
Index: translator/SynTree/Visitor.cc
===================================================================
--- translator/SynTree/Visitor.cc	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
+++ translator/SynTree/Visitor.cc	(revision d9a0e763800888addddd70d8848a8f432b825e4b)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: Visitor.cc,v 1.30 2005/08/29 20:59:27 rcbilson Exp $
- *
- */
-
 #include <cassert>
 #include "Visitor.h"
@@ -16,15 +9,9 @@
 
 
-Visitor::Visitor()
-{
-}
-
-Visitor::~Visitor()
-{
-}
-
-void
-Visitor::visit(ObjectDecl *objectDecl)
-{
+Visitor::Visitor() {}
+
+Visitor::~Visitor() {}
+
+void Visitor::visit(ObjectDecl *objectDecl) {
     maybeAccept( objectDecl->get_type(), *this );
     maybeAccept( objectDecl->get_init(), *this );
@@ -32,7 +19,5 @@
 }
 
-void
-Visitor::visit(FunctionDecl *functionDecl)
-{
+void Visitor::visit(FunctionDecl *functionDecl) {
     maybeAccept( functionDecl->get_functionType(), *this );
     acceptAll( functionDecl->get_oldDecls(), *this );
@@ -40,38 +25,26 @@
 }
 
-void
-Visitor::visit(AggregateDecl *aggregateDecl)
-{
+void Visitor::visit(AggregateDecl *aggregateDecl) {
     acceptAll( aggregateDecl->get_parameters(), *this );
     acceptAll( aggregateDecl->get_members(), *this );
 }
 
-void 
-Visitor::visit(StructDecl *aggregateDecl)
-{
+void Visitor::visit(StructDecl *aggregateDecl) {
     visit( static_cast< AggregateDecl* >( aggregateDecl ) );
 }
 
-void 
-Visitor::visit(UnionDecl *aggregateDecl)
-{
+void Visitor::visit(UnionDecl *aggregateDecl) {
     visit( static_cast< AggregateDecl* >( aggregateDecl ) );
 }
 
-void 
-Visitor::visit(EnumDecl *aggregateDecl)
-{
+void Visitor::visit(EnumDecl *aggregateDecl) {
     visit( static_cast< AggregateDecl* >( aggregateDecl ) );
 }
 
-void 
-Visitor::visit(ContextDecl *aggregateDecl)
-{
+void Visitor::visit(ContextDecl *aggregateDecl) {
     visit( static_cast< AggregateDecl* >( aggregateDecl ) );
 }
 
-void
-Visitor::visit(NamedTypeDecl *typeDecl)
-{
+void Visitor::visit(NamedTypeDecl *typeDecl) {
     acceptAll( typeDecl->get_parameters(), *this );
     acceptAll( typeDecl->get_assertions(), *this );
@@ -79,31 +52,21 @@
 }
 
-void 
-Visitor::visit(TypeDecl *typeDecl)
-{
+void Visitor::visit(TypeDecl *typeDecl) {
     visit( static_cast< NamedTypeDecl* >( typeDecl ) );
 }
 
-void 
-Visitor::visit(TypedefDecl *typeDecl)
-{
+void Visitor::visit(TypedefDecl *typeDecl) {
     visit( static_cast< NamedTypeDecl* >( typeDecl ) );
 }
 
-void
-Visitor::visit(CompoundStmt *compoundStmt)
-{
+void Visitor::visit(CompoundStmt *compoundStmt) {
     acceptAll( compoundStmt->get_kids(), *this );
 }
 
-void
-Visitor::visit(ExprStmt *exprStmt)
-{
+void Visitor::visit(ExprStmt *exprStmt) {
     maybeAccept( exprStmt->get_expr(), *this );
 }
 
-void
-Visitor::visit(IfStmt *ifStmt)
-{
+void Visitor::visit(IfStmt *ifStmt) {
     maybeAccept( ifStmt->get_condition(), *this );
     maybeAccept( ifStmt->get_thenPart(), *this );
@@ -111,14 +74,10 @@
 }
 
-void
-Visitor::visit(WhileStmt *whileStmt)
-{
+void Visitor::visit(WhileStmt *whileStmt) {
     maybeAccept( whileStmt->get_condition(), *this );
     maybeAccept( whileStmt->get_body(), *this );
 }
 
-void
-Visitor::visit(ForStmt *forStmt)
-{
+void Visitor::visit(ForStmt *forStmt) {
     // ForStmt still needs to be fixed
     maybeAccept( forStmt->get_initialization(), *this );
@@ -128,73 +87,50 @@
 }
 
-void
-Visitor::visit(SwitchStmt *switchStmt)
-{
+void Visitor::visit(SwitchStmt *switchStmt) {
     maybeAccept( switchStmt->get_condition(), *this );
     acceptAll( switchStmt->get_branches(), *this );
 }
 
-void
-Visitor::visit(ChooseStmt *switchStmt)
-{
+void Visitor::visit(ChooseStmt *switchStmt) {
     maybeAccept( switchStmt->get_condition(), *this );
     acceptAll( switchStmt->get_branches(), *this );
 }
 
-void
-Visitor::visit(FallthruStmt *fallthruStmt){}
-
-void
-Visitor::visit(CaseStmt *caseStmt)
-{
+void Visitor::visit(FallthruStmt *fallthruStmt){}
+
+void Visitor::visit(CaseStmt *caseStmt) {
     maybeAccept( caseStmt->get_condition(), *this );
     acceptAll( caseStmt->get_statements(), *this );
 }
 
-void
-Visitor::visit(BranchStmt *branchStmt)
-{
-}
-
-void
-Visitor::visit(ReturnStmt *returnStmt)
-{
+void Visitor::visit(BranchStmt *branchStmt) {
+}
+
+void Visitor::visit(ReturnStmt *returnStmt) {
     maybeAccept( returnStmt->get_expr(), *this );
 }
 
-void
-Visitor::visit(TryStmt *tryStmt)
-{
+void Visitor::visit(TryStmt *tryStmt) {
     maybeAccept( tryStmt->get_block(), *this );
     acceptAll( tryStmt->get_catchers(), *this );
 }
 
-void
-Visitor::visit(CatchStmt *catchStmt)
-{
+void Visitor::visit(CatchStmt *catchStmt) {
     maybeAccept( catchStmt->get_decl(), *this );
     maybeAccept( catchStmt->get_body(), *this );
 }
 
-void
-Visitor::visit(FinallyStmt *finalStmt)
-{
+void Visitor::visit(FinallyStmt *finalStmt) {
     maybeAccept( finalStmt->get_block(), *this );
 }
 
-void
-Visitor::visit(NullStmt *nullStmt)
-{
-}
-
-void
-Visitor::visit(DeclStmt *declStmt)
-{
+void Visitor::visit(NullStmt *nullStmt) {
+}
+
+void Visitor::visit(DeclStmt *declStmt) {
     maybeAccept( declStmt->get_decl(), *this );
 }
 
-void
-Visitor::visit(ApplicationExpr *applicationExpr)
-{
+void Visitor::visit(ApplicationExpr *applicationExpr) {
     acceptAll( applicationExpr->get_results(), *this );
     maybeAccept( applicationExpr->get_function(), *this );
@@ -202,70 +138,50 @@
 }
 
-void
-Visitor::visit(UntypedExpr *untypedExpr)
-{
+void Visitor::visit(UntypedExpr *untypedExpr) {
     acceptAll( untypedExpr->get_results(), *this );
     acceptAll( untypedExpr->get_args(), *this );
 }
 
-void
-Visitor::visit(NameExpr *nameExpr)
-{
+void Visitor::visit(NameExpr *nameExpr) {
     acceptAll( nameExpr->get_results(), *this );
 }
 
-void
-Visitor::visit(AddressExpr *addressExpr)
-{
+void Visitor::visit(AddressExpr *addressExpr) {
     acceptAll( addressExpr->get_results(), *this );
     maybeAccept( addressExpr->get_arg(), *this );
 }
 
-void
-Visitor::visit(LabelAddressExpr *labAddressExpr)
-{
+void Visitor::visit(LabelAddressExpr *labAddressExpr) {
     acceptAll( labAddressExpr->get_results(), *this );
     maybeAccept( labAddressExpr->get_arg(), *this );
 }
 
-void
-Visitor::visit(CastExpr *castExpr)
-{
+void Visitor::visit(CastExpr *castExpr) {
     acceptAll( castExpr->get_results(), *this );
     maybeAccept( castExpr->get_arg(), *this );
 }
 
-void
-Visitor::visit(UntypedMemberExpr *memberExpr)
-{
+void Visitor::visit(UntypedMemberExpr *memberExpr) {
     acceptAll( memberExpr->get_results(), *this );
     maybeAccept( memberExpr->get_aggregate(), *this );
 }
 
-void
-Visitor::visit(MemberExpr *memberExpr)
-{
+void Visitor::visit(MemberExpr *memberExpr) {
     acceptAll( memberExpr->get_results(), *this );
     maybeAccept( memberExpr->get_aggregate(), *this );
 }
 
-void
-Visitor::visit(VariableExpr *variableExpr)
-{
+void Visitor::visit(VariableExpr *variableExpr) {
     acceptAll( variableExpr->get_results(), *this );
 }
 
-void
-Visitor::visit(ConstantExpr *constantExpr)
-{
+void Visitor::visit(ConstantExpr *constantExpr) {
     acceptAll( constantExpr->get_results(), *this );
     maybeAccept( constantExpr->get_constant(), *this );
 }
 
-void
-Visitor::visit(SizeofExpr *sizeofExpr)
-{
+void Visitor::visit(SizeofExpr *sizeofExpr) {
     acceptAll( sizeofExpr->get_results(), *this );
-    if( sizeofExpr->get_isType() ) {
+    if ( sizeofExpr->get_isType() ) {
 	maybeAccept( sizeofExpr->get_type(), *this );
     } else {
@@ -274,9 +190,7 @@
 }
 
-void
-Visitor::visit(AttrExpr *attrExpr)
-{
+void Visitor::visit(AttrExpr *attrExpr) {
     acceptAll( attrExpr->get_results(), *this );
-    if( attrExpr->get_isType() ) {
+    if ( attrExpr->get_isType() ) {
 	maybeAccept( attrExpr->get_type(), *this );
     } else {
@@ -285,7 +199,5 @@
 }
 
-void
-Visitor::visit(LogicalExpr *logicalExpr)
-{
+void Visitor::visit(LogicalExpr *logicalExpr) {
     acceptAll( logicalExpr->get_results(), *this );
     maybeAccept( logicalExpr->get_arg1(), *this );
@@ -293,7 +205,5 @@
 }
 
-void
-Visitor::visit(ConditionalExpr *conditionalExpr)
-{
+void Visitor::visit(ConditionalExpr *conditionalExpr) {
     acceptAll( conditionalExpr->get_results(), *this );
     maybeAccept( conditionalExpr->get_arg1(), *this );
@@ -302,7 +212,5 @@
 }
 
-void
-Visitor::visit(CommaExpr *commaExpr)
-{
+void Visitor::visit(CommaExpr *commaExpr) {
     acceptAll( commaExpr->get_results(), *this );
     maybeAccept( commaExpr->get_arg1(), *this );
@@ -310,54 +218,38 @@
 }
 
-void
-Visitor::visit(TupleExpr *tupleExpr)
-{
+void Visitor::visit(TupleExpr *tupleExpr) {
     acceptAll( tupleExpr->get_results(), *this );
     acceptAll( tupleExpr->get_exprs(), *this );
 }
 
-void
-Visitor::visit(SolvedTupleExpr *tupleExpr)
-{
+void Visitor::visit(SolvedTupleExpr *tupleExpr) {
     acceptAll( tupleExpr->get_results(), *this );
     acceptAll( tupleExpr->get_exprs(), *this );
 }
 
-void
-Visitor::visit(TypeExpr *typeExpr)
-{
+void Visitor::visit(TypeExpr *typeExpr) {
     acceptAll( typeExpr->get_results(), *this );
     maybeAccept( typeExpr->get_type(), *this );
 }
 
-void
-Visitor::visit(UntypedValofExpr *valofExpr)
-{
+void Visitor::visit(UntypedValofExpr *valofExpr) {
     acceptAll( valofExpr->get_results(), *this );
     maybeAccept( valofExpr->get_body(), *this );
 }
 
-void
-Visitor::visit(VoidType *voidType)
-{
+void Visitor::visit(VoidType *voidType) {
     acceptAll( voidType->get_forall(), *this );
 }
 
-void
-Visitor::visit(BasicType *basicType)
-{
+void Visitor::visit(BasicType *basicType) {
     acceptAll( basicType->get_forall(), *this );
 }
 
-void
-Visitor::visit(PointerType *pointerType)
-{
+void Visitor::visit(PointerType *pointerType) {
     acceptAll( pointerType->get_forall(), *this );
     maybeAccept( pointerType->get_base(), *this );
 }
 
-void
-Visitor::visit(ArrayType *arrayType)
-{
+void Visitor::visit(ArrayType *arrayType) {
     acceptAll( arrayType->get_forall(), *this );
     maybeAccept( arrayType->get_dimension(), *this );
@@ -365,7 +257,5 @@
 }
 
-void
-Visitor::visit(FunctionType *functionType)
-{
+void Visitor::visit(FunctionType *functionType) {
     acceptAll( functionType->get_forall(), *this );
     acceptAll( functionType->get_returnVals(), *this );
@@ -373,60 +263,42 @@
 }
 
-void
-Visitor::visit(ReferenceToType *aggregateUseType)
-{
+void Visitor::visit(ReferenceToType *aggregateUseType) {
     acceptAll( aggregateUseType->get_forall(), *this );
     acceptAll( aggregateUseType->get_parameters(), *this );
 }
 
-void 
-Visitor::visit(StructInstType *aggregateUseType)
-{
-    visit( static_cast< ReferenceToType* >( aggregateUseType ) );
-}
-
-void 
-Visitor::visit(UnionInstType *aggregateUseType)
-{
-    visit( static_cast< ReferenceToType* >( aggregateUseType ) );
-}
-
-void 
-Visitor::visit(EnumInstType *aggregateUseType)
-{
-    visit( static_cast< ReferenceToType* >( aggregateUseType ) );
-}
-
-void 
-Visitor::visit(ContextInstType *aggregateUseType)
-{
+void Visitor::visit(StructInstType *aggregateUseType) {
+    visit( static_cast< ReferenceToType* >( aggregateUseType ) );
+}
+
+void Visitor::visit(UnionInstType *aggregateUseType) {
+    visit( static_cast< ReferenceToType* >( aggregateUseType ) );
+}
+
+void Visitor::visit(EnumInstType *aggregateUseType) {
+    visit( static_cast< ReferenceToType* >( aggregateUseType ) );
+}
+
+void Visitor::visit(ContextInstType *aggregateUseType) {
     visit( static_cast< ReferenceToType* >( aggregateUseType ) );
     acceptAll( aggregateUseType->get_members(), *this );
 }
 
-void 
-Visitor::visit(TypeInstType *aggregateUseType)
-{
-    visit( static_cast< ReferenceToType* >( aggregateUseType ) );
-}
-
-void
-Visitor::visit(TupleType *tupleType)
-{
+void Visitor::visit(TypeInstType *aggregateUseType) {
+    visit( static_cast< ReferenceToType* >( aggregateUseType ) );
+}
+
+void Visitor::visit(TupleType *tupleType) {
     acceptAll( tupleType->get_forall(), *this );
     acceptAll( tupleType->get_types(), *this );
 }
 
-void
-Visitor::visit(TypeofType *typeofType)
-{
+void Visitor::visit(TypeofType *typeofType) {
     assert( typeofType->get_expr() );
     typeofType->get_expr()->accept( *this );
 }
 
-void
-Visitor::visit(AttrType *attrType)
-{
-    if( attrType->get_isType() ) {
+void Visitor::visit(AttrType *attrType) {
+    if ( attrType->get_isType() ) {
 	assert( attrType->get_type() );
 	attrType->get_type()->accept( *this );
@@ -437,37 +309,22 @@
 }
 
-void
-Visitor::visit(MemberInit *memberInit)
-{
+void Visitor::visit(MemberInit *memberInit) {
     memberInit->get_value()->accept( *this );
 }
 
-void
-Visitor::visit(ElementInit *elementInit)
-{
+void Visitor::visit(ElementInit *elementInit) {
     elementInit->get_value()->accept( *this );
 }
 
-void
-Visitor::visit(SingleInit *singleInit)
-{
+void Visitor::visit(SingleInit *singleInit) {
     singleInit->get_value()->accept( *this );
 }
 
-void
-Visitor::visit(ListInit *listInit)
-{
+void Visitor::visit(ListInit *listInit) {
     acceptAll( listInit->get_designators(), *this );
     acceptAll( listInit->get_initializers(), *this );
 }
 
-void
-Visitor::visit(Subrange *subrange)
-{
-}
-
-void
-Visitor::visit(Constant *constant)
-{
-}
-
+void Visitor::visit(Subrange *subrange) {}
+
+void Visitor::visit(Constant *constant) {}
Index: translator/SynTree/Visitor.h
===================================================================
--- translator/SynTree/Visitor.h	(revision 3848e0e8736f68e720b8e97d4e893bb0bb0aca6b)
+++ translator/SynTree/Visitor.h	(revision d9a0e763800888addddd70d8848a8f432b825e4b)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: Visitor.h,v 1.23 2005/08/29 20:59:27 rcbilson Exp $
- *
- */
-
 #ifndef VISITOR_H
 #define VISITOR_H
@@ -14,91 +7,86 @@
 
 
-class Visitor
-{
-protected:
+class Visitor {
+  protected:
     Visitor();
     virtual ~Visitor();
+  public:
+    virtual void visit( ObjectDecl *objectDecl );
+    virtual void visit( FunctionDecl *functionDecl );
+    virtual void visit( StructDecl *aggregateDecl );
+    virtual void visit( UnionDecl *aggregateDecl );
+    virtual void visit( EnumDecl *aggregateDecl );
+    virtual void visit( ContextDecl *aggregateDecl );
+    virtual void visit( TypeDecl *typeDecl );
+    virtual void visit( TypedefDecl *typeDecl );
 
-public:
-    virtual void visit(ObjectDecl *objectDecl);
-    virtual void visit(FunctionDecl *functionDecl);
-    virtual void visit(StructDecl *aggregateDecl);
-    virtual void visit(UnionDecl *aggregateDecl);
-    virtual void visit(EnumDecl *aggregateDecl);
-    virtual void visit(ContextDecl *aggregateDecl);
-    virtual void visit(TypeDecl *typeDecl);
-    virtual void visit(TypedefDecl *typeDecl);
+    virtual void visit( CompoundStmt *compoundStmt );
+    virtual void visit( ExprStmt *exprStmt );
+    virtual void visit( IfStmt *ifStmt );
+    virtual void visit( WhileStmt *whileStmt );
+    virtual void visit( ForStmt *forStmt );
+    virtual void visit( SwitchStmt *switchStmt );
+    virtual void visit( ChooseStmt *switchStmt );
+    virtual void visit( FallthruStmt *switchStmt );
+    virtual void visit( CaseStmt *caseStmt );
+    virtual void visit( BranchStmt *branchStmt );
+    virtual void visit( ReturnStmt *returnStmt );
+    virtual void visit( TryStmt *tryStmt );
+    virtual void visit( CatchStmt *catchStmt );
+    virtual void visit( FinallyStmt *finallyStmt );
+    virtual void visit( NullStmt *nullStmt );
+    virtual void visit( DeclStmt *declStmt );
 
-    virtual void visit(CompoundStmt *compoundStmt);
-    virtual void visit(ExprStmt *exprStmt);
-    virtual void visit(IfStmt *ifStmt);
-    virtual void visit(WhileStmt *whileStmt);
-    virtual void visit(ForStmt *forStmt);
-    virtual void visit(SwitchStmt *switchStmt);
-    virtual void visit(ChooseStmt *switchStmt);
-    virtual void visit(FallthruStmt *switchStmt);
-    virtual void visit(CaseStmt *caseStmt);
-    virtual void visit(BranchStmt *branchStmt);
-    virtual void visit(ReturnStmt *returnStmt);
-    virtual void visit(TryStmt *tryStmt);
-    virtual void visit(CatchStmt *catchStmt);
-    virtual void visit(FinallyStmt *finallyStmt);
-    virtual void visit(NullStmt *nullStmt);
-    virtual void visit(DeclStmt *declStmt);
+    virtual void visit( ApplicationExpr *applicationExpr );
+    virtual void visit( UntypedExpr *untypedExpr );
+    virtual void visit( NameExpr *nameExpr );
+    virtual void visit( CastExpr *castExpr );
+    virtual void visit( AddressExpr *addressExpr );
+    virtual void visit( LabelAddressExpr *labAddressExpr );
+    virtual void visit( UntypedMemberExpr *memberExpr );
+    virtual void visit( MemberExpr *memberExpr );
+    virtual void visit( VariableExpr *variableExpr );
+    virtual void visit( ConstantExpr *constantExpr ); 
+    virtual void visit( SizeofExpr *sizeofExpr );
+    virtual void visit( AttrExpr *attrExpr );
+    virtual void visit( LogicalExpr *logicalExpr );
+    virtual void visit( ConditionalExpr *conditionalExpr );
+    virtual void visit( CommaExpr *commaExpr );
+    virtual void visit( TupleExpr *tupleExpr );
+    virtual void visit( SolvedTupleExpr *tupleExpr );
+    virtual void visit( TypeExpr *typeExpr );
+    virtual void visit( UntypedValofExpr *valofExpr );
 
-    virtual void visit(ApplicationExpr *applicationExpr);
-    virtual void visit(UntypedExpr *untypedExpr);
-    virtual void visit(NameExpr *nameExpr);
-    virtual void visit(CastExpr *castExpr);
-    virtual void visit(AddressExpr *addressExpr);
-    virtual void visit(LabelAddressExpr *labAddressExpr);
-    virtual void visit(UntypedMemberExpr *memberExpr);
-    virtual void visit(MemberExpr *memberExpr);
-    virtual void visit(VariableExpr *variableExpr);
-    virtual void visit(ConstantExpr *constantExpr); 
-    virtual void visit(SizeofExpr *sizeofExpr);
-    virtual void visit(AttrExpr *attrExpr);
-    virtual void visit(LogicalExpr *logicalExpr);
-    virtual void visit(ConditionalExpr *conditionalExpr);
-    virtual void visit(CommaExpr *commaExpr);
-    virtual void visit(TupleExpr *tupleExpr);
-    virtual void visit(SolvedTupleExpr *tupleExpr);
-    virtual void visit(TypeExpr *typeExpr);
-    virtual void visit(UntypedValofExpr *valofExpr);
+    virtual void visit( VoidType *basicType );
+    virtual void visit( BasicType *basicType );
+    virtual void visit( PointerType *pointerType );
+    virtual void visit( ArrayType *arrayType );
+    virtual void visit( FunctionType *functionType );
+    virtual void visit( StructInstType *aggregateUseType );
+    virtual void visit( UnionInstType *aggregateUseType );
+    virtual void visit( EnumInstType *aggregateUseType );
+    virtual void visit( ContextInstType *aggregateUseType );
+    virtual void visit( TypeInstType *aggregateUseType );
+    virtual void visit( TupleType *tupleType );
+    virtual void visit( TypeofType *typeofType );
+    virtual void visit( AttrType *attrType );
 
-    virtual void visit(VoidType *basicType);
-    virtual void visit(BasicType *basicType);
-    virtual void visit(PointerType *pointerType);
-    virtual void visit(ArrayType *arrayType);
-    virtual void visit(FunctionType *functionType);
-    virtual void visit(StructInstType *aggregateUseType);
-    virtual void visit(UnionInstType *aggregateUseType);
-    virtual void visit(EnumInstType *aggregateUseType);
-    virtual void visit(ContextInstType *aggregateUseType);
-    virtual void visit(TypeInstType *aggregateUseType);
-    virtual void visit(TupleType *tupleType);
-    virtual void visit(TypeofType *typeofType);
-    virtual void visit(AttrType *attrType);
+    virtual void visit( MemberInit *memberInit );
+    virtual void visit( ElementInit *elementInit );
+    virtual void visit( SingleInit *singleInit );
+    virtual void visit( ListInit *listInit );
 
-    virtual void visit(MemberInit *memberInit);
-    virtual void visit(ElementInit *elementInit);
-    virtual void visit(SingleInit *singleInit);
-    virtual void visit(ListInit *listInit);
+    virtual void visit( Subrange *subrange );
 
-    virtual void visit(Subrange *subrange);
-
-    virtual void visit(Constant *constant);
-
-private:
-    virtual void visit(AggregateDecl *aggregateDecl);
-    virtual void visit(NamedTypeDecl *typeDecl);
-    virtual void visit(ReferenceToType *aggregateUseType);
+    virtual void visit( Constant *constant );
+  private:
+    virtual void visit( AggregateDecl *aggregateDecl );
+    virtual void visit( NamedTypeDecl *typeDecl );
+    virtual void visit( ReferenceToType *aggregateUseType );
 };
 
 template< typename TreeType, typename VisitorType >
-inline void
-maybeAccept( TreeType *tree, VisitorType &visitor )
-{
-    if( tree ) {
+inline void maybeAccept( TreeType *tree, VisitorType &visitor ) {
+    if ( tree ) {
 	tree->accept( visitor );
     }
@@ -106,11 +94,9 @@
 
 template< typename Container, typename VisitorType >
-inline void
-acceptAll( Container &container, VisitorType &visitor )
-{
+inline void acceptAll( Container &container, VisitorType &visitor ) {
     SemanticError errors;
-   for( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+    for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
 	try {
-	    if( *i ) {
+	    if ( *i ) {
 		(*i)->accept( visitor );
 	    }
@@ -119,5 +105,5 @@
 	}
     }
-    if( !errors.isEmpty() ) {
+    if ( !errors.isEmpty() ) {
 	throw errors;
     }
@@ -125,21 +111,19 @@
 
 template< typename Container, typename VisitorType >
-void
-acceptAllFold( Container &container, VisitorType &visitor, VisitorType &around )
-{
+void acceptAllFold( Container &container, VisitorType &visitor, VisitorType &around ) {
     SemanticError errors;
-    for( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+    for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
 	try {
-	    if( *i ) {
-    VisitorType *v = new VisitorType;
+	    if ( *i ) {
+		VisitorType *v = new VisitorType;
 		(*i)->accept( *v );
 
-    typename Container::iterator nxt = i; nxt++; // forward_iterator
-    if( nxt == container.end() )
-	visitor += *v;
-    else
-	visitor += *v + around;
+		typename Container::iterator nxt = i; nxt++; // forward_iterator
+		if ( nxt == container.end() )
+		    visitor += *v;
+		else
+		    visitor += *v + around;
 
-    delete v;
+		delete v;
 	    }
 	} catch( SemanticError &e ) {
@@ -147,16 +131,8 @@
 	}
     }
-    if( !errors.isEmpty() ) {
+    if ( !errors.isEmpty() ) {
 	throw errors;
     }
 }
 
-
-#endif /* #ifndef VISITOR_H */
-
-
-/*
-    Local Variables:
-    mode: c++
-    End:
-*/
+#endif // VISITOR_H
