Changeset 0dd3a2f

translator/SymTab/AddVisit.h

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: AddVisit.h,v 1.2 2005/08/29 20:14:17 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// AddVisit.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 16:14:32 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 16:16:38 2015
+// Update Count     : 3
+//
 namespace SymTab {
+        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 );
+        template< typename Visitor >
+        inline void addVisitStatementList( std::list< Statement* > &statements, Visitor &visitor ) {
+                for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
+                        addDecls( visitor.get_declsToAdd(), statements, i );
+                        (*i)->accept( visitor );
+                } // for
+                addDecls( visitor.get_declsToAdd(), statements, statements.end() );
+        }
+template< typename Visitor >
+inline void
+addVisitStatementList( std::list< Statement* > &statements, Visitor &visitor )
+{
+  for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) {
+    addDecls( visitor.get_declsToAdd(), statements, i );
+    (*i)->accept( visitor );
+  }
+  addDecls( visitor.get_declsToAdd(), statements, statements.end() );
+}
+template< typename Visitor >
+inline void
+addVisitStatement( Statement *stmt, Visitor &visitor )
+{
+  maybeAccept( stmt, visitor );
+        template< typename Visitor >
+        inline void addVisitStatement( Statement *stmt, Visitor &visitor ) {
+                maybeAccept( stmt, visitor );
 ///   if ( ! declsToAdd.empty() ) {
 ///     CompoundStmt *compound = new CompoundStmt( noLabels );
 …
 ///     addDecls( declsToAdd, compound->get_kids(), compound->get_kids().end() );
 ///   }
+}
+        }
+template< typename Visitor >
+inline void
+addVisit(CompoundStmt *compoundStmt, Visitor &visitor)
+{
+  addVisitStatementList( compoundStmt->get_kids(), visitor );
+}
+        template< typename Visitor >
+        inline void addVisit(CompoundStmt *compoundStmt, Visitor &visitor) {
+                addVisitStatementList( compoundStmt->get_kids(), visitor );
+        }
+template< typename Visitor >
+inline void
+addVisit(IfStmt *ifStmt, Visitor &visitor)
+{
+  addVisitStatement( ifStmt->get_thenPart(), visitor );
+  addVisitStatement( ifStmt->get_elsePart(), visitor );
+  maybeAccept( ifStmt->get_condition(), visitor );
+}
+        template< typename Visitor >
+        inline void addVisit(IfStmt *ifStmt, Visitor &visitor) {
+                addVisitStatement( ifStmt->get_thenPart(), visitor );
+                addVisitStatement( ifStmt->get_elsePart(), visitor );
+                maybeAccept( ifStmt->get_condition(), visitor );
+        }
+template< typename Visitor >
+inline void
+addVisit(WhileStmt *whileStmt, Visitor &visitor)
+{
+  addVisitStatement( whileStmt->get_body(), visitor );
+  maybeAccept( whileStmt->get_condition(), visitor );
+}
+        template< typename Visitor >
+        inline void addVisit(WhileStmt *whileStmt, Visitor &visitor) {
+                addVisitStatement( whileStmt->get_body(), visitor );
+                maybeAccept( whileStmt->get_condition(), visitor );
+        }
+template< typename Visitor >
+inline void
+addVisit(ForStmt *forStmt, Visitor &visitor)
+{
+  addVisitStatement( forStmt->get_body(), visitor );
+  maybeAccept( forStmt->get_initialization(), visitor );
+  maybeAccept( forStmt->get_condition(), visitor );
+  maybeAccept( forStmt->get_increment(), visitor );
+}
+        template< typename Visitor >
+        inline void addVisit(ForStmt *forStmt, Visitor &visitor) {
+                addVisitStatement( forStmt->get_body(), visitor );
+                maybeAccept( forStmt->get_initialization(), visitor );
+                maybeAccept( forStmt->get_condition(), visitor );
+                maybeAccept( forStmt->get_increment(), visitor );
+        }
+template< typename Visitor >
+inline void
+addVisit(SwitchStmt *switchStmt, Visitor &visitor)
+{
+  addVisitStatementList( switchStmt->get_branches(), visitor );
+  maybeAccept( switchStmt->get_condition(), visitor );
+}
+        template< typename Visitor >
+        inline void addVisit(SwitchStmt *switchStmt, Visitor &visitor) {
+                addVisitStatementList( switchStmt->get_branches(), visitor );
+                maybeAccept( switchStmt->get_condition(), visitor );
+        }
+template< typename Visitor >
+inline void
+addVisit(ChooseStmt *switchStmt, Visitor &visitor)
+{
+  addVisitStatementList( switchStmt->get_branches(), visitor );
+  maybeAccept( switchStmt->get_condition(), visitor );
+}
+        template< typename Visitor >
+        inline void addVisit(ChooseStmt *switchStmt, Visitor &visitor) {
+                addVisitStatementList( switchStmt->get_branches(), visitor );
+                maybeAccept( switchStmt->get_condition(), visitor );
+        }
+template< typename Visitor >
+inline void
+addVisit(CaseStmt *caseStmt, Visitor &visitor)
+{
+  addVisitStatementList( caseStmt->get_statements(), visitor );
+  maybeAccept( caseStmt->get_condition(), visitor );
+}
+        template< typename Visitor >
+        inline void addVisit(CaseStmt *caseStmt, Visitor &visitor) {
+                addVisitStatementList( caseStmt->get_statements(), visitor );
+                maybeAccept( caseStmt->get_condition(), visitor );
+        }
+template< typename Visitor >
+inline void
+addVisit(CatchStmt *cathStmt, Visitor &visitor)
+{
+  addVisitStatement( cathStmt->get_body(), visitor );
+  maybeAccept( cathStmt->get_decl(), visitor );
+}
+        template< typename Visitor >
+        inline void addVisit(CatchStmt *cathStmt, Visitor &visitor) {
+                addVisitStatement( cathStmt->get_body(), visitor );
+                maybeAccept( cathStmt->get_decl(), visitor );
+        }
+} // namespace SymTab
+} // namespace SymTab
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/AggregateTable.h

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: AggregateTable.h,v 1.4 2005/08/29 20:14:17 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// AggregateTable.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 16:17:26 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 16:19:29 2015
+// Update Count     : 4
+//
 #ifndef SYMTAB_AGGREGATETABLE_H
 #define SYMTAB_AGGREGATETABLE_H
+#ifndef AGGREGATETABLE_H
+#define AGGREGATETABLE_H
 #include <map>
 …
 namespace SymTab {
+        template< class AggregateDeclClass >
+        class AggregateTableConflictFunction : public std::binary_function< AggregateDeclClass *, AggregateDeclClass *, AggregateDeclClass *> {
+          public:
+                AggregateDeclClass *operator()( AggregateDeclClass *existing, AggregateDeclClass *added ) {
+                        if ( existing->get_members().empty() ) {
+                                return added;
+                        } else if ( ! added->get_members().empty() ) {
+                                throw SemanticError( "redeclaration of ", added );
+                        } // if
+                        return existing;
+                }
+        };
+template< class AggregateDeclClass >
+class AggregateTableConflictFunction : public std::binary_function< AggregateDeclClass*, AggregateDeclClass*, AggregateDeclClass* >
+{
+public:
+  AggregateDeclClass *operator()( AggregateDeclClass *existing, AggregateDeclClass *added )
+  {
+    if ( existing->get_members().empty() ) {
+      return added;
+    } else if ( ! added->get_members().empty() ) {
+      throw SemanticError( "redeclaration of ", added );
+    }
+    return existing;
+  }
+};
+typedef StackTable< StructDecl, AggregateTableConflictFunction< StructDecl > > StructTable;
+typedef StackTable< EnumDecl, AggregateTableConflictFunction< EnumDecl > > EnumTable;
+typedef StackTable< UnionDecl, AggregateTableConflictFunction< UnionDecl > > UnionTable;
+typedef StackTable< ContextDecl, AggregateTableConflictFunction< ContextDecl > > ContextTable;
+        typedef StackTable< StructDecl, AggregateTableConflictFunction< StructDecl > > StructTable;
+        typedef StackTable< EnumDecl, AggregateTableConflictFunction< EnumDecl > > EnumTable;
+        typedef StackTable< UnionDecl, AggregateTableConflictFunction< UnionDecl > > UnionTable;
+        typedef StackTable< ContextDecl, AggregateTableConflictFunction< ContextDecl > > ContextTable;
 } // namespace SymTab
+#endif /* #ifndef SYMTAB_AGGREGATETABLE_H */
+#endif // AGGREGATETABLE_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/FixFunction.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// FixFunction.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 16:19:49 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 16:22:54 2015
+// Update Count     : 2
+//
 #include "FixFunction.h"
 #include "SynTree/Declaration.h"
 …
 namespace SymTab {
+        FixFunction::FixFunction() : isVoid( false ) {
+        }
+FixFunction::FixFunction()
+  : isVoid( false )
+{
+}
+        DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
+                ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
+                delete functionDecl;
+                return pointer;
+        }
+DeclarationWithType*
+FixFunction::mutate(FunctionDecl *functionDecl)
+{
+  ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClass(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type()->clone() ), 0 );
+  delete functionDecl;
+  return pointer;
+}
+        Type * FixFunction::mutate(VoidType *voidType) {
+                isVoid = true;
+                return voidType;
+        }
+Type*
+FixFunction::mutate(VoidType *voidType)
+{
+  isVoid = true;
+  return voidType;
+}
+        Type * FixFunction::mutate(BasicType *basicType) {
+                return basicType;
+        }
+Type*
+FixFunction::mutate(BasicType *basicType)
+{
+  return basicType;
+}
+        Type * FixFunction::mutate(PointerType *pointerType) {
+                return pointerType;
+        }
+Type*
+FixFunction::mutate(PointerType *pointerType)
+{
   return pointerType;
+}
+        Type * FixFunction::mutate(ArrayType *arrayType) {
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), maybeClone( arrayType->get_base()->clone() ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() );
+                delete arrayType;
+                return pointerType;
+        }
+Type*
+FixFunction::mutate(ArrayType *arrayType)
+{
+  PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), maybeClone( arrayType->get_base()->clone() ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() );
+  delete arrayType;
+  return pointerType;
+}
+        Type * FixFunction::mutate(StructInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+Type*
+FixFunction::mutate(StructInstType *aggregateUseType)
+{
+  return aggregateUseType;
+}
+        Type * FixFunction::mutate(UnionInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+Type*
+FixFunction::mutate(UnionInstType *aggregateUseType)
+{
+  return aggregateUseType;
+}
+        Type * FixFunction::mutate(EnumInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+Type*
+FixFunction::mutate(EnumInstType *aggregateUseType)
+{
+  return aggregateUseType;
+}
+        Type * FixFunction::mutate(ContextInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+Type*
+FixFunction::mutate(ContextInstType *aggregateUseType)
+{
+  return aggregateUseType;
+}
+        Type * FixFunction::mutate(TypeInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+Type*
+FixFunction::mutate(TypeInstType *aggregateUseType)
+{
+  return aggregateUseType;
+}
+        Type * FixFunction::mutate(TupleType *tupleType) {
+                return tupleType;
+        }
+} // namespace SymTab
+Type*
+FixFunction::mutate(TupleType *tupleType)
+{
+  return tupleType;
+}
+} // namespace SymTab
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/FixFunction.h

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: FixFunction.h,v 1.3 2005/08/29 20:14:17 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// FixFunction.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 17:02:08 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 17:03:43 2015
+// Update Count     : 2
+//
 #ifndef SYMTAB_FIXFUNCTION_H
 #define SYMTAB_FIXFUNCTION_H
+#ifndef FIXFUNCTION_H
+#define FIXFUNCTION_H
 #include "SynTree/Mutator.h"
 namespace SymTab {
+        class FixFunction : public Mutator {
+                typedef Mutator Parent;
+          public:
+                FixFunction();
+class FixFunction : public Mutator
+{
+  typedef Mutator Parent;
+                bool get_isVoid() const { return isVoid; }
+                void set_isVoid( bool newValue ) { isVoid = newValue; }
+          private:
+                virtual DeclarationWithType* mutate(FunctionDecl *functionDecl);
+public:
+  FixFunction();
+  bool get_isVoid() const { return isVoid; }
+  void set_isVoid( bool newValue ) { isVoid = newValue; }
+private:
+  virtual DeclarationWithType* mutate(FunctionDecl *functionDecl);
+  virtual Type* mutate(VoidType *voidType);
+  virtual Type* mutate(BasicType *basicType);
+  virtual Type* mutate(PointerType *pointerType);
+  virtual Type* mutate(ArrayType *arrayType);
+  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(VoidType *voidType);
+                virtual Type* mutate(BasicType *basicType);
+                virtual Type* mutate(PointerType *pointerType);
+                virtual Type* mutate(ArrayType *arrayType);
+                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);
+  bool isVoid;
+};
+                bool isVoid;
+        };
 } // namespace SymTab
+#endif /* #ifndef SYMTAB_FIXFUNCTION_H */
+#endif // FIXFUNCTION_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/IdTable.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: IdTable.cc,v 1.6 2005/08/29 20:14:17 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// IdTable.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 17:04:02 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 17:07:43 2015
+// Update Count     : 3
+//
 #include <cassert>
 …
 namespace SymTab {
+        IdTable::IdTable() : scopeLevel( 0 ) {
+        }
+IdTable::IdTable()
+  : scopeLevel( 0 )
+{
+}
+        void IdTable::enterScope() {
+                scopeLevel++;
+        }
+void
+IdTable::enterScope()
+{
+  scopeLevel++;
+}
+        void IdTable::leaveScope() {
+                for ( OuterTableType::iterator outer = table.begin(); outer != table.end(); ++outer ) {
+                        for ( InnerTableType::iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
+                                std::stack< DeclEntry >& entry = inner->second;
+                                if ( ! entry.empty() && entry.top().second == scopeLevel ) {
+                                        entry.pop();
+                                } // if
+                        } // for
+                } // for
+void
+IdTable::leaveScope()
+{
+  for ( OuterTableType::iterator outer = table.begin(); outer != table.end(); ++outer ) {
+    for ( InnerTableType::iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
+      std::stack< DeclEntry >& entry = inner->second;
+      if ( ! entry.empty() && entry.top().second == scopeLevel ) {
+        entry.pop();
+      }
+    }
+  }
+  scopeLevel--;
+  assert( scopeLevel >= 0 );
+}
+                scopeLevel--;
+                assert( scopeLevel >= 0 );
+        }
+void
+IdTable::addDecl( DeclarationWithType *decl )
+{
+  const string &name = decl->get_name();
+  string manglename;
+  if ( decl->get_linkage() == LinkageSpec::C ) {
+    manglename = name;
+  } else {
+    manglename = Mangler::mangle( decl );
+  }
+  InnerTableType &declTable = table[ name ];
+  InnerTableType::iterator it = declTable.find( manglename );
+  if ( it == declTable.end() ) {
+    declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
+  } else {
+    std::stack< DeclEntry >& entry = it->second;
+    if ( ! entry.empty() && entry.top().second == scopeLevel ) {
+      if ( decl->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( decl->get_type(), entry.top().first->get_type(), Indexer() ) ) {
+        FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( decl );
+        FunctionDecl *old = dynamic_cast< FunctionDecl* >( entry.top().first );
+        if ( newentry && old && newentry->get_statements() && old->get_statements() ) {
+          throw SemanticError( "duplicate function definition for ", decl );
+        } else {
+          ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( decl );
+          ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( entry.top().first );
+          if ( newobj && oldobj && newobj->get_init() && oldobj->get_init() ) {
+            throw SemanticError( "duplicate definition for ", decl );
+          }
+        }
+      } else {
+        throw SemanticError( "duplicate definition for ", decl );
+      }
+    } else {
+      declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
+    }
+  }
+  // ensure the set of routines with C linkage cannot be overloaded
+  for ( InnerTableType::iterator i = declTable.begin(); i != declTable.end(); ++i ) {
+    if ( ! i->second.empty() && i->second.top().first->get_linkage() == LinkageSpec::C && declTable.size() > 1 ) {
+        InnerTableType::iterator j = i;
+        for ( j++; j != declTable.end(); ++j ) {
+          if ( ! j->second.empty() && j->second.top().first->get_linkage() == LinkageSpec::C ) {
+            throw SemanticError( "invalid overload of C function " );
+          }
+        void IdTable::addDecl( DeclarationWithType *decl ) {
+                const string &name = decl->get_name();
+                string manglename;
+                if ( decl->get_linkage() == LinkageSpec::C ) {
+                        manglename = name;
+                } else {
+                        manglename = Mangler::mangle( decl );
+                } // if
+                InnerTableType &declTable = table[ name ];
+                InnerTableType::iterator it = declTable.find( manglename );
+                if ( it == declTable.end() ) {
+                        declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
+                } else {
+                        std::stack< DeclEntry >& entry = it->second;
+                        if ( ! entry.empty() && entry.top().second == scopeLevel ) {
+                                if ( decl->get_linkage() != LinkageSpec::C || ResolvExpr::typesCompatible( decl->get_type(), entry.top().first->get_type(), Indexer() ) ) {
+                                        FunctionDecl *newentry = dynamic_cast< FunctionDecl* >( decl );
+                                        FunctionDecl *old = dynamic_cast< FunctionDecl* >( entry.top().first );
+                                        if ( newentry && old && newentry->get_statements() && old->get_statements() ) {
+                                                throw SemanticError( "duplicate function definition for ", decl );
+                                        } else {
+                                                ObjectDecl *newobj = dynamic_cast< ObjectDecl* >( decl );
+                                                ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( entry.top().first );
+                                                if ( newobj && oldobj && newobj->get_init() && oldobj->get_init() ) {
+                                                        throw SemanticError( "duplicate definition for ", decl );
+                                                } // if
+                                        } // if
+                                } else {
+                                        throw SemanticError( "duplicate definition for ", decl );
+                                } // if
+                        } else {
+                                declTable[ manglename ].push( DeclEntry( decl, scopeLevel ) );
+                        } // if
+                } // if
+                // ensure the set of routines with C linkage cannot be overloaded
+                for ( InnerTableType::iterator i = declTable.begin(); i != declTable.end(); ++i ) {
+                        if ( ! i->second.empty() && i->second.top().first->get_linkage() == LinkageSpec::C && declTable.size() > 1 ) {
+                                InnerTableType::iterator j = i;
+                                for ( j++; j != declTable.end(); ++j ) {
+                                        if ( ! j->second.empty() && j->second.top().first->get_linkage() == LinkageSpec::C ) {
+                                                throw SemanticError( "invalid overload of C function " );
+                                        } // if
+                                } // for
+                        } // if
+                } // for
+        }
+    }
+  }
+}
+void
+IdTable::lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const
+{
+  OuterTableType::const_iterator outer = table.find( id );
+  if ( outer == table.end() ) return;
+  const InnerTableType &declTable = outer->second;
+  for ( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) {
+    const std::stack< DeclEntry >& entry = it->second;
+    if ( ! entry.empty() ) {
+      decls.push_back( entry.top().first );
+    }
+  }
+}
+        void IdTable::lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const {
+                OuterTableType::const_iterator outer = table.find( id );
+                if ( outer == table.end() ) return;
+                const InnerTableType &declTable = outer->second;
+                for ( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) {
+                        const std::stack< DeclEntry >& entry = it->second;
+                        if ( ! entry.empty() ) {
+                                decls.push_back( entry.top().first );
+                        } // if
+                } // for
+        }
 DeclarationWithType* IdTable::lookupId( const std::string &id) const {
    DeclarationWithType* result = 0;
    int depth = -1;
+        DeclarationWithType * IdTable::lookupId( const std::string &id) const {
+                DeclarationWithType* result = 0;
+                int depth = -1;
    OuterTableType::const_iterator outer = table.find( id );
    if ( outer == table.end() ) return 0;
    const InnerTableType &declTable = outer->second;
    for ( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) {
      const std::stack< DeclEntry >& entry = it->second;
      if ( ! entry.empty() && entry.top().second > depth ) {
        result = entry.top().first;
        depth = entry.top().second;
+     }
+   }
    return result;
+}
+                OuterTableType::const_iterator outer = table.find( id );
+                if ( outer == table.end() ) return 0;
+                const InnerTableType &declTable = outer->second;
+                for ( InnerTableType::const_iterator it = declTable.begin(); it != declTable.end(); ++it ) {
+                        const std::stack< DeclEntry >& entry = it->second;
+                        if ( ! entry.empty() && entry.top().second > depth ) {
+                                result = entry.top().first;
+                                depth = entry.top().second;
+                        } // if
+                } // for
+                return result;
+        }
+void
+IdTable::dump( std::ostream &os ) const
+{
+  for ( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) {
+    for ( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
+        void IdTable::dump( std::ostream &os ) const {
+                for ( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) {
+                        for ( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
 #if 0
       const std::stack< DeclEntry >& entry = inner->second;
       if ( ! entry.empty() ) { // && entry.top().second == scopeLevel ) {
         os << outer->first << " (" << inner->first << ") (" << entry.top().second << ")" << std::endl;
       } else {
         os << outer->first << " (" << inner->first << ") ( entry-empty)" << std::endl;
+      }
+                                const std::stack< DeclEntry >& entry = inner->second;
+                                if ( ! entry.empty() ) { // && entry.top().second == scopeLevel ) {
+                                        os << outer->first << " (" << inner->first << ") (" << entry.top().second << ")" << std::endl;
+                                } else {
+                                        os << outer->first << " (" << inner->first << ") ( entry-empty)" << std::endl;
+                                } // if
 #endif
 #if 0
       std::stack<DeclEntry> stack = inner->second;
       os << "dumping a stack" << std::endl;
       while (! stack.empty()) {
         DeclEntry d = stack.top();
         os << outer->first << " (" << inner->first << ") (" << d.second << ") " << std::endl;
         stack.pop();
+      }
+                                std::stack<DeclEntry> stack = inner->second;
+                                os << "dumping a stack" << std::endl;
+                                while (! stack.empty()) {
+                                        DeclEntry d = stack.top();
+                                        os << outer->first << " (" << inner->first << ") (" << d.second << ") " << std::endl;
+                                        stack.pop();
+                                } // while
 #endif
+    }
+  }
+                        } // for
+                } // for
 #if 0
   for ( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) {
     for ( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
       const std::stack< DeclEntry >& entry = inner->second;
       if ( ! entry.empty() && entry.top().second == scopeLevel ) {
         os << outer->first << " (" << inner->first << ") (" << scopeLevel << ")" << std::endl;
+      }
+    }
+  }
+                for ( OuterTableType::const_iterator outer = table.begin(); outer != table.end(); ++outer ) {
+                        for ( InnerTableType::const_iterator inner = outer->second.begin(); inner != outer->second.end(); ++inner ) {
+                                const std::stack< DeclEntry >& entry = inner->second;
+                                if ( ! entry.empty() && entry.top().second == scopeLevel ) {
+                                        os << outer->first << " (" << inner->first << ") (" << scopeLevel << ")" << std::endl;
+                                } // if
+                        } // for
+                } // for
 #endif
+}
+        }
+} // namespace SymTab
+} // namespace SymTab
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/IdTable.h

-              ra32b204
+              r0dd3a2f
+#ifndef SYMTAB_IDTABLE_H
+#define SYMTAB_IDTABLE_H
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// IdTable.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:30:02 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:31:45 2015
+// Update Count     : 3
+//
+#ifndef IDTABLE_H
+#define IDTABLE_H
 #include <iostream>
 …
     class IdTable {
       public:
         IdTable();
+                IdTable();
         void enterScope();
         void leaveScope();
         void addDecl( DeclarationWithType *decl );
         void lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const;
         DeclarationWithType* lookupId( const std::string &id) const;
+                void enterScope();
+                void leaveScope();
+                void addDecl( DeclarationWithType *decl );
+                void lookupId( const std::string &id, std::list< DeclarationWithType* >& decls ) const;
+                DeclarationWithType* lookupId( const std::string &id) const;
+        void dump( std::ostream &os ) const; // debugging
+                void dump( std::ostream &os ) const;                    // debugging
+      private:
+                typedef std::pair< DeclarationWithType*, int > DeclEntry;
+                typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType;
+                typedef std::map< std::string, InnerTableType > OuterTableType;
+      private:
+        typedef std::pair< DeclarationWithType*, int > DeclEntry;
+        typedef std::map< std::string, std::stack< DeclEntry > > InnerTableType;
+        typedef std::map< std::string, InnerTableType > OuterTableType;
+        OuterTableType table;
+        int scopeLevel;
+                OuterTableType table;
+                int scopeLevel;
     };
 } // namespace SymTab
+#endif // SYMTAB_IDTABLE_H
+#endif // IDTABLE_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/ImplementationType.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: ImplementationType.cc,v 1.4 2005/08/29 20:14:17 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// ImplementationType.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:32:01 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:34:40 2015
+// Update Count     : 2
+//
 #include "ImplementationType.h"
 …
 namespace SymTab {
+        class ImplementationType : public Visitor {
+          public:
+                ImplementationType( const SymTab::Indexer &indexer );
+class ImplementationType : public Visitor
+{
+public:
+  ImplementationType( const SymTab::Indexer &indexer );
+  Type *get_result() { return result; }
+                Type *get_result() { return result; }
+          private:
+                virtual void visit(VoidType *voidType);
+                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);
+private:
+  virtual void visit(VoidType *voidType);
+  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);
+                Type *result;                   // synthesized
+                const SymTab::Indexer &indexer;
+        };
+  Type *result;                 // synthesized
+  const SymTab::Indexer &indexer;
+};
+        Type * implementationType( Type *type, const SymTab::Indexer& indexer ) {
+                ImplementationType implementor( indexer );
+                type->accept( implementor );
+                if ( implementor.get_result() == 0 ) {
+                        return type->clone();
+                } else {
+                        return implementor.get_result();
+                } // if
+        }
+Type*
+implementationType( Type *type, const SymTab::Indexer& indexer )
+{
+  ImplementationType implementor( indexer );
+  type->accept( implementor );
+  if ( implementor.get_result() == 0 ) {
+    return type->clone();
+  } else {
+    return implementor.get_result();
+  }
+}
+        ImplementationType::ImplementationType( const SymTab::Indexer &indexer ) : result( 0 ), indexer( indexer ) {
+        }
+ImplementationType::ImplementationType( const SymTab::Indexer &indexer )
+  : result( 0 ), indexer( indexer )
+{
+}
+        void ImplementationType::visit(VoidType *voidType) {
+        }
+void
+ImplementationType::visit(VoidType *voidType)
+{
+}
+        void ImplementationType::visit(BasicType *basicType) {
+        }
+void
+ImplementationType::visit(BasicType *basicType)
+{
+}
+        void ImplementationType::visit(PointerType *pointerType) {
+                PointerType *newType = pointerType->clone();
+                newType->set_base( implementationType( pointerType->get_base(), indexer ) );
+                result = newType;
+        }
+void
+ImplementationType::visit(PointerType *pointerType)
+{
+  PointerType *newType = pointerType->clone();
+  newType->set_base( implementationType( pointerType->get_base(), indexer ) );
+  result = newType;
+}
+        void ImplementationType::visit(ArrayType *arrayType) {
+                ArrayType *newType = arrayType->clone();
+                newType->set_base( implementationType( arrayType->get_base(), indexer ) );
+                result = newType;
+        }
+void
+ImplementationType::visit(ArrayType *arrayType)
+{
+  ArrayType *newType = arrayType->clone();
+  newType->set_base( implementationType( arrayType->get_base(), indexer ) );
+  result = newType;
+}
+void
+ImplementationType::visit(FunctionType *functionType)
+{
+        void ImplementationType::visit(FunctionType *functionType) {
 ///   FunctionType *newType = functionType->clone();
 ///   for ( std::list< DeclarationWithType* >::iterator i = newType->get_parameters().begin(); i != newType->get_parameters().end(); ++i ) {
 …
 ///     i->set_type( implementationType( i->get_type(), indexer ) );
 ///   }
+}
+        }
+void
+ImplementationType::visit(StructInstType *aggregateUseType)
+{
+}
+        void ImplementationType::visit(StructInstType *aggregateUseType) {
+        }
+void
+ImplementationType::visit(UnionInstType *aggregateUseType)
+{
+}
+        void ImplementationType::visit(UnionInstType *aggregateUseType) {
+        }
+void
+ImplementationType::visit(EnumInstType *aggregateUseType)
+{
+}
+        void ImplementationType::visit(EnumInstType *aggregateUseType) {
+        }
+void
+ImplementationType::visit(ContextInstType *aggregateUseType)
+{
+}
+        void ImplementationType::visit(ContextInstType *aggregateUseType) {
+        }
+void
+ImplementationType::visit(TypeInstType *inst)
+{
+  NamedTypeDecl *typeDecl = indexer.lookupType( inst->get_name() );
+  if ( typeDecl && typeDecl->get_base() ) {
+    Type *base = implementationType( typeDecl->get_base(), indexer );
+    base->get_qualifiers() += inst->get_qualifiers();
+    result = base;
+  }
+}
+        void ImplementationType::visit(TypeInstType *inst) {
+                NamedTypeDecl *typeDecl = indexer.lookupType( inst->get_name() );
+                if ( typeDecl && typeDecl->get_base() ) {
+                        Type *base = implementationType( typeDecl->get_base(), indexer );
+                        base->get_qualifiers() += inst->get_qualifiers();
+                        result = base;
+                } // if
+        }
+void
+ImplementationType::visit(TupleType *tupleType)
+{
+  TupleType *newType = new TupleType( Type::Qualifiers() );
+  for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
+    Type *implType = implementationType( *i, indexer );
+    implType->get_qualifiers() += tupleType->get_qualifiers();
+    newType->get_types().push_back( implType );
+  }
+  result = newType;
+}
+        void ImplementationType::visit(TupleType *tupleType) {
+                TupleType *newType = new TupleType( Type::Qualifiers() );
+                for ( std::list< Type* >::iterator i = tupleType->get_types().begin(); i != tupleType->get_types().end(); ++i ) {
+                        Type *implType = implementationType( *i, indexer );
+                        implType->get_qualifiers() += tupleType->get_qualifiers();
+                        newType->get_types().push_back( implType );
+                } // for
+                result = newType;
+        }
+} // namespace SymTab
+} // namespace SymTab
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/ImplementationType.h

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: ImplementationType.h,v 1.3 2005/08/29 20:14:17 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// ImplementationType.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:35:41 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:37:15 2015
+// Update Count     : 2
+//
 #ifndef SYMTAB_IMPLEMENTATIONTYPE_H
 #define SYMTAB_IMPLEMENTATIONTYPE_H
+#ifndef IMPLEMENTATIONTYPE_H
+#define IMPLEMENTATIONTYPE_H
 #include "SynTree/SynTree.h"
 …
 namespace SymTab {
+        Type *implementationType( Type *, const SymTab::Indexer &indexer );
+Type *implementationType( Type *, const SymTab::Indexer &indexer );
+template< typename InputIterator, typename OutputIterator >
+void
+implementationTypeList( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer )
+{
+  while ( begin != end ) {
+    *out++ = implementationType( *begin++, indexer );
+  }
+}
+        template< typename InputIterator, typename OutputIterator >
+        void implementationTypeList( InputIterator begin, InputIterator end, OutputIterator out, const SymTab::Indexer &indexer ) {
+                while ( begin != end ) {
+                        *out++ = implementationType( *begin++, indexer );
+                } // while
+        }
 } // namespace SymTab
+#endif /* #ifndef SYMTAB_IMPLEMENTATIONTYPE_H */
+#endif // IMPLEMENTATIONTYPE_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/Indexer.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Indexer.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:37:33 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:38:44 2015
+// Update Count     : 2
+//
 #include "SynTree/Declaration.h"
 #include "SynTree/Type.h"
 …
     void Indexer::visit( ObjectDecl *objectDecl ) {
         maybeAccept( objectDecl->get_type(), *this );
         maybeAccept( objectDecl->get_init(), *this );
         maybeAccept( objectDecl->get_bitfieldWidth(), *this );
         if ( objectDecl->get_name() != "" ) {
             debugPrint( "Adding object " << objectDecl->get_name() << std::endl );
             idTable.addDecl( objectDecl );
+        }
+                maybeAccept( objectDecl->get_type(), *this );
+                maybeAccept( objectDecl->get_init(), *this );
+                maybeAccept( objectDecl->get_bitfieldWidth(), *this );
+                if ( objectDecl->get_name() != "" ) {
+                        debugPrint( "Adding object " << objectDecl->get_name() << std::endl );
+                        idTable.addDecl( objectDecl );
+                } // if
+    }
     void Indexer::visit( FunctionDecl *functionDecl ) {
         if ( functionDecl->get_name() == "" ) return;
         debugPrint( "Adding function " << functionDecl->get_name() << std::endl );
         idTable.addDecl( functionDecl );
         enterScope();
         maybeAccept( functionDecl->get_functionType(), *this );
         acceptAll( functionDecl->get_oldDecls(), *this );
         maybeAccept( functionDecl->get_statements(), *this );
         leaveScope();
+                if ( functionDecl->get_name() == "" ) return;
+                debugPrint( "Adding function " << functionDecl->get_name() << std::endl );
+                idTable.addDecl( functionDecl );
+                enterScope();
+                maybeAccept( functionDecl->get_functionType(), *this );
+                acceptAll( functionDecl->get_oldDecls(), *this );
+                maybeAccept( functionDecl->get_statements(), *this );
+                leaveScope();
+    }
 …
     void Indexer::visit( TypeDecl *typeDecl ) {
         // see A NOTE ON THE ORDER OF TRAVERSAL, above
         // note that assertions come after the type is added to the symtab, since they aren't part
         // of the type proper and may depend on the type itself
         enterScope();
         acceptAll( typeDecl->get_parameters(), *this );
         maybeAccept( typeDecl->get_base(), *this );
         leaveScope();
         debugPrint( "Adding type " << typeDecl->get_name() << std::endl );
         typeTable.add( typeDecl );
         acceptAll( typeDecl->get_assertions(), *this );
+                // see A NOTE ON THE ORDER OF TRAVERSAL, above
+                // note that assertions come after the type is added to the symtab, since they aren't part
+                // of the type proper and may depend on the type itself
+                enterScope();
+                acceptAll( typeDecl->get_parameters(), *this );
+                maybeAccept( typeDecl->get_base(), *this );
+                leaveScope();
+                debugPrint( "Adding type " << typeDecl->get_name() << std::endl );
+                typeTable.add( typeDecl );
+                acceptAll( typeDecl->get_assertions(), *this );
+    }
     void Indexer::visit( TypedefDecl *typeDecl ) {
         enterScope();
         acceptAll( typeDecl->get_parameters(), *this );
         maybeAccept( typeDecl->get_base(), *this );
         leaveScope();
         debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl );
         typeTable.add( typeDecl );
+                enterScope();
+                acceptAll( typeDecl->get_parameters(), *this );
+                maybeAccept( typeDecl->get_base(), *this );
+                leaveScope();
+                debugPrint( "Adding typedef " << typeDecl->get_name() << std::endl );
+                typeTable.add( typeDecl );
+    }
     void Indexer::visit( StructDecl *aggregateDecl ) {
         // make up a forward declaration and add it before processing the members
         StructDecl fwdDecl( aggregateDecl->get_name() );
         cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
         debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl );
         structTable.add( &fwdDecl );
         enterScope();
         acceptAll( aggregateDecl->get_parameters(), *this );
         acceptAll( aggregateDecl->get_members(), *this );
         leaveScope();
         debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl );
         // this addition replaces the forward declaration
         structTable.add( aggregateDecl );
+                // make up a forward declaration and add it before processing the members
+                StructDecl fwdDecl( aggregateDecl->get_name() );
+                cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
+                debugPrint( "Adding fwd decl for struct " << fwdDecl.get_name() << std::endl );
+                structTable.add( &fwdDecl );
+                enterScope();
+                acceptAll( aggregateDecl->get_parameters(), *this );
+                acceptAll( aggregateDecl->get_members(), *this );
+                leaveScope();
+                debugPrint( "Adding struct " << aggregateDecl->get_name() << std::endl );
+                // this addition replaces the forward declaration
+                structTable.add( aggregateDecl );
+    }
     void Indexer::visit( UnionDecl *aggregateDecl ) {
         // make up a forward declaration and add it before processing the members
         UnionDecl fwdDecl( aggregateDecl->get_name() );
         cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
         debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl );
         unionTable.add( &fwdDecl );
         enterScope();
         acceptAll( aggregateDecl->get_parameters(), *this );
         acceptAll( aggregateDecl->get_members(), *this );
         leaveScope();
         debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl );
         unionTable.add( aggregateDecl );
+                // make up a forward declaration and add it before processing the members
+                UnionDecl fwdDecl( aggregateDecl->get_name() );
+                cloneAll( aggregateDecl->get_parameters(), fwdDecl.get_parameters() );
+                debugPrint( "Adding fwd decl for union " << fwdDecl.get_name() << std::endl );
+                unionTable.add( &fwdDecl );
+                enterScope();
+                acceptAll( aggregateDecl->get_parameters(), *this );
+                acceptAll( aggregateDecl->get_members(), *this );
+                leaveScope();
+                debugPrint( "Adding union " << aggregateDecl->get_name() << std::endl );
+                unionTable.add( aggregateDecl );
+    }
     void Indexer::visit( EnumDecl *aggregateDecl ) {
         debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl );
         enumTable.add( aggregateDecl );
         // unlike structs, contexts, and unions, enums inject their members into the global scope
         acceptAll( aggregateDecl->get_members(), *this );
+                debugPrint( "Adding enum " << aggregateDecl->get_name() << std::endl );
+                enumTable.add( aggregateDecl );
+                // unlike structs, contexts, and unions, enums inject their members into the global scope
+                acceptAll( aggregateDecl->get_members(), *this );
+    }
     void Indexer::visit( ContextDecl *aggregateDecl ) {
         enterScope();
         acceptAll( aggregateDecl->get_parameters(), *this );
         acceptAll( aggregateDecl->get_members(), *this );
         leaveScope();
         debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl );
         contextTable.add( aggregateDecl );
+                enterScope();
+                acceptAll( aggregateDecl->get_parameters(), *this );
+                acceptAll( aggregateDecl->get_members(), *this );
+                leaveScope();
+                debugPrint( "Adding context " << aggregateDecl->get_name() << std::endl );
+                contextTable.add( aggregateDecl );
+    }
     void Indexer::visit( CompoundStmt *compoundStmt ) {
         enterScope();
         acceptAll( compoundStmt->get_kids(), *this );
         leaveScope();
+                enterScope();
+                acceptAll( compoundStmt->get_kids(), *this );
+                leaveScope();
+    }
     void Indexer::visit( ContextInstType *contextInst ) {
         acceptAll( contextInst->get_parameters(), *this );
         acceptAll( contextInst->get_members(), *this );
+                acceptAll( contextInst->get_parameters(), *this );
+                acceptAll( contextInst->get_members(), *this );
+    }
     void Indexer::visit( StructInstType *structInst ) {
         if ( ! structTable.lookup( structInst->get_name() ) ) {
             debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl );
             structTable.add( structInst->get_name() );
+        }
         enterScope();
         acceptAll( structInst->get_parameters(), *this );
         leaveScope();
+                if ( ! structTable.lookup( structInst->get_name() ) ) {
+                        debugPrint( "Adding struct " << structInst->get_name() << " from implicit forward declaration" << std::endl );
+                        structTable.add( structInst->get_name() );
+                }
+                enterScope();
+                acceptAll( structInst->get_parameters(), *this );
+                leaveScope();
+    }
     void Indexer::visit( UnionInstType *unionInst ) {
         if ( ! unionTable.lookup( unionInst->get_name() ) ) {
             debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl );
             unionTable.add( unionInst->get_name() );
+        }
         enterScope();
         acceptAll( unionInst->get_parameters(), *this );
         leaveScope();
+                if ( ! unionTable.lookup( unionInst->get_name() ) ) {
+                        debugPrint( "Adding union " << unionInst->get_name() << " from implicit forward declaration" << std::endl );
+                        unionTable.add( unionInst->get_name() );
+                }
+                enterScope();
+                acceptAll( unionInst->get_parameters(), *this );
+                leaveScope();
+    }
 …
     void Indexer::lookupId( const std::string &id, std::list< DeclarationWithType* > &list ) const {
         idTable.lookupId( id, list );
+                idTable.lookupId( id, list );
+    }
     DeclarationWithType* Indexer::lookupId( const std::string &id) const {
         return idTable.lookupId(id);
+                return idTable.lookupId(id);
+    }
     NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
         return typeTable.lookup( id );
+                return typeTable.lookup( id );
+    }
     StructDecl *Indexer::lookupStruct( const std::string &id ) const {
         return structTable.lookup( id );
+                return structTable.lookup( id );
+    }
     EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
         return enumTable.lookup( id );
+                return enumTable.lookup( id );
+    }
     UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
         return unionTable.lookup( id );
+                return unionTable.lookup( id );
+    }
     ContextDecl  * Indexer::lookupContext( const std::string &id ) const {
         return contextTable.lookup( id );
+                return contextTable.lookup( id );
+    }
     void Indexer::enterScope() {
         if ( doDebug ) {
             std::cout << "--- Entering scope" << std::endl;
+        }
         idTable.enterScope();
         typeTable.enterScope();
         structTable.enterScope();
         enumTable.enterScope();
         unionTable.enterScope();
         contextTable.enterScope();
+                if ( doDebug ) {
+                        std::cout << "--- Entering scope" << std::endl;
+                }
+                idTable.enterScope();
+                typeTable.enterScope();
+                structTable.enterScope();
+                enumTable.enterScope();
+                unionTable.enterScope();
+                contextTable.enterScope();
+    }
     void Indexer::leaveScope() {
         using std::cout;
         using std::endl;
         if ( doDebug ) {
             cout << "--- Leaving scope containing" << endl;
             idTable.dump( cout );
             typeTable.dump( cout );
             structTable.dump( cout );
             enumTable.dump( cout );
             unionTable.dump( cout );
             contextTable.dump( cout );
+        }
         idTable.leaveScope();
         typeTable.leaveScope();
         structTable.leaveScope();
         enumTable.leaveScope();
         unionTable.leaveScope();
         contextTable.leaveScope();
+                using std::cout;
+                using std::endl;
+                if ( doDebug ) {
+                        cout << "--- Leaving scope containing" << endl;
+                        idTable.dump( cout );
+                        typeTable.dump( cout );
+                        structTable.dump( cout );
+                        enumTable.dump( cout );
+                        unionTable.dump( cout );
+                        contextTable.dump( cout );
+                }
+                idTable.leaveScope();
+                typeTable.leaveScope();
+                structTable.leaveScope();
+                enumTable.leaveScope();
+                unionTable.leaveScope();
+                contextTable.leaveScope();
+    }
 …
         contextTable.dump( os );
 #if 0
         idTable.dump( os );
         typeTable.dump( os );
         structTable.dump( os );
         enumTable.dump( os );
         unionTable.dump( os );
         contextTable.dump( os );
+                idTable.dump( os );
+                typeTable.dump( os );
+                structTable.dump( os );
+                enumTable.dump( os );
+                unionTable.dump( os );
+                contextTable.dump( os );
 #endif
+    }
 } // namespace SymTab
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/Indexer.h

-              ra32b204
+              r0dd3a2f
+#ifndef SYMTAB_INDEXER_H
+#define SYMTAB_INDEXER_H
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Indexer.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:38:55 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:40:17 2015
+// Update Count     : 2
+//
+#ifndef INDEXER_H
+#define INDEXER_H
 #include <list>
 …
 } // namespace SymTab
+#endif // SYMTAB_INDEXER_H
+#endif // INDEXER_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/Mangler.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Mangler.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:40:29 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:43:49 2015
+// Update Count     : 2
+//
 #include <cassert>
 #include <string>
 …
 namespace SymTab {
     Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true )
     {}
+    Mangler::Mangler() : nextVarNum( 0 ), isTopLevel( true ) {
+        }
 //Mangler::Mangler( const Mangler & )
 …
 //}
     Mangler::Mangler( const Mangler &rhs ) : mangleName() {
         varNums = rhs.varNums;
         nextVarNum = rhs.nextVarNum;
         isTopLevel = rhs.isTopLevel;
+                varNums = rhs.varNums;
+                nextVarNum = rhs.nextVarNum;
+                isTopLevel = rhs.isTopLevel;
+    }
     void Mangler::mangleDecl( DeclarationWithType *declaration ) {
         bool wasTopLevel = isTopLevel;
         if ( isTopLevel ) {
             varNums.clear();
             nextVarNum = 0;
             isTopLevel = false;
+        }
         mangleName << "__";
         CodeGen::OperatorInfo opInfo;
         if ( operatorLookup( declaration->get_name(), opInfo ) ) {
             mangleName << opInfo.outputName;
         } else {
             mangleName << declaration->get_name();
+        }
         mangleName << "__";
         maybeAccept( declaration->get_type(), *this );
         isTopLevel = wasTopLevel;
+                bool wasTopLevel = isTopLevel;
+                if ( isTopLevel ) {
+                        varNums.clear();
+                        nextVarNum = 0;
+                        isTopLevel = false;
+                } // if
+                mangleName << "__";
+                CodeGen::OperatorInfo opInfo;
+                if ( operatorLookup( declaration->get_name(), opInfo ) ) {
+                        mangleName << opInfo.outputName;
+                } else {
+                        mangleName << declaration->get_name();
+                } // if
+                mangleName << "__";
+                maybeAccept( declaration->get_type(), *this );
+                isTopLevel = wasTopLevel;
+    }
     void Mangler::visit( ObjectDecl *declaration ) {
         mangleDecl( declaration );
+                mangleDecl( declaration );
+    }
     void Mangler::visit( FunctionDecl *declaration ) {
         mangleDecl( declaration );
+                mangleDecl( declaration );
+    }
     void Mangler::visit( VoidType *voidType ) {
         printQualifiers( voidType );
         mangleName << "v";
+                printQualifiers( voidType );
+                mangleName << "v";
+    }
     void Mangler::visit( BasicType *basicType ) {
         static const char *btLetter[] = {
             "b",        // Bool
             "c",        // Char
             "Sc",       // SignedChar
             "Uc",       // UnsignedChar
             "s",        // ShortSignedInt
             "Us",       // ShortUnsignedInt
             "i",        // SignedInt
             "Ui",       // UnsignedInt
             "l",        // LongSignedInt
             "Ul",       // LongUnsignedInt
             "q",        // LongLongSignedInt
             "Uq",       // LongLongUnsignedInt
             "f",        // Float
             "d",        // Double
             "r",        // LongDouble
             "Xf",       // FloatComplex
             "Xd",       // DoubleComplex
             "Xr",       // LongDoubleComplex
             "If",       // FloatImaginary
             "Id",       // DoubleImaginary
             "Ir",       // LongDoubleImaginary
         };
+                static const char *btLetter[] = {
+                        "b",    // Bool
+                        "c",    // Char
+                        "Sc",   // SignedChar
+                        "Uc",   // UnsignedChar
+                        "s",    // ShortSignedInt
+                        "Us",   // ShortUnsignedInt
+                        "i",    // SignedInt
+                        "Ui",   // UnsignedInt
+                        "l",    // LongSignedInt
+                        "Ul",   // LongUnsignedInt
+                        "q",    // LongLongSignedInt
+                        "Uq",   // LongLongUnsignedInt
+                        "f",    // Float
+                        "d",    // Double
+                        "r",    // LongDouble
+                        "Xf",   // FloatComplex
+                        "Xd",   // DoubleComplex
+                        "Xr",   // LongDoubleComplex
+                        "If",   // FloatImaginary
+                        "Id",   // DoubleImaginary
+                        "Ir",   // LongDoubleImaginary
+                };
         printQualifiers( basicType );
         mangleName << btLetter[ basicType->get_kind() ];
+                printQualifiers( basicType );
+                mangleName << btLetter[ basicType->get_kind() ];
+    }
     void Mangler::visit( PointerType *pointerType ) {
         printQualifiers( pointerType );
         mangleName << "P";
         maybeAccept( pointerType->get_base(), *this );
+                printQualifiers( pointerType );
+                mangleName << "P";
+                maybeAccept( pointerType->get_base(), *this );
+    }
     void Mangler::visit( ArrayType *arrayType ) {
         // TODO: encode dimension
         printQualifiers( arrayType );
         mangleName << "A0";
         maybeAccept( arrayType->get_base(), *this );
+                // TODO: encode dimension
+                printQualifiers( arrayType );
+                mangleName << "A0";
+                maybeAccept( arrayType->get_base(), *this );
+    }
     namespace {
+        inline std::list< Type* >
+        getTypes( const std::list< DeclarationWithType* > decls )
+        {
+            std::list< Type* > ret;
+            std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
+                            std::mem_fun( &DeclarationWithType::get_type ) );
+            return ret;
+        }
+                inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
+                        std::list< Type* > ret;
+                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
+                                                        std::mem_fun( &DeclarationWithType::get_type ) );
+                        return ret;
+                }
+    }
     void Mangler::visit( FunctionType *functionType ) {
         printQualifiers( functionType );
         mangleName << "F";
         std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
         acceptAll( returnTypes, *this );
         mangleName << "_";
         std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
         acceptAll( paramTypes, *this );
         mangleName << "_";
+                printQualifiers( functionType );
+                mangleName << "F";
+                std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
+                acceptAll( returnTypes, *this );
+                mangleName << "_";
+                std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
+                acceptAll( paramTypes, *this );
+                mangleName << "_";
+    }
     void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
         printQualifiers( refType );
         mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
+                printQualifiers( refType );
+                mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
+    }
     void Mangler::visit( StructInstType *aggregateUseType ) {
         mangleRef( aggregateUseType, "s" );
+                mangleRef( aggregateUseType, "s" );
+    }
     void Mangler::visit( UnionInstType *aggregateUseType ) {
         mangleRef( aggregateUseType, "u" );
+                mangleRef( aggregateUseType, "u" );
+    }
     void Mangler::visit( EnumInstType *aggregateUseType ) {
         mangleRef( aggregateUseType, "e" );
+                mangleRef( aggregateUseType, "e" );
+    }
     void Mangler::visit( TypeInstType *typeInst ) {
         VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
         if ( varNum == varNums.end() ) {
             mangleRef( typeInst, "t" );
         } else {
             printQualifiers( typeInst );
             std::ostrstream numStream;
             numStream << varNum->second.first;
             mangleName << (numStream.pcount() + 1);
             switch ( (TypeDecl::Kind )varNum->second.second ) {
               case TypeDecl::Any:
                 mangleName << "t";
                 break;
               case TypeDecl::Dtype:
                 mangleName << "d";
                 break;
               case TypeDecl::Ftype:
                 mangleName << "f";
                 break;
+            }
             mangleName << std::string( numStream.str(), numStream.pcount() );
+        }
+                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
+                if ( varNum == varNums.end() ) {
+                        mangleRef( typeInst, "t" );
+                } else {
+                        printQualifiers( typeInst );
+                        std::ostrstream numStream;
+                        numStream << varNum->second.first;
+                        mangleName << (numStream.pcount() + 1);
+                        switch ( (TypeDecl::Kind )varNum->second.second ) {
+                          case TypeDecl::Any:
+                                mangleName << "t";
+                                break;
+                          case TypeDecl::Dtype:
+                                mangleName << "d";
+                                break;
+                          case TypeDecl::Ftype:
+                                mangleName << "f";
+                                break;
+                        } // switch
+                        mangleName << std::string( numStream.str(), numStream.pcount() );
+                } // if
+    }
     void Mangler::visit( TupleType *tupleType ) {
         printQualifiers( tupleType );
         mangleName << "T";
         acceptAll( tupleType->get_types(), *this );
         mangleName << "_";
+                printQualifiers( tupleType );
+                mangleName << "T";
+                acceptAll( tupleType->get_types(), *this );
+                mangleName << "_";
+    }
     void Mangler::visit( TypeDecl *decl ) {
         static const char *typePrefix[] = { "BT", "BD", "BF" };
         mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
+                static const char *typePrefix[] = { "BT", "BD", "BF" };
+                mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
+    }
     void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
         for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
             os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
+        }
+                for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
+                        os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
+                } // for
+    }
     void Mangler::printQualifiers( Type *type ) {
+        if ( ! type->get_forall().empty() ) {
+            std::list< std::string > assertionNames;
+            int tcount = 0, dcount = 0, fcount = 0;
+            mangleName << "A";
+            for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                switch ( (*i)->get_kind() ) {
+                  case TypeDecl::Any:
+                    tcount++;
+                    break;
+                  case TypeDecl::Dtype:
+                    dcount++;
+                    break;
+                  case TypeDecl::Ftype:
+                    fcount++;
+                    break;
+                }
+                varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
+                for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
+                    Mangler sub_mangler;
+                    sub_mangler.nextVarNum = nextVarNum;
+                    sub_mangler.isTopLevel = false;
+                    sub_mangler.varNums = varNums;
+                    (*assert)->accept( sub_mangler );
+                    assertionNames.push_back( std::string( sub_mangler.mangleName.str(), sub_mangler.mangleName.pcount() ) );
+                }
+            }
+            mangleName << tcount << "_" << dcount << "_" << fcount << "_";
+            std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
+            mangleName << "_";
+        }
+        if ( type->get_isConst() ) {
+            mangleName << "C";
+        }
+        if ( type->get_isVolatile() ) {
+            mangleName << "V";
+        }
+        if ( type->get_isRestrict() ) {
+            mangleName << "R";
+        }
+        if ( type->get_isLvalue() ) {
+            mangleName << "L";
+        }
+        if ( type->get_isAtomic() ) {
+            mangleName << "A";
+        }
+    }
+} // SymTab
+                if ( ! type->get_forall().empty() ) {
+                        std::list< std::string > assertionNames;
+                        int tcount = 0, dcount = 0, fcount = 0;
+                        mangleName << "A";
+                        for ( std::list< TypeDecl* >::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                                switch ( (*i)->get_kind() ) {
+                                  case TypeDecl::Any:
+                                        tcount++;
+                                        break;
+                                  case TypeDecl::Dtype:
+                                        dcount++;
+                                        break;
+                                  case TypeDecl::Ftype:
+                                        fcount++;
+                                        break;
+                                } // switch
+                                varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
+                                for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
+                                        Mangler sub_mangler;
+                                        sub_mangler.nextVarNum = nextVarNum;
+                                        sub_mangler.isTopLevel = false;
+                                        sub_mangler.varNums = varNums;
+                                        (*assert)->accept( sub_mangler );
+                                        assertionNames.push_back( std::string( sub_mangler.mangleName.str(), sub_mangler.mangleName.pcount() ) );
+                                } // for
+                        } // for
+                        mangleName << tcount << "_" << dcount << "_" << fcount << "_";
+                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
+                        mangleName << "_";
+                } // if
+                if ( type->get_isConst() ) {
+                        mangleName << "C";
+                } // if
+                if ( type->get_isVolatile() ) {
+                        mangleName << "V";
+                } // if
+                if ( type->get_isRestrict() ) {
+                        mangleName << "R";
+                } // if
+                if ( type->get_isLvalue() ) {
+                        mangleName << "L";
+                } // if
+                if ( type->get_isAtomic() ) {
+                        mangleName << "A";
+                } // if
+    }
+} // namespace SymTab
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/Mangler.h

-              ra32b204
+              r0dd3a2f
+#ifndef SYMTAB_MANGLER_H
+#define SYMTAB_MANGLER_H
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Mangler.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:44:03 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:45:05 2015
+// Update Count     : 2
+//
+#ifndef MANGLER_H
+#define MANGLER_H
 #include <strstream>
 …
     class Mangler : public Visitor {
       public:
         template< typename SynTreeClass >
+                template< typename SynTreeClass >
             static std::string mangle( SynTreeClass *decl ); // interface to clients
 ///   using Visitor::visit;
         virtual void visit( ObjectDecl *declaration );
         virtual void visit( FunctionDecl *declaration );
         virtual void visit( TypeDecl *declaration );
+                virtual void visit( ObjectDecl *declaration );
+                virtual void visit( FunctionDecl *declaration );
+                virtual void visit( TypeDecl *declaration );
         virtual void visit( VoidType *voidType );
         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( TypeInstType *aggregateUseType );
         virtual void visit( TupleType *tupleType );
+                virtual void visit( VoidType *voidType );
+                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( TypeInstType *aggregateUseType );
+                virtual void visit( TupleType *tupleType );
         std::string get_mangleName() { return std::string( mangleName.str(), mangleName.pcount() ); }
+                std::string get_mangleName() { return std::string( mangleName.str(), mangleName.pcount() ); }
       private:
         std::ostrstream mangleName;
         typedef std::map< std::string, std::pair< int, int > > VarMapType;
         VarMapType varNums;
         int nextVarNum;
         bool isTopLevel;
+                std::ostrstream mangleName;
+                typedef std::map< std::string, std::pair< int, int > > VarMapType;
+                VarMapType varNums;
+                int nextVarNum;
+                bool isTopLevel;
         Mangler();
         Mangler( const Mangler & );
+                Mangler();
+                Mangler( const Mangler & );
         void mangleDecl( DeclarationWithType *declaration );
         void mangleRef( ReferenceToType *refType, std::string prefix );
+                void mangleDecl( DeclarationWithType *declaration );
+                void mangleRef( ReferenceToType *refType, std::string prefix );
         void printQualifiers( Type *type );
+                void printQualifiers( Type *type );
     }; // Mangler
     template< typename SynTreeClass >
     std::string Mangler::mangle( SynTreeClass *decl ) {
         Mangler mangler;
         maybeAccept( decl, mangler );
         return mangler.get_mangleName();
+                Mangler mangler;
+                maybeAccept( decl, mangler );
+                return mangler.get_mangleName();
+    }
 } // SymTab
+#endif // SYMTAB_MANGLER_H
+#endif // MANGLER_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/StackTable.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// StackTable.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:45:15 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:46:59 2015
+// Update Count     : 2
+//
 #include <cassert>
 …
 namespace SymTab {
     template< typename Element, typename ConflictFunction >
     StackTable< Element, ConflictFunction >::StackTable() : scopeLevel( 0 )
     {}
+    StackTable< Element, ConflictFunction >::StackTable() : scopeLevel( 0 ) {
+        }
     template< typename Element, typename ConflictFunction >
     void StackTable< Element, ConflictFunction >::enterScope() {
         scopeLevel++;
+                scopeLevel++;
+    }
     template< typename Element, typename ConflictFunction >
     void StackTable< Element, ConflictFunction >::leaveScope() {
         for ( typename TableType::iterator it = table.begin(); it != table.end(); ++it ) {
             std::stack< Entry >& entry = it->second;
             if ( ! entry.empty() && entry.top().second == scopeLevel ) {
                 entry.pop();
+            }
+        }
         scopeLevel--;
         assert( scopeLevel >= 0 );
+                for ( typename TableType::iterator it = table.begin(); it != table.end(); ++it ) {
+                        std::stack< Entry >& entry = it->second;
+                        if ( ! entry.empty() && entry.top().second == scopeLevel ) {
+                                entry.pop();
+                        } // if
+                } // for
+                scopeLevel--;
+                assert( scopeLevel >= 0 );
+    }
     template< typename Element, typename ConflictFunction >
     void StackTable< Element, ConflictFunction >::add( Element *type ) {
         std::stack< Entry >& entry = table[ type->get_name() ];
         if ( ! entry.empty() && entry.top().second == scopeLevel ) {
             entry.top().first = conflictFunction( entry.top().first, type );
         } else {
             entry.push( Entry( type, scopeLevel ) );
+        }
+                std::stack< Entry >& entry = table[ type->get_name() ];
+                if ( ! entry.empty() && entry.top().second == scopeLevel ) {
+                        entry.top().first = conflictFunction( entry.top().first, type );
+                } else {
+                        entry.push( Entry( type, scopeLevel ) );
+                } // if
+    }
     template< typename Element, typename ConflictFunction >
     void StackTable< Element, ConflictFunction >::add( std::string fwdDeclName ) {
         add( new Element( fwdDeclName ) );
+                add( new Element( fwdDeclName ) );
+    }
     template< typename Element, typename ConflictFunction >
     Element *StackTable< Element, ConflictFunction >::lookup( std::string id ) const {
         typename TableType::const_iterator it = table.find( id );
         if ( it == table.end() ) {
             return 0;
         } else if ( ! it->second.empty() ) {
             return it->second.top().first;
         } else {
             return 0;
+        }
+                typename TableType::const_iterator it = table.find( id );
+                if ( it == table.end() ) {
+                        return 0;
+                } else if ( ! it->second.empty() ) {
+                        return it->second.top().first;
+                } else {
+                        return 0;
+                } // if
+    }
     template< typename Element, typename ConflictFunction >
     void StackTable< Element, ConflictFunction >::dump( std::ostream &os ) const {
         for ( typename TableType::const_iterator it = table.begin(); it != table.end(); ++it ) {
             const std::stack< Entry >& entry = it->second;
             if ( ! entry.empty() && entry.top().second == scopeLevel ) {
                 os << it->first << std::endl;
+            }
+        }
+                for ( typename TableType::const_iterator it = table.begin(); it != table.end(); ++it ) {
+                        const std::stack< Entry >& entry = it->second;
+                        if ( ! entry.empty() && entry.top().second == scopeLevel ) {
+                                os << it->first << std::endl;
+                        } // if
+                } // for
+    }
+} // SymTab
+} // namespace SymTab
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/StackTable.h

-              ra32b204
+              r0dd3a2f
+#ifndef SYMTAB_STACKTABLE_H
+#define SYMTAB_STACKTABLE_H
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// StackTable.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:47:10 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:48:15 2015
+// Update Count     : 3
+//
+#ifndef STACKTABLE_H
+#define STACKTABLE_H
 #include <map>
 …
         class StackTable {
       public:
         StackTable();
+                StackTable();
         void enterScope();
         void leaveScope();
         void add( Element *type );
         void add( std::string fwdDeclName );
         Element *lookup( std::string id ) const;
+                void enterScope();
+                void leaveScope();
+                void add( Element *type );
+                void add( std::string fwdDeclName );
+                Element *lookup( std::string id ) const;
         void dump( std::ostream &os ) const; // debugging
+                void dump( std::ostream &os ) const;                    // debugging
       private:
         typedef std::pair< Element*, int > Entry;
         typedef std::map< std::string, std::stack< Entry > > TableType;
+                typedef std::pair< Element*, int > Entry;
+                typedef std::map< std::string, std::stack< Entry > > TableType;
         ConflictFunction conflictFunction;
         TableType table;
         int scopeLevel;
+                ConflictFunction conflictFunction;
+                TableType table;
+                int scopeLevel;
     };
 } // SymTab
 …
 #include "StackTable.cc"
+#endif // SYMTAB_STACKTABLE_H
+#endif // STACKTABLE_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/TypeTable.h

-              ra32b204
+              r0dd3a2f
+#ifndef SYMTAB_TYPETABLE_H
+#define SYMTAB_TYPETABLE_H
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// TypeTable.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:48:32 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:49:49 2015
+// Update Count     : 2
+//
+#ifndef TYPETABLE_H
+#define TYPETABLE_H
 #include <cassert>
 …
     class TypeTableConflictFunction : public std::binary_function< NamedTypeDecl *, NamedTypeDecl *, NamedTypeDecl * > {
       public:
         NamedTypeDecl *operator()( NamedTypeDecl *existing, NamedTypeDecl *added ) {
             if ( existing->get_base() == 0 ) {
                 return added;
             } else if ( added->get_base() == 0 ) {
                 return existing;
             } else {
                 throw SemanticError( "redeclaration of ", added );
+            }
             assert( false );
             return 0;
+        }
+                NamedTypeDecl *operator()( NamedTypeDecl *existing, NamedTypeDecl *added ) {
+                        if ( existing->get_base() == 0 ) {
+                                return added;
+                        } else if ( added->get_base() == 0 ) {
+                                return existing;
+                        } else {
+                                throw SemanticError( "redeclaration of ", added );
+                        } // if
+                        assert( false );
+                        return 0;
+                }
     };
     typedef StackTable< NamedTypeDecl, TypeTableConflictFunction > TypeTable;
 } // SymTab
+} // namespace SymTab
+#endif // SYMTAB_TYPETABLE_H
+#endif // TYPETABLE_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/Validate.cc

-              ra32b204
+              r0dd3a2f
+/*
+  The "validate" phase of translation is used to take a syntax tree and convert it into a standard form that aims to be
+  as regular in structure as possible.  Some assumptions can be made regarding the state of the tree after this pass is
+  complete, including:
+  - No nested structure or union definitions; any in the input are "hoisted" to the level of the containing struct or
+    union.
+  - All enumeration constants have type EnumInstType.
+  - The type "void" never occurs in lists of function parameter or return types; neither do tuple types.  A function
+    taking no arguments has no argument types, and tuples are flattened.
+  - No context instances exist; they are all replaced by the set of declarations signified by the context, instantiated
+    by the particular set of type arguments.
+  - Every declaration is assigned a unique id.
+  - No typedef declarations or instances exist; the actual type is substituted for each instance.
+  - Each type, struct, and union definition is followed by an appropriate assignment operator.
+  - Each use of a struct or union is connected to a complete definition of that struct or union, even if that definition
+    occurs later in the input.
+*/
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Validate.cc --
+//
+// Author           : Richard C. Bilson
+// 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
+//
+// The "validate" phase of translation is used to take a syntax tree and convert it into a standard form that aims to be
+// as regular in structure as possible.  Some assumptions can be made regarding the state of the tree after this pass is
+// complete, including:
+//
+// - No nested structure or union definitions; any in the input are "hoisted" to the level of the containing struct or
+//   union.
+//
+// - All enumeration constants have type EnumInstType.
+//
+// - The type "void" never occurs in lists of function parameter or return types; neither do tuple types.  A function
+//   taking no arguments has no argument types, and tuples are flattened.
+//
+// - No context instances exist; they are all replaced by the set of declarations signified by the context, instantiated
+//   by the particular set of type arguments.
+//
+// - Every declaration is assigned a unique id.
+//
+// - No typedef declarations or instances exist; the actual type is substituted for each instance.
+//
+// - Each type, struct, and union definition is followed by an appropriate assignment operator.
+//
+// - Each use of a struct or union is connected to a complete definition of that struct or union, even if that
+//   definition occurs later in the input.
 #include <list>
 …
     class HoistStruct : public Visitor {
       public:
         static void hoistStruct( std::list< Declaration * > &translationUnit );
         std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
         virtual void visit( StructDecl *aggregateDecl );
         virtual void visit( UnionDecl *aggregateDecl );
         virtual void visit( CompoundStmt *compoundStmt );
         virtual void visit( IfStmt *ifStmt );
         virtual void visit( WhileStmt *whileStmt );
         virtual void visit( ForStmt *forStmt );
         virtual void visit( SwitchStmt *switchStmt );
         virtual void visit( ChooseStmt *chooseStmt );
         virtual void visit( CaseStmt *caseStmt );
         virtual void visit( CatchStmt *catchStmt );
+                static void hoistStruct( std::list< Declaration * > &translationUnit );
+                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
+                virtual void visit( StructDecl *aggregateDecl );
+                virtual void visit( UnionDecl *aggregateDecl );
+                virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( IfStmt *ifStmt );
+                virtual void visit( WhileStmt *whileStmt );
+                virtual void visit( ForStmt *forStmt );
+                virtual void visit( SwitchStmt *switchStmt );
+                virtual void visit( ChooseStmt *chooseStmt );
+                virtual void visit( CaseStmt *caseStmt );
+                virtual void visit( CatchStmt *catchStmt );
       private:
         HoistStruct();
         template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl );
         std::list< Declaration * > declsToAdd;
         bool inStruct;
+                HoistStruct();
+                template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl );
+                std::list< Declaration * > declsToAdd;
+                bool inStruct;
     };
     class Pass1 : public Visitor {
         typedef Visitor Parent;
         virtual void visit( EnumDecl *aggregateDecl );
         virtual void visit( FunctionType *func );
+                typedef Visitor Parent;
+                virtual void visit( EnumDecl *aggregateDecl );
+                virtual void visit( FunctionType *func );
     };
     class Pass2 : public Indexer {
         typedef Indexer Parent;
+                typedef Indexer Parent;
       public:
         Pass2( bool doDebug, const Indexer *indexer );
+                Pass2( bool doDebug, const Indexer *indexer );
       private:
         virtual void visit( StructInstType *structInst );
         virtual void visit( UnionInstType *unionInst );
         virtual void visit( ContextInstType *contextInst );
         virtual void visit( StructDecl *structDecl );
         virtual void visit( UnionDecl *unionDecl );
         virtual void visit( TypeInstType *typeInst );
         const Indexer *indexer;
         typedef std::map< std::string, std::list< StructInstType * > > ForwardStructsType;
         typedef std::map< std::string, std::list< UnionInstType * > > ForwardUnionsType;
         ForwardStructsType forwardStructs;
         ForwardUnionsType forwardUnions;
+                virtual void visit( StructInstType *structInst );
+                virtual void visit( UnionInstType *unionInst );
+                virtual void visit( ContextInstType *contextInst );
+                virtual void visit( StructDecl *structDecl );
+                virtual void visit( UnionDecl *unionDecl );
+                virtual void visit( TypeInstType *typeInst );
+                const Indexer *indexer;
+                typedef std::map< std::string, std::list< StructInstType * > > ForwardStructsType;
+                typedef std::map< std::string, std::list< UnionInstType * > > ForwardUnionsType;
+                ForwardStructsType forwardStructs;
+                ForwardUnionsType forwardUnions;
     };
     class Pass3 : public Indexer {
         typedef Indexer Parent;
+                typedef Indexer Parent;
       public:
         Pass3( const Indexer *indexer );
+                Pass3( const Indexer *indexer );
       private:
         virtual void visit( ObjectDecl *object );
         virtual void visit( FunctionDecl *func );
         const Indexer *indexer;
+                virtual void visit( ObjectDecl *object );
+                virtual void visit( FunctionDecl *func );
+                const Indexer *indexer;
     };
     class AddStructAssignment : public Visitor {
       public:
         static void addStructAssignment( std::list< Declaration * > &translationUnit );
         std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
         virtual void visit( StructDecl *structDecl );
         virtual void visit( UnionDecl *structDecl );
         virtual void visit( TypeDecl *typeDecl );
         virtual void visit( ContextDecl *ctxDecl );
         virtual void visit( FunctionDecl *functionDecl );
         virtual void visit( FunctionType *ftype );
         virtual void visit( PointerType *ftype );
         virtual void visit( CompoundStmt *compoundStmt );
         virtual void visit( IfStmt *ifStmt );
         virtual void visit( WhileStmt *whileStmt );
         virtual void visit( ForStmt *forStmt );
         virtual void visit( SwitchStmt *switchStmt );
         virtual void visit( ChooseStmt *chooseStmt );
         virtual void visit( CaseStmt *caseStmt );
         virtual void visit( CatchStmt *catchStmt );
         AddStructAssignment() : functionNesting( 0 ) {}
+                static void addStructAssignment( std::list< Declaration * > &translationUnit );
+                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
+                virtual void visit( StructDecl *structDecl );
+                virtual void visit( UnionDecl *structDecl );
+                virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( ContextDecl *ctxDecl );
+                virtual void visit( FunctionDecl *functionDecl );
+                virtual void visit( FunctionType *ftype );
+                virtual void visit( PointerType *ftype );
+                virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( IfStmt *ifStmt );
+                virtual void visit( WhileStmt *whileStmt );
+                virtual void visit( ForStmt *forStmt );
+                virtual void visit( SwitchStmt *switchStmt );
+                virtual void visit( ChooseStmt *chooseStmt );
+                virtual void visit( CaseStmt *caseStmt );
+                virtual void visit( CatchStmt *catchStmt );
+                AddStructAssignment() : functionNesting( 0 ) {}
       private:
         template< typename StmtClass > void visitStatement( StmtClass *stmt );
         std::list< Declaration * > declsToAdd;
         std::set< std::string > structsDone;
         unsigned int functionNesting;                   // current level of nested functions
+                template< typename StmtClass > void visitStatement( StmtClass *stmt );
+                std::list< Declaration * > declsToAdd;
+                std::set< std::string > structsDone;
+                unsigned int functionNesting;                   // current level of nested functions
     };
     class EliminateTypedef : public Mutator {
       public:
         static void eliminateTypedef( std::list< Declaration * > &translationUnit );
+                static void eliminateTypedef( std::list< Declaration * > &translationUnit );
       private:
         virtual Declaration *mutate( TypedefDecl *typeDecl );
         virtual TypeDecl *mutate( TypeDecl *typeDecl );
         virtual DeclarationWithType *mutate( FunctionDecl *funcDecl );
         virtual ObjectDecl *mutate( ObjectDecl *objDecl );
         virtual CompoundStmt *mutate( CompoundStmt *compoundStmt );
         virtual Type *mutate( TypeInstType *aggregateUseType );
         virtual Expression *mutate( CastExpr *castExpr );
         std::map< std::string, TypedefDecl * > typedefNames;
+                virtual Declaration *mutate( TypedefDecl *typeDecl );
+                virtual TypeDecl *mutate( TypeDecl *typeDecl );
+                virtual DeclarationWithType *mutate( FunctionDecl *funcDecl );
+                virtual ObjectDecl *mutate( ObjectDecl *objDecl );
+                virtual CompoundStmt *mutate( CompoundStmt *compoundStmt );
+                virtual Type *mutate( TypeInstType *aggregateUseType );
+                virtual Expression *mutate( CastExpr *castExpr );
+                std::map< std::string, TypedefDecl * > typedefNames;
     };
     void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
         Pass1 pass1;
         Pass2 pass2( doDebug, 0 );
         Pass3 pass3( 0 );
         EliminateTypedef::eliminateTypedef( translationUnit );
         HoistStruct::hoistStruct( translationUnit );
         acceptAll( translationUnit, pass1 );
         acceptAll( translationUnit, pass2 );
         AddStructAssignment::addStructAssignment( translationUnit );
         acceptAll( translationUnit, pass3 );
+                Pass1 pass1;
+                Pass2 pass2( doDebug, 0 );
+                Pass3 pass3( 0 );
+                EliminateTypedef::eliminateTypedef( translationUnit );
+                HoistStruct::hoistStruct( translationUnit );
+                acceptAll( translationUnit, pass1 );
+                acceptAll( translationUnit, pass2 );
+                AddStructAssignment::addStructAssignment( translationUnit );
+                acceptAll( translationUnit, pass3 );
+    }
     void validateType( Type *type, const Indexer *indexer ) {
         Pass1 pass1;
         Pass2 pass2( false, indexer );
         Pass3 pass3( indexer );
         type->accept( pass1 );
         type->accept( pass2 );
         type->accept( pass3 );
+                Pass1 pass1;
+                Pass2 pass2( false, indexer );
+                Pass3 pass3( indexer );
+                type->accept( pass1 );
+                type->accept( pass2 );
+                type->accept( pass3 );
+    }
     template< typename Visitor >
     void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor, bool addBefore ) {
         std::list< Declaration * >::iterator i = translationUnit.begin();
         while ( i != translationUnit.end() ) {
             (*i)->accept( visitor );
             std::list< Declaration * >::iterator next = i;
             next++;
             if ( ! visitor.get_declsToAdd().empty() ) {
                 translationUnit.splice( addBefore ? i : next, visitor.get_declsToAdd() );
             } // if
             i = next;
         } // while
+                std::list< Declaration * >::iterator i = translationUnit.begin();
+                while ( i != translationUnit.end() ) {
+                        (*i)->accept( visitor );
+                        std::list< Declaration * >::iterator next = i;
+                        next++;
+                        if ( ! visitor.get_declsToAdd().empty() ) {
+                                translationUnit.splice( addBefore ? i : next, visitor.get_declsToAdd() );
+                        } // if
+                        i = next;
+                } // while
+    }
     void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
         HoistStruct hoister;
         acceptAndAdd( translationUnit, hoister, true );
+                HoistStruct hoister;
+                acceptAndAdd( translationUnit, hoister, true );
+    }
 …
     void filter( std::list< Declaration * > &declList, bool (*pred)( Declaration * ), bool doDelete ) {
         std::list< Declaration * >::iterator i = declList.begin();
         while ( i != declList.end() ) {
             std::list< Declaration * >::iterator next = i;
             ++next;
             if ( pred( *i ) ) {
                 if ( doDelete ) {
                     delete *i;
                 } // if
                 declList.erase( i );
             } // if
             i = next;
         } // while
+                std::list< Declaration * >::iterator i = declList.begin();
+                while ( i != declList.end() ) {
+                        std::list< Declaration * >::iterator next = i;
+                        ++next;
+                        if ( pred( *i ) ) {
+                                if ( doDelete ) {
+                                        delete *i;
+                                } // if
+                                declList.erase( i );
+                        } // if
+                        i = next;
+                } // while
+    }
     bool isStructOrUnion( Declaration *decl ) {
         return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
+                return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
+    }
     template< typename AggDecl >
     void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
         if ( inStruct ) {
             // Add elements in stack order corresponding to nesting structure.
             declsToAdd.push_front( aggregateDecl );
             Visitor::visit( aggregateDecl );
         } else {
             inStruct = true;
             Visitor::visit( aggregateDecl );
             inStruct = false;
         } // if
         // Always remove the hoisted aggregate from the inner structure.
         filter( aggregateDecl->get_members(), isStructOrUnion, false );
+                if ( inStruct ) {
+                        // Add elements in stack order corresponding to nesting structure.
+                        declsToAdd.push_front( aggregateDecl );
+                        Visitor::visit( aggregateDecl );
+                } else {
+                        inStruct = true;
+                        Visitor::visit( aggregateDecl );
+                        inStruct = false;
+                } // if
+                // Always remove the hoisted aggregate from the inner structure.
+                filter( aggregateDecl->get_members(), isStructOrUnion, false );
+    }
     void HoistStruct::visit( StructDecl *aggregateDecl ) {
         handleAggregate( aggregateDecl );
+                handleAggregate( aggregateDecl );
+    }
     void HoistStruct::visit( UnionDecl *aggregateDecl ) {
         handleAggregate( aggregateDecl );
+                handleAggregate( aggregateDecl );
+    }
     void HoistStruct::visit( CompoundStmt *compoundStmt ) {
         addVisit( compoundStmt, *this );
+                addVisit( compoundStmt, *this );
+    }
     void HoistStruct::visit( IfStmt *ifStmt ) {
         addVisit( ifStmt, *this );
+                addVisit( ifStmt, *this );
+    }
     void HoistStruct::visit( WhileStmt *whileStmt ) {
         addVisit( whileStmt, *this );
+                addVisit( whileStmt, *this );
+    }
     void HoistStruct::visit( ForStmt *forStmt ) {
         addVisit( forStmt, *this );
+                addVisit( forStmt, *this );
+    }
     void HoistStruct::visit( SwitchStmt *switchStmt ) {
         addVisit( switchStmt, *this );
+                addVisit( switchStmt, *this );
+    }
     void HoistStruct::visit( ChooseStmt *switchStmt ) {
         addVisit( switchStmt, *this );
+                addVisit( switchStmt, *this );
+    }
     void HoistStruct::visit( CaseStmt *caseStmt ) {
         addVisit( caseStmt, *this );
+                addVisit( caseStmt, *this );
+    }
     void HoistStruct::visit( CatchStmt *cathStmt ) {
         addVisit( cathStmt, *this );
+                addVisit( cathStmt, *this );
+    }
     void Pass1::visit( EnumDecl *enumDecl ) {
         // Set the type of each member of the enumeration to be EnumConstant
         for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
             ObjectDecl *obj = dynamic_cast< ObjectDecl * >( *i );
             assert( obj );
             obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
         } // for
         Parent::visit( enumDecl );
+                // Set the type of each member of the enumeration to be EnumConstant
+                for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
+                        ObjectDecl *obj = dynamic_cast< ObjectDecl * >( *i );
+                        assert( obj );
+                        obj->set_type( new EnumInstType( Type::Qualifiers( true, false, false, false, false, false ), enumDecl->get_name() ) );
+                } // for
+                Parent::visit( enumDecl );
+    }
     namespace {
+        template< typename DWTIterator >
+        void fixFunctionList( DWTIterator begin, DWTIterator end, FunctionType *func ) {
+            // the only case in which "void" is valid is where it is the only one in the list; then
+            // it should be removed entirely
+            // other fix ups are handled by the FixFunction class
+            if ( begin == end ) return;
+            FixFunction fixer;
+            DWTIterator i = begin;
+            *i = (*i )->acceptMutator( fixer );
+            if ( fixer.get_isVoid() ) {
+                DWTIterator j = i;
+                ++i;
+                func->get_parameters().erase( j );
+                if ( i != end ) {
+                    throw SemanticError( "invalid type void in function type ", func );
+                } // if
+            } else {
+                ++i;
+                for ( ; i != end; ++i ) {
+                    FixFunction fixer;
+                    *i = (*i )->acceptMutator( fixer );
+                    if ( fixer.get_isVoid() ) {
+                        throw SemanticError( "invalid type void in function type ", func );
+                    } // if
+                template< typename DWTIterator >
+                void fixFunctionList( DWTIterator begin, DWTIterator end, FunctionType *func ) {
+                        // the only case in which "void" is valid is where it is the only one in the list; then it should be removed
+                        // entirely other fix ups are handled by the FixFunction class
+                        if ( begin == end ) return;
+                        FixFunction fixer;
+                        DWTIterator i = begin;
+                        *i = (*i )->acceptMutator( fixer );
+                        if ( fixer.get_isVoid() ) {
+                                DWTIterator j = i;
+                                ++i;
+                                func->get_parameters().erase( j );
+                                if ( i != end ) {
+                                        throw SemanticError( "invalid type void in function type ", func );
+                                } // if
+                        } else {
+                                ++i;
+                                for ( ; i != end; ++i ) {
+                                        FixFunction fixer;
+                                        *i = (*i )->acceptMutator( fixer );
+                                        if ( fixer.get_isVoid() ) {
+                                                throw SemanticError( "invalid type void in function type ", func );
+                                        } // if
+                                } // for
+                        } // if
+                }
+    }
+    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 ) {
+                if ( other_indexer ) {
+                        indexer = other_indexer;
+                } else {
+                        indexer = this;
+                } // if
+    }
+    void Pass2::visit( StructInstType *structInst ) {
+                Parent::visit( structInst );
+                StructDecl *st = indexer->lookupStruct( structInst->get_name() );
+                // it's not a semantic error if the struct is not found, just an implicit forward declaration
+                if ( st ) {
+                        assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
+                        structInst->set_baseStruct( st );
+                } // if
+                if ( ! st || st->get_members().empty() ) {
+                        // use of forward declaration
+                        forwardStructs[ structInst->get_name() ].push_back( structInst );
+                } // if
+    }
+    void Pass2::visit( UnionInstType *unionInst ) {
+                Parent::visit( unionInst );
+                UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
+                // it's not a semantic error if the union is not found, just an implicit forward declaration
+                if ( un ) {
+                        unionInst->set_baseUnion( un );
+                } // if
+                if ( ! un || un->get_members().empty() ) {
+                        // use of forward declaration
+                        forwardUnions[ unionInst->get_name() ].push_back( unionInst );
+                } // if
+    }
+    void Pass2::visit( ContextInstType *contextInst ) {
+                Parent::visit( contextInst );
+                ContextDecl *ctx = indexer->lookupContext( contextInst->get_name() );
+                if ( ! ctx ) {
+                        throw SemanticError( "use of undeclared context " + contextInst->get_name() );
+                } // if
+                for ( std::list< TypeDecl * >::const_iterator i = ctx->get_parameters().begin(); i != ctx->get_parameters().end(); ++i ) {
+                        for ( std::list< DeclarationWithType * >::const_iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
+                                if ( ContextInstType *otherCtx = dynamic_cast< ContextInstType * >(*assert ) ) {
+                                        cloneAll( otherCtx->get_members(), contextInst->get_members() );
+                                } else {
+                                        contextInst->get_members().push_back( (*assert )->clone() );
+                                } // if
+                        } // for
                 } // for
+            } // if
+        }
+    }
+    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 ) {
+        if ( other_indexer ) {
+            indexer = other_indexer;
+        } else {
+            indexer = this;
+        } // if
+    }
+    void Pass2::visit( StructInstType *structInst ) {
+        Parent::visit( structInst );
+        StructDecl *st = indexer->lookupStruct( structInst->get_name() );
+        // it's not a semantic error if the struct is not found, just an implicit forward declaration
+        if ( st ) {
+            assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
+            structInst->set_baseStruct( st );
+        } // if
+        if ( ! st || st->get_members().empty() ) {
+            // use of forward declaration
+            forwardStructs[ structInst->get_name() ].push_back( structInst );
+        } // if
+    }
+    void Pass2::visit( UnionInstType *unionInst ) {
+        Parent::visit( unionInst );
+        UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
+        // it's not a semantic error if the union is not found, just an implicit forward declaration
+        if ( un ) {
+            unionInst->set_baseUnion( un );
+        } // if
+        if ( ! un || un->get_members().empty() ) {
+            // use of forward declaration
+            forwardUnions[ unionInst->get_name() ].push_back( unionInst );
+        } // if
+    }
+    void Pass2::visit( ContextInstType *contextInst ) {
+        Parent::visit( contextInst );
+        ContextDecl *ctx = indexer->lookupContext( contextInst->get_name() );
+        if ( ! ctx ) {
+            throw SemanticError( "use of undeclared context " + contextInst->get_name() );
+        } // if
+        for ( std::list< TypeDecl * >::const_iterator i = ctx->get_parameters().begin(); i != ctx->get_parameters().end(); ++i ) {
+            for ( std::list< DeclarationWithType * >::const_iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
+                if ( ContextInstType *otherCtx = dynamic_cast< ContextInstType * >(*assert ) ) {
+                    cloneAll( otherCtx->get_members(), contextInst->get_members() );
+                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 ) {
+                if ( ! structDecl->get_members().empty() ) {
+                        ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
+                        if ( fwds != forwardStructs.end() ) {
+                                for ( std::list< StructInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
+                                        (*inst )->set_baseStruct( structDecl );
+                                } // for
+                                forwardStructs.erase( fwds );
+                        } // if
+                } // if
+                Indexer::visit( structDecl );
+    }
+    void Pass2::visit( UnionDecl *unionDecl ) {
+                if ( ! unionDecl->get_members().empty() ) {
+                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
+                        if ( fwds != forwardUnions.end() ) {
+                                for ( std::list< UnionInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
+                                        (*inst )->set_baseUnion( unionDecl );
+                                } // for
+                                forwardUnions.erase( fwds );
+                        } // if
+                } // if
+                Indexer::visit( unionDecl );
+    }
+    void Pass2::visit( TypeInstType *typeInst ) {
+                if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
+                        if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
+                                typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
+                        } // if
+                } // if
+    }
+    Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
+                if ( other_indexer ) {
+                        indexer = other_indexer;
                 } else {
+                    contextInst->get_members().push_back( (*assert )->clone() );
+                } // if
+            } // for
+        } // 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 ) {
+        if ( ! structDecl->get_members().empty() ) {
+            ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
+            if ( fwds != forwardStructs.end() ) {
+                for ( std::list< StructInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
+                    (*inst )->set_baseStruct( structDecl );
+                        indexer = this;
+                } // if
+    }
+    void forallFixer( Type *func ) {
+                // Fix up assertions
+                for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
+                        std::list< DeclarationWithType * > toBeDone, nextRound;
+                        toBeDone.splice( toBeDone.end(), (*type )->get_assertions() );
+                        while ( ! toBeDone.empty() ) {
+                                for ( std::list< DeclarationWithType * >::iterator assertion = toBeDone.begin(); assertion != toBeDone.end(); ++assertion ) {
+                                        if ( ContextInstType *ctx = dynamic_cast< ContextInstType * >( (*assertion )->get_type() ) ) {
+                                                for ( std::list< Declaration * >::const_iterator i = ctx->get_members().begin(); i != ctx->get_members().end(); ++i ) {
+                                                        DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *i );
+                                                        assert( dwt );
+                                                        nextRound.push_back( dwt->clone() );
+                                                }
+                                                delete ctx;
+                                        } else {
+                                                FixFunction fixer;
+                                                *assertion = (*assertion )->acceptMutator( fixer );
+                                                if ( fixer.get_isVoid() ) {
+                                                        throw SemanticError( "invalid type void in assertion of function ", func );
+                                                }
+                                                (*type )->get_assertions().push_back( *assertion );
+                                        } // if
+                                } // for
+                                toBeDone.clear();
+                                toBeDone.splice( toBeDone.end(), nextRound );
+                        } // while
                 } // for
-                forwardStructs.erase( fwds );
-            } // if
-        } // if
-        Indexer::visit( structDecl );
+    }
-    void Pass2::visit( UnionDecl *unionDecl ) {
-        if ( ! unionDecl->get_members().empty() ) {
-            ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
-            if ( fwds != forwardUnions.end() ) {
-                for ( std::list< UnionInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
-                    (*inst )->set_baseUnion( unionDecl );
-                } // for
-                forwardUnions.erase( fwds );
-            } // if
-        } // if
-        Indexer::visit( unionDecl );
+    }
-    void Pass2::visit( TypeInstType *typeInst ) {
-        if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
-            if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
-                typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
-            } // if
-        } // if
+    }
-    Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
-        if ( other_indexer ) {
-            indexer = other_indexer;
-        } else {
-            indexer = this;
-        } // if
+    }
-    void forallFixer( Type *func ) {
-        // Fix up assertions
-        for ( std::list< TypeDecl * >::iterator type = func->get_forall().begin(); type != func->get_forall().end(); ++type ) {
-            std::list< DeclarationWithType * > toBeDone, nextRound;
-            toBeDone.splice( toBeDone.end(), (*type )->get_assertions() );
-            while ( ! toBeDone.empty() ) {
-                for ( std::list< DeclarationWithType * >::iterator assertion = toBeDone.begin(); assertion != toBeDone.end(); ++assertion ) {
-                    if ( ContextInstType *ctx = dynamic_cast< ContextInstType * >( (*assertion )->get_type() ) ) {
-                        for ( std::list< Declaration * >::const_iterator i = ctx->get_members().begin(); i != ctx->get_members().end(); ++i ) {
-                            DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *i );
-                            assert( dwt );
-                            nextRound.push_back( dwt->clone() );
+                        }
-                        delete ctx;
-                    } else {
-                        FixFunction fixer;
-                        *assertion = (*assertion )->acceptMutator( fixer );
-                        if ( fixer.get_isVoid() ) {
-                            throw SemanticError( "invalid type void in assertion of function ", func );
+                        }
-                        (*type )->get_assertions().push_back( *assertion );
+                    }
+                }
-                toBeDone.clear();
-                toBeDone.splice( toBeDone.end(), nextRound );
+            }
+        }
+    }
     void Pass3::visit( ObjectDecl *object ) {
         forallFixer( object->get_type() );
         if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
             forallFixer( pointer->get_base() );
         } // if
         Parent::visit( object );
         object->fixUniqueId();
+                forallFixer( object->get_type() );
+                if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
+                        forallFixer( pointer->get_base() );
+                } // if
+                Parent::visit( object );
+                object->fixUniqueId();
+    }
     void Pass3::visit( FunctionDecl *func ) {
         forallFixer( func->get_type() );
         Parent::visit( func );
         func->fixUniqueId();
+                forallFixer( func->get_type() );
+                Parent::visit( func );
+                func->fixUniqueId();
+    }
 …
     void AddStructAssignment::addStructAssignment( std::list< Declaration * > &translationUnit ) {
         AddStructAssignment visitor;
         acceptAndAdd( translationUnit, visitor, false );
+                AddStructAssignment visitor;
+                acceptAndAdd( translationUnit, visitor, false );
+    }
     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
         if ( obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL ) return;
         UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
         UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
         derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
         // do something special for unnamed members
         Expression *dstselect = new AddressExpr( new MemberExpr( member, derefExpr ) );
         assignExpr->get_args().push_back( dstselect );
         Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
         assignExpr->get_args().push_back( srcselect );
         *out++ = new ExprStmt( noLabels, assignExpr );
+                ObjectDecl *obj = dynamic_cast<ObjectDecl *>( member );
+                // unnamed bit fields are not copied as they cannot be accessed
+                if ( obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL ) return;
+                UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
+                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
+                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
+                // do something special for unnamed members
+                Expression *dstselect = new AddressExpr( new MemberExpr( member, derefExpr ) );
+                assignExpr->get_args().push_back( dstselect );
+                Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
+                assignExpr->get_args().push_back( srcselect );
+                *out++ = new ExprStmt( noLabels, assignExpr );
+    }
     template< typename OutputIterator >
     void makeArrayAssignment( ObjectDecl *srcParam, ObjectDecl *dstParam, DeclarationWithType *member, ArrayType *array, OutputIterator out ) {
         static UniqueName indexName( "_index" );
         // for a flexible array member nothing is done -- user must define own assignment
         if ( ! array->get_dimension() ) return;
         ObjectDecl *index = new ObjectDecl( indexName.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 );
         *out++ = new DeclStmt( noLabels, index );
         UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
         init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
         init->get_args().push_back( new NameExpr( "0" ) );
         Statement *initStmt = new ExprStmt( noLabels, init );
         UntypedExpr *cond = new UntypedExpr( new NameExpr( "?<?" ) );
         cond->get_args().push_back( new VariableExpr( index ) );
         cond->get_args().push_back( array->get_dimension()->clone() );
         UntypedExpr *inc = new UntypedExpr( new NameExpr( "++?" ) );
         inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
         UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
         UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
         derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
         Expression *dstselect = new MemberExpr( member, derefExpr );
         UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?+?" ) );
         dstIndex->get_args().push_back( dstselect );
         dstIndex->get_args().push_back( new VariableExpr( index ) );
         assignExpr->get_args().push_back( dstIndex );
         Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
         UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
         srcIndex->get_args().push_back( srcselect );
         srcIndex->get_args().push_back( new VariableExpr( index ) );
         assignExpr->get_args().push_back( srcIndex );
         *out++ = new ForStmt( noLabels, initStmt, cond, inc, new ExprStmt( noLabels, assignExpr ) );
+                static UniqueName indexName( "_index" );
+                // for a flexible array member nothing is done -- user must define own assignment
+                if ( ! array->get_dimension() ) return;
+                ObjectDecl *index = new ObjectDecl( indexName.newName(), Declaration::NoStorageClass, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 );
+                *out++ = new DeclStmt( noLabels, index );
+                UntypedExpr *init = new UntypedExpr( new NameExpr( "?=?" ) );
+                init->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                init->get_args().push_back( new NameExpr( "0" ) );
+                Statement *initStmt = new ExprStmt( noLabels, init );
+                UntypedExpr *cond = new UntypedExpr( new NameExpr( "?<?" ) );
+                cond->get_args().push_back( new VariableExpr( index ) );
+                cond->get_args().push_back( array->get_dimension()->clone() );
+                UntypedExpr *inc = new UntypedExpr( new NameExpr( "++?" ) );
+                inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                UntypedExpr *assignExpr = new UntypedExpr( new NameExpr( "?=?" ) );
+                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
+                derefExpr->get_args().push_back( new VariableExpr( dstParam ) );
+                Expression *dstselect = new MemberExpr( member, derefExpr );
+                UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?+?" ) );
+                dstIndex->get_args().push_back( dstselect );
+                dstIndex->get_args().push_back( new VariableExpr( index ) );
+                assignExpr->get_args().push_back( dstIndex );
+                Expression *srcselect = new MemberExpr( member, new VariableExpr( srcParam ) );
+                UntypedExpr *srcIndex = new UntypedExpr( new NameExpr( "?[?]" ) );
+                srcIndex->get_args().push_back( srcselect );
+                srcIndex->get_args().push_back( new VariableExpr( index ) );
+                assignExpr->get_args().push_back( srcIndex );
+                *out++ = new ForStmt( noLabels, initStmt, cond, inc, new ExprStmt( noLabels, assignExpr ) );
+    }
     Declaration *makeStructAssignment( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting ) {
         FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
         ObjectDecl *returnVal = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
         assignType->get_returnVals().push_back( returnVal );
         ObjectDecl *dstParam = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
         assignType->get_parameters().push_back( dstParam );
         ObjectDecl *srcParam = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType, 0 );
         assignType->get_parameters().push_back( srcParam );
         // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
         // because each unit generates copies of the default routines for each aggregate.
         FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? Declaration::NoStorageClass : Declaration::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true );
         assignDecl->fixUniqueId();
         for ( std::list< Declaration * >::const_iterator member = aggregateDecl->get_members().begin(); member != aggregateDecl->get_members().end(); ++member ) {
             if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ) ) {
                 if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
                     makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
                 } else {
                     makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
                 } // if
             } // if
         } // for
         assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
         return assignDecl;
+                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
+                ObjectDecl *returnVal = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
+                assignType->get_returnVals().push_back( returnVal );
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
+                assignType->get_parameters().push_back( dstParam );
+                ObjectDecl *srcParam = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType, 0 );
+                assignType->get_parameters().push_back( srcParam );
+                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
+                // because each unit generates copies of the default routines for each aggregate.
+                FunctionDecl *assignDecl = new FunctionDecl( "?=?", functionNesting > 0 ? Declaration::NoStorageClass : Declaration::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true );
+                assignDecl->fixUniqueId();
+                for ( std::list< Declaration * >::const_iterator member = aggregateDecl->get_members().begin(); member != aggregateDecl->get_members().end(); ++member ) {
+                        if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( *member ) ) {
+                                if ( ArrayType *array = dynamic_cast< ArrayType * >( dwt->get_type() ) ) {
+                                        makeArrayAssignment( srcParam, dstParam, dwt, array, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                } else {
+                                        makeScalarAssignment( srcParam, dstParam, dwt, back_inserter( assignDecl->get_statements()->get_kids() ) );
+                                } // if
+                        } // if
+                } // for
+                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                return assignDecl;
+    }
     Declaration *makeUnionAssignment( UnionDecl *aggregateDecl, UnionInstType *refType, unsigned int functionNesting ) {
         FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
         ObjectDecl *returnVal = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
         assignType->get_returnVals().push_back( returnVal );
         ObjectDecl *dstParam = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
         assignType->get_parameters().push_back( dstParam );
         ObjectDecl *srcParam = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType, 0 );
         assignType->get_parameters().push_back( srcParam );
         // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
         // because each unit generates copies of the default routines for each aggregate.
         FunctionDecl *assignDecl = new FunctionDecl( "?=?",  functionNesting > 0 ? Declaration::NoStorageClass : Declaration::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true );
         assignDecl->fixUniqueId();
         UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
         copy->get_args().push_back( new VariableExpr( dstParam ) );
         copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
         copy->get_args().push_back( new SizeofExpr( refType->clone() ) );
         assignDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, copy ) );
         assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
         return assignDecl;
+                FunctionType *assignType = new FunctionType( Type::Qualifiers(), false );
+                ObjectDecl *returnVal = new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType->clone(), 0 );
+                assignType->get_returnVals().push_back( returnVal );
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), refType->clone() ), 0 );
+                assignType->get_parameters().push_back( dstParam );
+                ObjectDecl *srcParam = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, refType, 0 );
+                assignType->get_parameters().push_back( srcParam );
+                // Routines at global scope marked "static" to prevent multiple definitions is separate translation units
+                // because each unit generates copies of the default routines for each aggregate.
+                FunctionDecl *assignDecl = new FunctionDecl( "?=?",  functionNesting > 0 ? Declaration::NoStorageClass : Declaration::Static, LinkageSpec::AutoGen, assignType, new CompoundStmt( noLabels ), true );
+                assignDecl->fixUniqueId();
+                UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
+                copy->get_args().push_back( new VariableExpr( dstParam ) );
+                copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
+                copy->get_args().push_back( new SizeofExpr( refType->clone() ) );
+                assignDecl->get_statements()->get_kids().push_back( new ExprStmt( noLabels, copy ) );
+                assignDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                return assignDecl;
+    }
     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() );
             structInst->set_baseStruct( structDecl );
             declsToAdd.push_back( makeStructAssignment( structDecl, structInst, functionNesting ) );
             structsDone.insert( structDecl->get_name() );
         } // if
+                if ( ! structDecl->get_members().empty() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
+                        StructInstType *structInst = new StructInstType( Type::Qualifiers(), structDecl->get_name() );
+                        structInst->set_baseStruct( structDecl );
+                        declsToAdd.push_back( makeStructAssignment( structDecl, structInst, functionNesting ) );
+                        structsDone.insert( structDecl->get_name() );
+                } // if
+    }
     void AddStructAssignment::visit( UnionDecl *unionDecl ) {
         if ( ! unionDecl->get_members().empty() ) {
             UnionInstType *unionInst = new UnionInstType( Type::Qualifiers(), unionDecl->get_name() );
             unionInst->set_baseUnion( unionDecl );
             declsToAdd.push_back( makeUnionAssignment( unionDecl, unionInst, functionNesting ) );
         } // if
+                if ( ! unionDecl->get_members().empty() ) {
+                        UnionInstType *unionInst = new UnionInstType( Type::Qualifiers(), unionDecl->get_name() );
+                        unionInst->set_baseUnion( unionDecl );
+                        declsToAdd.push_back( makeUnionAssignment( unionDecl, unionInst, functionNesting ) );
+                } // if
+    }
     void AddStructAssignment::visit( TypeDecl *typeDecl ) {
         CompoundStmt *stmts = 0;
         TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
         typeInst->set_baseType( typeDecl );
         ObjectDecl *src = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, typeInst->clone(), 0 );
         ObjectDecl *dst = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), typeInst->clone() ), 0 );
         if ( typeDecl->get_base() ) {
             stmts = new CompoundStmt( std::list< Label >() );
             UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
             assign->get_args().push_back( new CastExpr( new VariableExpr( dst ), new PointerType( Type::Qualifiers(), typeDecl->get_base()->clone() ) ) );
             assign->get_args().push_back( new CastExpr( new VariableExpr( src ), typeDecl->get_base()->clone() ) );
             stmts->get_kids().push_back( new ReturnStmt( std::list< Label >(), assign ) );
         } // if
         FunctionType *type = new FunctionType( Type::Qualifiers(), false );
         type->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, typeInst, 0 ) );
         type->get_parameters().push_back( dst );
         type->get_parameters().push_back( src );
         FunctionDecl *func = new FunctionDecl( "?=?", Declaration::NoStorageClass, LinkageSpec::AutoGen, type, stmts, false );
         declsToAdd.push_back( func );
+                CompoundStmt *stmts = 0;
+                TypeInstType *typeInst = new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), false );
+                typeInst->set_baseType( typeDecl );
+                ObjectDecl *src = new ObjectDecl( "_src", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, typeInst->clone(), 0 );
+                ObjectDecl *dst = new ObjectDecl( "_dst", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), typeInst->clone() ), 0 );
+                if ( typeDecl->get_base() ) {
+                        stmts = new CompoundStmt( std::list< Label >() );
+                        UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+                        assign->get_args().push_back( new CastExpr( new VariableExpr( dst ), new PointerType( Type::Qualifiers(), typeDecl->get_base()->clone() ) ) );
+                        assign->get_args().push_back( new CastExpr( new VariableExpr( src ), typeDecl->get_base()->clone() ) );
+                        stmts->get_kids().push_back( new ReturnStmt( std::list< Label >(), assign ) );
+                } // if
+                FunctionType *type = new FunctionType( Type::Qualifiers(), false );
+                type->get_returnVals().push_back( new ObjectDecl( "", Declaration::NoStorageClass, LinkageSpec::Cforall, 0, typeInst, 0 ) );
+                type->get_parameters().push_back( dst );
+                type->get_parameters().push_back( src );
+                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 ) {
         if ( ! declsToAdd.empty() ) {
             for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
                 statements.insert( i, new DeclStmt( noLabels, *decl ) );
             } // for
             declsToAdd.clear();
         } // if
+                if ( ! declsToAdd.empty() ) {
+                        for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
+                                statements.insert( i, new DeclStmt( noLabels, *decl ) );
+                        } // for
+                        declsToAdd.clear();
+                } // if
+    }
     void AddStructAssignment::visit( FunctionType *) {
         // ensure that we don't add assignment ops for types defined as part of the function
+                // ensure that we don't add assignment ops for types defined as part of the function
+    }
     void AddStructAssignment::visit( PointerType *) {
         // ensure that we don't add assignment ops for types defined as part of the pointer
+                // ensure that we don't add assignment ops for types defined as part of the pointer
+    }
     void AddStructAssignment::visit( ContextDecl *) {
         // ensure that we don't add assignment ops for types defined as part of the context
+                // 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 ) {
         std::set< std::string > oldStructs = structsDone;
         addVisit( stmt, *this );
         structsDone = oldStructs;
+                std::set< std::string > oldStructs = structsDone;
+                addVisit( stmt, *this );
+                structsDone = oldStructs;
+    }
     void AddStructAssignment::visit( FunctionDecl *functionDecl ) {
         maybeAccept( functionDecl->get_functionType(), *this );
         acceptAll( functionDecl->get_oldDecls(), *this );
         functionNesting += 1;
         maybeAccept( functionDecl->get_statements(), *this );
         functionNesting -= 1;
+                maybeAccept( functionDecl->get_functionType(), *this );
+                acceptAll( functionDecl->get_oldDecls(), *this );
+                functionNesting += 1;
+                maybeAccept( functionDecl->get_statements(), *this );
+                functionNesting -= 1;
+    }
     void AddStructAssignment::visit( CompoundStmt *compoundStmt ) {
         visitStatement( compoundStmt );
+                visitStatement( compoundStmt );
+    }
     void AddStructAssignment::visit( IfStmt *ifStmt ) {
         visitStatement( ifStmt );
+                visitStatement( ifStmt );
+    }
     void AddStructAssignment::visit( WhileStmt *whileStmt ) {
         visitStatement( whileStmt );
+                visitStatement( whileStmt );
+    }
     void AddStructAssignment::visit( ForStmt *forStmt ) {
         visitStatement( forStmt );
+                visitStatement( forStmt );
+    }
     void AddStructAssignment::visit( SwitchStmt *switchStmt ) {
         visitStatement( switchStmt );
+                visitStatement( switchStmt );
+    }
     void AddStructAssignment::visit( ChooseStmt *switchStmt ) {
         visitStatement( switchStmt );
+                visitStatement( switchStmt );
+    }
     void AddStructAssignment::visit( CaseStmt *caseStmt ) {
         visitStatement( caseStmt );
+                visitStatement( caseStmt );
+    }
     void AddStructAssignment::visit( CatchStmt *cathStmt ) {
         visitStatement( cathStmt );
+                visitStatement( cathStmt );
+    }
     bool isTypedef( Declaration *decl ) {
         return dynamic_cast< TypedefDecl * >( decl );
+                return dynamic_cast< TypedefDecl * >( decl );
+    }
     void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
         EliminateTypedef eliminator;
         mutateAll( translationUnit, eliminator );
         filter( translationUnit, isTypedef, true );
+                EliminateTypedef eliminator;
+                mutateAll( translationUnit, eliminator );
+                filter( translationUnit, isTypedef, true );
+    }
     Type *EliminateTypedef::mutate( TypeInstType *typeInst ) {
         std::map< std::string, TypedefDecl * >::const_iterator def = typedefNames.find( typeInst->get_name() );
         if ( def != typedefNames.end() ) {
             Type *ret = def->second->get_base()->clone();
             ret->get_qualifiers() += typeInst->get_qualifiers();
             delete typeInst;
             return ret;
         } // if
         return typeInst;
+                std::map< std::string, TypedefDecl * >::const_iterator def = typedefNames.find( typeInst->get_name() );
+                if ( def != typedefNames.end() ) {
+                        Type *ret = def->second->get_base()->clone();
+                        ret->get_qualifiers() += typeInst->get_qualifiers();
+                        delete typeInst;
+                        return ret;
+                } // if
+                return typeInst;
+    }
     Declaration *EliminateTypedef::mutate( TypedefDecl *tyDecl ) {
         Declaration *ret = Mutator::mutate( tyDecl );
         typedefNames[ tyDecl->get_name() ] = tyDecl;
         // When a typedef is a forward declaration:
         //    typedef struct screen SCREEN;
         // the declaration portion must be retained:
         //    struct screen;
         // because the expansion of the typedef is:
         //    void rtn( SCREEN *p ) => void rtn( struct screen *p )
         // hence the type-name "screen" must be defined.
         // Note, qualifiers on the typedef are superfluous for the forward declaration.
         if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( tyDecl->get_base() ) ) {
             return new StructDecl( aggDecl->get_name() );
         } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( tyDecl->get_base() ) ) {
             return new UnionDecl( aggDecl->get_name() );
         } else {
             return ret;
         } // if
+                Declaration *ret = Mutator::mutate( tyDecl );
+                typedefNames[ tyDecl->get_name() ] = tyDecl;
+                // When a typedef is a forward declaration:
+                //    typedef struct screen SCREEN;
+                // the declaration portion must be retained:
+                //    struct screen;
+                // because the expansion of the typedef is:
+                //    void rtn( SCREEN *p ) => void rtn( struct screen *p )
+                // hence the type-name "screen" must be defined.
+                // Note, qualifiers on the typedef are superfluous for the forward declaration.
+                if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( tyDecl->get_base() ) ) {
+                        return new StructDecl( aggDecl->get_name() );
+                } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( tyDecl->get_base() ) ) {
+                        return new UnionDecl( aggDecl->get_name() );
+                } else {
+                        return ret;
+                } // if
+    }
     TypeDecl *EliminateTypedef::mutate( TypeDecl *typeDecl ) {
         std::map< std::string, TypedefDecl * >::iterator i = typedefNames.find( typeDecl->get_name() );
         if ( i != typedefNames.end() ) {
             typedefNames.erase( i ) ;
         } // if
         return typeDecl;
+                std::map< std::string, TypedefDecl * >::iterator i = typedefNames.find( typeDecl->get_name() );
+                if ( i != typedefNames.end() ) {
+                        typedefNames.erase( i ) ;
+                } // if
+                return typeDecl;
+    }
     DeclarationWithType *EliminateTypedef::mutate( FunctionDecl *funcDecl ) {
         std::map< std::string, TypedefDecl * > oldNames = typedefNames;
         DeclarationWithType *ret = Mutator::mutate( funcDecl );
         typedefNames = oldNames;
         return ret;
+                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
+                DeclarationWithType *ret = Mutator::mutate( funcDecl );
+                typedefNames = oldNames;
+                return ret;
+    }
     ObjectDecl *EliminateTypedef::mutate( ObjectDecl *objDecl ) {
         std::map< std::string, TypedefDecl * > oldNames = typedefNames;
         ObjectDecl *ret = Mutator::mutate( objDecl );
         typedefNames = oldNames;
         return ret;
+                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
+                ObjectDecl *ret = Mutator::mutate( objDecl );
+                typedefNames = oldNames;
+                return ret;
+    }
     Expression *EliminateTypedef::mutate( CastExpr *castExpr ) {
         std::map< std::string, TypedefDecl * > oldNames = typedefNames;
         Expression *ret = Mutator::mutate( castExpr );
         typedefNames = oldNames;
         return ret;
+                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
+                Expression *ret = Mutator::mutate( castExpr );
+                typedefNames = oldNames;
+                return ret;
+    }
     CompoundStmt *EliminateTypedef::mutate( CompoundStmt *compoundStmt ) {
         std::map< std::string, TypedefDecl * > oldNames = typedefNames;
         CompoundStmt *ret = Mutator::mutate( compoundStmt );
         std::list< Statement * >::iterator i = compoundStmt->get_kids().begin();
         while ( i != compoundStmt->get_kids().end() ) {
             std::list< Statement * >::iterator next = i;
             ++next;
             if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( *i ) ) {
                 if ( dynamic_cast< TypedefDecl * >( declStmt->get_decl() ) ) {
                     delete *i;
                     compoundStmt->get_kids().erase( i );
                 } // if
             } // if
             i = next;
         } // while
         typedefNames = oldNames;
         return ret;
+                std::map< std::string, TypedefDecl * > oldNames = typedefNames;
+                CompoundStmt *ret = Mutator::mutate( compoundStmt );
+                std::list< Statement * >::iterator i = compoundStmt->get_kids().begin();
+                while ( i != compoundStmt->get_kids().end() ) {
+                        std::list< Statement * >::iterator next = i;
+                        ++next;
+                        if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( *i ) ) {
+                                if ( dynamic_cast< TypedefDecl * >( declStmt->get_decl() ) ) {
+                                        delete *i;
+                                        compoundStmt->get_kids().erase( i );
+                                } // if
+                        } // if
+                        i = next;
+                } // while
+                typedefNames = oldNames;
+                return ret;
+    }
 } // namespace SymTab
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SymTab/Validate.h

-              ra32b204
+              r0dd3a2f
+// This class is intended to perform pre-processing of declarations, validating their
+// correctness and computing some auxilliary data that is necessary for the indexer.
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Validate.h -- This class is intended to perform pre-processing of declarations, validating their correctness and
+//               computing some auxilliary data that is necessary for the indexer.
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 21:53:34 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sun May 17 21:55:09 2015
+// Update Count     : 2
+//
 #ifndef SYMTAB_VALIDATE_H
 #define SYMTAB_VALIDATE_H
+#ifndef VALIDATE_H
+#define VALIDATE_H
 #include "SynTree/SynTree.h"
 …
     void validate( std::list< Declaration * > &translationUnit, bool doDebug = false );
     void validateType( Type *type, const Indexer *indexer );
 } // SymTab
+} // namespace SymTab
+#endif // SYMTAB_VALIDATE_H
+#endif // VALIDATE_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/AddressExpr.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: AddressExpr.cc,v 1.6 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// AddressExpr.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 23:54:44 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 07:48:14 2015
+// Update Count     : 5
+//
 #include "Expression.h"
 …
 #include "utility.h"
+AddressExpr::AddressExpr( Expression *arg, Expression *_aname )
+    : Expression( _aname ), arg( arg )
+{
+AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
     for ( std::list< Type* >::const_iterator i = arg->get_results().begin(); i != arg->get_results().end(); ++i ) {
         get_results().push_back( new PointerType( Type::Qualifiers(), (*i)->clone() ) );
+    }
+                get_results().push_back( new PointerType( Type::Qualifiers(), (*i)->clone() ) );
+    } // for
+}
+AddressExpr::AddressExpr( const AddressExpr &other )
+    : Expression( other ), arg( maybeClone( other.arg ) )
+{
+AddressExpr::AddressExpr( const AddressExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+}
+AddressExpr::~AddressExpr()
+{
+AddressExpr::~AddressExpr() {
     delete arg;
+}
+void
+AddressExpr::print( std::ostream &os, int indent ) const
+{
+void AddressExpr::print( std::ostream &os, int indent ) const {
     os << std::string( indent, ' ' ) << "Address of:" << std::endl;
     if ( arg ) {
         arg->print( os, indent+2 );
+    }
+                arg->print( os, indent+2 );
+    } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/AggregateDecl.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: AggregateDecl.cc,v 1.7 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// AggregateDecl.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Sun May 17 23:56:39 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 07:48:23 2015
+// Update Count     : 4
+//
 #include "Declaration.h"
 …
+AggregateDecl::AggregateDecl( const std::string &name )
+    : Parent( name, Declaration::NoStorageClass, LinkageSpec::Cforall )
+{
+AggregateDecl::AggregateDecl( const std::string &name ) : Parent( name, Declaration::NoStorageClass, LinkageSpec::Cforall ) {
+}
+AggregateDecl::AggregateDecl( const AggregateDecl &other )
+    : Parent( other )
+{
+AggregateDecl::AggregateDecl( const AggregateDecl &other ) : Parent( other ) {
     cloneAll( other.members, members );
     cloneAll( other.parameters, parameters );
+}
+AggregateDecl::~AggregateDecl()
+{
+AggregateDecl::~AggregateDecl() {
     deleteAll( members );
     deleteAll( parameters );
+}
+void
+AggregateDecl::print( std::ostream &os, int indent ) const
+{
+void AggregateDecl::print( std::ostream &os, int indent ) const {
     using std::string;
     using std::endl;
 …
     os << typeString() << " " << get_name();
     if ( ! parameters.empty() ) {
         os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
         printAll( parameters, os, indent+4 );
+    }
+                os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
+                printAll( parameters, os, indent+4 );
+    } // if
     if ( ! members.empty() ) {
         os << endl << string( indent+2, ' ' ) << "with members" << endl;
         printAll( members, os, indent+4 );
+    }
+                os << endl << string( indent+2, ' ' ) << "with members" << endl;
+                printAll( members, os, indent+4 );
+    } // if
+}
+void
+AggregateDecl::printShort( std::ostream &os, int indent ) const
+{
+void AggregateDecl::printShort( std::ostream &os, int indent ) const {
     using std::string;
     using std::endl;
 …
     os << typeString() << " " << get_name();
     if ( ! parameters.empty() ) {
         os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
         printAll( parameters, os, indent+4 );
+    }
+                os << endl << string( indent+2, ' ' ) << "with parameters" << endl;
+                printAll( parameters, os, indent+4 );
+    } // if
+}
 …
 std::string ContextDecl::typeString() const { return "context"; }
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/ApplicationExpr.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// ApplicationExpr.cc.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 07:54:17 2015
+// Update Count     : 4
+//
 #include <cassert>
 …
+ParamEntry::ParamEntry( const ParamEntry &other )
+    : decl( other.decl ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) )
+{
+ParamEntry::ParamEntry( const ParamEntry &other ) :
+                decl( other.decl ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) ) {
+}
+ParamEntry &
+ParamEntry::operator=( const ParamEntry &other )
+{
+    if ( &other == this ) return *this;
+    decl = other.decl;
+    actualType = maybeClone( other.actualType );
+    formalType = maybeClone( other.formalType );
+    expr = maybeClone( other.expr );
+    return *this;
+ParamEntry &ParamEntry::operator=( const ParamEntry &other ) {
+        if ( &other == this ) return *this;
+        decl = other.decl;
+        actualType = maybeClone( other.actualType );
+        formalType = maybeClone( other.formalType );
+        expr = maybeClone( other.expr );
+        return *this;
+}
+ParamEntry::~ParamEntry()
+{
+    delete actualType;
+    delete formalType;
+    delete expr;
+ParamEntry::~ParamEntry() {
+        delete actualType;
+        delete formalType;
+        delete expr;
+}
+ApplicationExpr::ApplicationExpr( Expression *funcExpr )
+    : function( funcExpr )
+{
+    PointerType *pointer = dynamic_cast< PointerType* >( funcExpr->get_results().front() );
+    assert( pointer );
+    FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+    assert( function );
+    for ( std::list< DeclarationWithType* >::const_iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
+        get_results().push_back( (*i)->get_type()->clone() );
+    }
+ApplicationExpr::ApplicationExpr( Expression *funcExpr ) : function( funcExpr ) {
+        PointerType *pointer = dynamic_cast< PointerType* >( funcExpr->get_results().front() );
+        assert( pointer );
+        FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
+        assert( function );
+        for ( std::list< DeclarationWithType* >::const_iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
+                get_results().push_back( (*i)->get_type()->clone() );
+        } // for
+}
+ApplicationExpr::ApplicationExpr( const ApplicationExpr &other )
+    : Expression( other ), function( maybeClone( other.function ) ), inferParams( other.inferParams )
+{
+    cloneAll( other.args, args );
+ApplicationExpr::ApplicationExpr( const ApplicationExpr &other ) :
+                Expression( other ), function( maybeClone( other.function ) ), inferParams( other.inferParams ) {
+        cloneAll( other.args, args );
+}
+ApplicationExpr::~ApplicationExpr()
+{
+    delete function;
+    deleteAll( args );
+ApplicationExpr::~ApplicationExpr() {
+        delete function;
+        deleteAll( args );
+}
+void
+ApplicationExpr::print( std::ostream &os, int indent ) const
+{
+    os << std::string( indent, ' ' ) << "Application of" << std::endl;
+    function->print( os, indent+2 );
+    if ( ! args.empty() ) {
+        os << std::string( indent, ' ' ) << "to arguments" << std::endl;
+        printAll( args, os, indent+2 );
+    }
+    if ( ! inferParams.empty() ) {
+        os << std::string(indent, ' ') << "with inferred parameters:" << std::endl;
+        for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
+            os << std::string(indent+2, ' ');
+            Declaration::declFromId( i->second.decl )->printShort( os, indent+2 );
+            os << std::endl;
+        }
+    }
+    Expression::print( os, indent );
+void ApplicationExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Application of" << std::endl;
+        function->print( os, indent+2 );
+        if ( ! args.empty() ) {
+                os << std::string( indent, ' ' ) << "to arguments" << std::endl;
+                printAll( args, os, indent+2 );
+        } // if
+        if ( ! inferParams.empty() ) {
+                os << std::string(indent, ' ') << "with inferred parameters:" << std::endl;
+                for ( InferredParams::const_iterator i = inferParams.begin(); i != inferParams.end(); ++i ) {
+                        os << std::string(indent+2, ' ');
+                        Declaration::declFromId( i->second.decl )->printShort( os, indent+2 );
+                        os << std::endl;
+                } // for
+        } // if
+        Expression::print( os, indent );
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/ArrayType.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: ArrayType.cc,v 1.6 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// ArrayType.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 07:52:08 2015
+// Update Count     : 2
+//
 #include "Type.h"
 …
 ArrayType::ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic )
+    : Type( tq ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic )
+{
+    base->set_isLvalue( false );
+                : Type( tq ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
+        base->set_isLvalue( false );
+}
 ArrayType::ArrayType( const ArrayType &other )
+    : Type( other ), base( maybeClone( other.base ) ), dimension( maybeClone( other.dimension ) ),
+        isVarLen( other.isVarLen ), isStatic( other.isStatic )
+{
+        : Type( other ), base( maybeClone( other.base ) ), dimension( maybeClone( other.dimension ) ),
+          isVarLen( other.isVarLen ), isStatic( other.isStatic ) {
+}
+ArrayType::~ArrayType()
+{
+    delete base;
+    delete dimension;
+ArrayType::~ArrayType() {
+        delete base;
+        delete dimension;
+}
+void
+ArrayType::print( std::ostream &os, int indent ) const
+{
+    Type::print( os, indent );
+    if ( isStatic ) {
+        os << "static ";
+    }
+    if ( isVarLen ) {
+        os << "variable length array of ";
+    } else if ( dimension ) {
+        os << "array of ";
+        dimension->print( os, indent );
+    } else {
+        os << "open array of ";
+    }
+    if ( base ) {
+        base->print( os, indent );
+    }
+void ArrayType::print( std::ostream &os, int indent ) const {
+        Type::print( os, indent );
+        if ( isStatic ) {
+                os << "static ";
+        } // if
+        if ( isVarLen ) {
+                os << "variable length array of ";
+        } else if ( dimension ) {
+                os << "array of ";
+                dimension->print( os, indent );
+        } else {
+                os << "open array of ";
+        } // if
+        if ( base ) {
+                base->print( os, indent );
+        } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/AttrType.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: AttrType.cc,v 1.3 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// XXX.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 07:53:48 2015
+// Update Count     : 1
+//
 #include "Type.h"
 …
 AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr )
+    : Type( tq ), name( name ), expr( expr ), type( 0 ), isType( false )
+{
+        : Type( tq ), name( name ), expr( expr ), type( 0 ), isType( false ) {
+}
 AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type )
+    : Type( tq ), name( name ), expr( 0 ), type( type ), isType( true )
+{
+        : Type( tq ), name( name ), expr( 0 ), type( type ), isType( true ) {
+}
 AttrType::AttrType( const AttrType &other )
+    : Type( other ), name( other.name ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType )
+{
+        : Type( other ), name( other.name ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
+}
+AttrType::~AttrType()
+{
+    delete expr;
+    delete type;
+AttrType::~AttrType() {
+        delete expr;
+        delete type;
+}
+void
+AttrType::print( std::ostream &os, int indent ) const
+{
+    Type::print( os, indent );
+    os << "attribute " << name << " applied to ";
+    if ( expr ) {
+        os << "expression ";
+        expr->print( os, indent );
+    }
+    if ( type ) {
+        os << "type ";
+        type->print( os, indent );
+    }
+void AttrType::print( std::ostream &os, int indent ) const {
+        Type::print( os, indent );
+        os << "attribute " << name << " applied to ";
+        if ( expr ) {
+                os << "expression ";
+                expr->print( os, indent );
+        } // if
+        if ( type ) {
+                os << "type ";
+                type->print( os, indent );
+        } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/BasicType.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// BasicType.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 07:55:16 2015
+// Update Count     : 1
+//
 #include <cassert>
 #include "Type.h"
 BasicType::BasicType( const Type::Qualifiers &tq, Kind bt ) : Type( tq ), kind( bt ) {}
 void BasicType::print( std::ostream &os, int indent ) const {
     static const char *kindNames[] = {
         "_Bool", "char", "signed char", "unsigned char", "short signed int", "short unsigned int",
         "signed int", "unsigned int", "long signed int", "long unsigned int", "long long signed int",
         "long long unsigned int", "float", "double", "long double", "float _Complex", "double _Complex",
         "long double _Complex", "float _Imaginary", "double _Imaginary", "long double _Imaginary"
     };
+        static const char *kindNames[] = {
+                "_Bool", "char", "signed char", "unsigned char", "short signed int", "short unsigned int",
+                "signed int", "unsigned int", "long signed int", "long unsigned int", "long long signed int",
+                "long long unsigned int", "float", "double", "long double", "float _Complex", "double _Complex",
+                "long double _Complex", "float _Imaginary", "double _Imaginary", "long double _Imaginary"
+        };
     Type::print( os, indent );
     os << kindNames[ kind ] << ' ';
+        Type::print( os, indent );
+        os << kindNames[ kind ] << ' ';
+}
 bool BasicType::isInteger() const {
+    switch ( kind ) {
+      case Bool:
+      case Char:
+      case SignedChar:
+      case UnsignedChar:
+      case ShortSignedInt:
+      case ShortUnsignedInt:
+      case SignedInt:
+      case UnsignedInt:
+      case LongSignedInt:
+      case LongUnsignedInt:
+      case LongLongSignedInt:
+      case LongLongUnsignedInt:
+        return true;
+      case Float:
+      case Double:
+      case LongDouble:
+      case FloatComplex:
+      case DoubleComplex:
+      case LongDoubleComplex:
+      case FloatImaginary:
+      case DoubleImaginary:
+      case LongDoubleImaginary:
+        switch ( kind ) {
+          case Bool:
+          case Char:
+          case SignedChar:
+          case UnsignedChar:
+          case ShortSignedInt:
+          case ShortUnsignedInt:
+          case SignedInt:
+          case UnsignedInt:
+          case LongSignedInt:
+          case LongUnsignedInt:
+          case LongLongSignedInt:
+          case LongLongUnsignedInt:
+                return true;
+          case Float:
+          case Double:
+          case LongDouble:
+          case FloatComplex:
+          case DoubleComplex:
+          case LongDoubleComplex:
+          case FloatImaginary:
+          case DoubleImaginary:
+          case LongDoubleImaginary:
+                return false;
+          case NUMBER_OF_BASIC_TYPES:
+                assert( false );
+        } // switch
+        assert( false );
         return false;
-      case NUMBER_OF_BASIC_TYPES:
-        assert( false );
+    }
-    assert( false );
-    return false;
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/CodeGenVisitor.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// CodeGenVisitor.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 07:57:51 2015
+// Update Count     : 3
+//
 #include <iostream>
 #include <list>
 …
 using namespace std;
+//*** Types
+void CodeGenVisitor::visit(Type *type){ }
+void CodeGenVisitor::visit(BasicType *basicType) { }
+void CodeGenVisitor::visit( Type *type ){ }
+void CodeGenVisitor::visit( BasicType *basicType ) { }
+//*** Constant
+void CodeGenVisitor::visit(Constant *constant) {
+    cout << constant->get_value() << endl;
+void CodeGenVisitor::visit( Constant *constant ) {
+        cout << constant->get_value() << endl;
+}
+//*** Expressions
+void CodeGenVisitor::visit(Expression *expr){ }
+void CodeGenVisitor::visit( Expression *expr ){ }
 void CodeGenVisitor::visit(ConstantExpr *cnst){
     if (cnst != 0)
         visit(cnst->get_constant());
+void CodeGenVisitor::visit( ConstantExpr *cnst ) {
+        if ( cnst != 0 )
+                visit(cnst->get_constant());
+}
+//*** Statements
+void CodeGenVisitor::visit(Statement *stmt){ }
+void CodeGenVisitor::visit( Statement *stmt ) { }
 void CodeGenVisitor::visit(ExprStmt *exprStmt){
     if (exprStmt != 0)
         exprStmt->get_expr()->accept(*this);    // visit(exprStmt->get_expr()) doesn't work
+void CodeGenVisitor::visit( ExprStmt *exprStmt ) {
+        if ( exprStmt != 0 )
+                exprStmt->get_expr()->accept( *this );                  // visit(exprStmt->get_expr()) doesn't work
+}
 void CodeGenVisitor::visit(SwitchStmt *switchStmt){
     cout << "switch (" << endl;
     // visit(switchStmt->get_condition());   // why doesn't this work?
     switchStmt->get_condition()->accept(*this);
+void CodeGenVisitor::visit( SwitchStmt *switchStmt ) {
+        cout << "switch (" << endl;
+        // visit(switchStmt->get_condition());   // why doesn't this work?
+        switchStmt->get_condition()->accept(*this);
     cout << ") {" << endl;
     // visit(switchStmt->get_body());  // why doesn't this work?
     cout << "}" << endl;
+        cout << ") {" << endl;
+        // visit(switchStmt->get_body());  // why doesn't this work?
+        cout << "}" << endl;
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/CodeGenVisitor.h

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// CodeGenVisitor.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:46:47 2015
+// Update Count     : 4
+//
 #ifndef CODEGENV_H
 #define CODEGENV_H
 …
 #include "Visitor.h"
+class CodeGenVisitor : public Visitor {
+  public:
+        virtual void visit( Type * );
+        virtual void visit( BasicType * );
+class CodeGenVisitor : public Visitor {
+public:
+    //*** Types
+    virtual void visit(Type *);
+    virtual void visit(BasicType *);
+        virtual void visit( Constant * );
+    //*** Constant
     virtual void visit(Constant *);
+        virtual void visit( Expression * );
+        virtual void visit( ConstantExpr * );
+    //*** Expressions
+    virtual void visit(Expression *);
+    virtual void visit(ConstantExpr *);
+    //*** Statements
+    virtual void visit(Statement *);
+    virtual void visit(ExprStmt *);
+    virtual void visit(SwitchStmt *);
+        virtual void visit( Statement * );
+        virtual void visit( ExprStmt * );
+        virtual void visit( SwitchStmt * );
 };
+#endif // CODEGENV_H
+#endif /* #ifndef CODEGENV_H */
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/CommaExpr.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: CommaExpr.cc,v 1.7 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// CommaExpr.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:09:58 2015
+// Update Count     : 1
+//
 #include "Expression.h"
 …
 #include "utility.h"
 CommaExpr::CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname )
+    : Expression( _aname ), arg1( arg1 ), arg2( arg2 )
+{
+    cloneAll( arg2->get_results(), get_results() );
+                : Expression( _aname ), arg1( arg1 ), arg2( arg2 ) {
+        cloneAll( arg2->get_results(), get_results() );
+}
 CommaExpr::CommaExpr( const CommaExpr &other )
+    : Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) )
+{
+                : Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ) {
+}
+CommaExpr::~CommaExpr()
+{
+    delete arg1;
+    delete arg2;
+CommaExpr::~CommaExpr() {
+        delete arg1;
+        delete arg2;
+}
+void
+CommaExpr::print( std::ostream &os, int indent ) const
+{
+    os << std::string( indent, ' ' ) << "Comma Expression:" << std::endl;
+    arg1->print( os, indent+2 );
+    os << std::endl;
+    arg2->print( os, indent+2 );
+    Expression::print( os, indent );
+void CommaExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Comma Expression:" << std::endl;
+        arg1->print( os, indent+2 );
+        os << std::endl;
+        arg2->print( os, indent+2 );
+        Expression::print( os, indent );
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/CompoundStmt.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: CompoundStmt.cc,v 1.4 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// XXX.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:11:02 2015
+// Update Count     : 1
+//
 #include "Statement.h"
 …
 CompoundStmt::CompoundStmt( const CompoundStmt &other ) : Statement( other ) {
     cloneAll( other.kids, kids );
+        cloneAll( other.kids, kids );
+}
 CompoundStmt::~CompoundStmt() {
     deleteAll( kids );
+        deleteAll( kids );
+}
 void CompoundStmt::print( std::ostream &os, int indent ) {
     os << "\r" << string(indent, ' ') << "CompoundStmt" << endl ;
     printAll( kids, os, indent+2 );
+        os << "\r" << string(indent, ' ') << "CompoundStmt" << endl ;
+        printAll( kids, os, indent+2 );
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Constant.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Constant.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:13:25 2015
+// Update Count     : 1
+//
 #include <iostream>
 #include <list>
 …
 #include "Type.h"
+Constant::Constant(Type *_type, std::string _value):
+    type(_type), value(_value) {}
+Constant::Constant( Type *_type, std::string _value ) : type(_type), value(_value) {}
 Constant::~Constant() {}
 …
 void Constant::print( std::ostream &os ) const {
     os << value;
     if ( type ) {
         os << " (type: ";
         type->print( os );
         os << ")";
+    }
+        os << value;
+        if ( type ) {
+                os << " (type: ";
+                type->print( os );
+                os << ")";
+        } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Constant.h

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: Constant.h,v 1.6 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Constant.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:46:37 2015
+// Update Count     : 2
+//
 #ifndef CONSTANT_H
 …
 #include "Mutator.h"
+class Constant {
+  public:
+        Constant( Type *type, std::string value );
+        virtual ~Constant();
+class Constant
+{
+public:
+    Constant( Type *type, std::string value );
+    virtual ~Constant();
+        Type *get_type() { return type; }
+        void set_type( Type *newValue ) { type = newValue; }
+        std::string get_value() { return value; }
+        void set_value( std::string newValue ) { value = newValue; }
+    Type *get_type() { return type; }
+    void set_type( Type *newValue ) { type = newValue; }
+    std::string get_value() { return value; }
+    void set_value( std::string newValue ) { value = newValue; }
+    virtual Constant *clone() const;
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Constant *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os ) const;
+private:
+    Type *type;
+    std::string value;
+        virtual Constant *clone() const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Constant *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os ) const;
+  private:
+        Type *type;
+        std::string value;
 };
+#endif // CONSTANT_H
+#endif /* #ifndef CONSTANT_H */
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/DeclStmt.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: DeclStmt.cc,v 1.4 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// DeclStmt.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:16:03 2015
+// Update Count     : 2
+//
 #include "Statement.h"
 …
 #include "utility.h"
+DeclStmt::DeclStmt( std::list<Label> labels, Declaration *decl )
+    : Statement( labels ), decl( decl )
+{
+DeclStmt::DeclStmt( std::list<Label> labels, Declaration *decl ) : Statement( labels ), decl( decl ) {
+}
+DeclStmt::DeclStmt( const DeclStmt &other )
+    : Statement( other ), decl( maybeClone( other.decl ) )
+{
+DeclStmt::DeclStmt( const DeclStmt &other ) : Statement( other ), decl( maybeClone( other.decl ) ) {
+}
+DeclStmt::~DeclStmt()
+{
+    delete decl;
+DeclStmt::~DeclStmt() {
+        delete decl;
+}
+void
+DeclStmt::print( std::ostream &os, int indent )
+{
+    os << "Declaration of ";
+    if ( decl ) {
+        decl->print( os, indent );
+    }
+void DeclStmt::print( std::ostream &os, int indent ) {
+        os << "Declaration of ";
+        if ( decl ) {
+                decl->print( os, indent );
+        } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Declaration.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: Declaration.cc,v 1.8 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Declaration.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:18:35 2015
+// Update Count     : 2
+//
 #include <string>
 …
 #include "utility.h"
 const char* Declaration::storageClassName[] = { "", "auto", "static", "extern", "register" };
 …
 Declaration::Declaration( const std::string &name, StorageClass sc, LinkageSpec::Type linkage )
+    : name( name ), storageClass( sc ), linkage( linkage ), uniqueId( 0 )
+{
+        : name( name ), storageClass( sc ), linkage( linkage ), uniqueId( 0 ) {
+}
 Declaration::Declaration( const Declaration &other )
+    : name( other.name ), storageClass( other.storageClass ), linkage( other.linkage ), uniqueId( other.uniqueId )
+{
+        : name( other.name ), storageClass( other.storageClass ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
+}
+Declaration::~Declaration()
+{
+Declaration::~Declaration() {
+}
+void
+Declaration::fixUniqueId()
+{
+    uniqueId = ++lastUniqueId;
+    idMap[ uniqueId ] = this;
+void Declaration::fixUniqueId() {
+        uniqueId = ++lastUniqueId;
+        idMap[ uniqueId ] = this;
+}
 /* static class method */
+Declaration *
+Declaration::declFromId( UniqueId id )
+{
+    IdMapType::const_iterator i = idMap.find( id );
+    if ( i != idMap.end() ) {
+        return i->second;
+    } else {
+        return 0;
+    }
+Declaration *Declaration::declFromId( UniqueId id ) {
+        IdMapType::const_iterator i = idMap.find( id );
+        if ( i != idMap.end() ) {
+                return i->second;
+        } else {
+                return 0;
+        } // if
+}
 /* static class method */
+void
+Declaration::dumpIds( std::ostream &os )
+{
+    for ( IdMapType::const_iterator i = idMap.begin(); i != idMap.end(); ++i ) {
+        os << i->first << " -> ";
+        i->second->printShort( os );
+        os << std::endl;
+    }
+void Declaration::dumpIds( std::ostream &os ) {
+        for ( IdMapType::const_iterator i = idMap.begin(); i != idMap.end(); ++i ) {
+                os << i->first << " -> ";
+                i->second->printShort( os );
+                os << std::endl;
+        } // for
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Declaration.h

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Declaration.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:46:25 2015
+// Update Count     : 2
+//
 #ifndef DECLARATION_H
 #define DECLARATION_H
 …
 #include "Parser/LinkageSpec.h"
 class Declaration {
   public:
     enum StorageClass {
         NoStorageClass,
         Extern,
         Static,
         Auto,
         Register,
         Inline,
         Fortran,
     };
     Declaration( const std::string &name, StorageClass sc, LinkageSpec::Type linkage );
     Declaration( const Declaration &other );
     virtual ~Declaration();
     std::string get_name() const { return name; }
     void set_name( std::string newValue ) { name = newValue; }
     StorageClass get_storageClass() const { return storageClass; }
     void set_storageClass( StorageClass newValue ) { storageClass = newValue; }
     LinkageSpec::Type get_linkage() const { return linkage; }
     void set_linkage( LinkageSpec::Type newValue ) { linkage = newValue; }
     UniqueId get_uniqueId() const { return uniqueId; }
     void fixUniqueId( void );
     virtual Declaration *clone() const = 0;
     virtual void accept( Visitor &v ) = 0;
     virtual Declaration *acceptMutator( Mutator &m ) = 0;
     virtual void print( std::ostream &os, int indent = 0 ) const = 0;
     virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
     static const char* storageClassName[];
     static void dumpIds( std::ostream &os );
     static Declaration *declFromId( UniqueId id );
   private:
     std::string name;
     StorageClass storageClass;
     LinkageSpec::Type linkage;
     UniqueId uniqueId;
+        enum StorageClass {
+                NoStorageClass,
+                Extern,
+                Static,
+                Auto,
+                Register,
+                Inline,
+                Fortran,
+        };
+        Declaration( const std::string &name, StorageClass sc, LinkageSpec::Type linkage );
+        Declaration( const Declaration &other );
+        virtual ~Declaration();
+        std::string get_name() const { return name; }
+        void set_name( std::string newValue ) { name = newValue; }
+        StorageClass get_storageClass() const { return storageClass; }
+        void set_storageClass( StorageClass newValue ) { storageClass = newValue; }
+        LinkageSpec::Type get_linkage() const { return linkage; }
+        void set_linkage( LinkageSpec::Type newValue ) { linkage = newValue; }
+        UniqueId get_uniqueId() const { return uniqueId; }
+        void fixUniqueId( void );
+        virtual Declaration *clone() const = 0;
+        virtual void accept( Visitor &v ) = 0;
+        virtual Declaration *acceptMutator( Mutator &m ) = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const = 0;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const = 0;
+        static const char* storageClassName[];
+        static void dumpIds( std::ostream &os );
+        static Declaration *declFromId( UniqueId id );
+  private:
+        std::string name;
+        StorageClass storageClass;
+        LinkageSpec::Type linkage;
+        UniqueId uniqueId;
 };
 class DeclarationWithType : public Declaration {
   public:
     DeclarationWithType( const std::string &name, StorageClass sc, LinkageSpec::Type linkage );
     DeclarationWithType( const DeclarationWithType &other );
     virtual ~DeclarationWithType();
     std::string get_mangleName() const { return mangleName; }
     void set_mangleName( std::string newValue ) { mangleName = newValue; }
     virtual DeclarationWithType *clone() const = 0;
     virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
     virtual Type *get_type() const = 0;
     virtual void set_type(Type *) = 0;
   private:
     // this represents the type with all types and typedefs expanded it is generated by SymTab::Validate::Pass2
     std::string mangleName;
+        DeclarationWithType( const std::string &name, StorageClass sc, LinkageSpec::Type linkage );
+        DeclarationWithType( const DeclarationWithType &other );
+        virtual ~DeclarationWithType();
+        std::string get_mangleName() const { return mangleName; }
+        void set_mangleName( std::string newValue ) { mangleName = newValue; }
+        virtual DeclarationWithType *clone() const = 0;
+        virtual DeclarationWithType *acceptMutator( Mutator &m ) = 0;
+        virtual Type *get_type() const = 0;
+        virtual void set_type(Type *) = 0;
+  private:
+        // this represents the type with all types and typedefs expanded it is generated by SymTab::Validate::Pass2
+        std::string mangleName;
 };
 class ObjectDecl : public DeclarationWithType {
     typedef DeclarationWithType Parent;
   public:
     ObjectDecl( const std::string &name, StorageClass sc, LinkageSpec::Type linkage, Expression *bitfieldWidth, Type *type, Initializer *init );
     ObjectDecl( const ObjectDecl &other );
     virtual ~ObjectDecl();
     virtual Type *get_type() const { return type; }
     virtual void set_type(Type *newType) { type = newType; }
     Initializer *get_init() const { return init; }
     void set_init( Initializer *newValue ) { init = newValue; }
     Expression *get_bitfieldWidth() const { return bitfieldWidth; }
     void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; }
     virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual ObjectDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 ) const;
     virtual void printShort( std::ostream &os, int indent = 0 ) const;
   private:
     Type *type;
     Initializer *init;
     Expression *bitfieldWidth;
+        typedef DeclarationWithType Parent;
+  public:
+        ObjectDecl( const std::string &name, StorageClass sc, LinkageSpec::Type linkage, Expression *bitfieldWidth, Type *type, Initializer *init );
+        ObjectDecl( const ObjectDecl &other );
+        virtual ~ObjectDecl();
+        virtual Type *get_type() const { return type; }
+        virtual void set_type(Type *newType) { type = newType; }
+        Initializer *get_init() const { return init; }
+        void set_init( Initializer *newValue ) { init = newValue; }
+        Expression *get_bitfieldWidth() const { return bitfieldWidth; }
+        void set_bitfieldWidth( Expression *newValue ) { bitfieldWidth = newValue; }
+        virtual ObjectDecl *clone() const { return new ObjectDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual ObjectDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+  private:
+        Type *type;
+        Initializer *init;
+        Expression *bitfieldWidth;
 };
 class FunctionDecl : public DeclarationWithType {
     typedef DeclarationWithType Parent;
   public:
     FunctionDecl( const std::string &name, StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline );
     FunctionDecl( const FunctionDecl &other );
     virtual ~FunctionDecl();
     Type *get_type() const;
     virtual void set_type(Type *);
     FunctionType *get_functionType() const { return type; }
     void set_functionType( FunctionType *newValue ) { type = newValue; }
     CompoundStmt *get_statements() const { return statements; }
     void set_statements( CompoundStmt *newValue ) { statements = newValue; }
+        typedef DeclarationWithType Parent;
+  public:
+        FunctionDecl( const std::string &name, StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline );
+        FunctionDecl( const FunctionDecl &other );
+        virtual ~FunctionDecl();
+        Type *get_type() const;
+        virtual void set_type(Type *);
+        FunctionType *get_functionType() const { return type; }
+        void set_functionType( FunctionType *newValue ) { type = newValue; }
+        CompoundStmt *get_statements() const { return statements; }
+        void set_statements( CompoundStmt *newValue ) { statements = newValue; }
 //    bool get_isInline() const { return isInline; }
 //    void set_isInline( bool newValue ) { isInline = newValue; }
     std::list< std::string >& get_oldIdents() { return oldIdents; }
     std::list< Declaration* >& get_oldDecls() { return oldDecls; }
     virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 ) const;
     virtual void printShort( std::ostream &os, int indent = 0 ) const;
   private:
     FunctionType *type;
     CompoundStmt *statements;
     bool isInline;
     std::list< std::string > oldIdents;
     std::list< Declaration* > oldDecls;
+        std::list< std::string >& get_oldIdents() { return oldIdents; }
+        std::list< Declaration* >& get_oldDecls() { return oldDecls; }
+        virtual FunctionDecl *clone() const { return new FunctionDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual DeclarationWithType *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
+  private:
+        FunctionType *type;
+        CompoundStmt *statements;
+        bool isInline;
+        std::list< std::string > oldIdents;
+        std::list< Declaration* > oldDecls;
 };
 class NamedTypeDecl : public Declaration {
     typedef Declaration Parent;
   public:
     NamedTypeDecl( const std::string &name, StorageClass sc, Type *type );
     NamedTypeDecl( const TypeDecl &other );
     virtual ~NamedTypeDecl();
     Type *get_base() const { return base; }
     void set_base( Type *newValue ) { base = newValue; }
     std::list< TypeDecl* >& get_parameters() { return parameters; }
     std::list< DeclarationWithType* >& get_assertions() { return assertions; }
     virtual NamedTypeDecl *clone() const = 0;
     virtual void print( std::ostream &os, int indent = 0 ) const;
     virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        typedef Declaration Parent;
+  public:
+        NamedTypeDecl( const std::string &name, StorageClass sc, Type *type );
+        NamedTypeDecl( const TypeDecl &other );
+        virtual ~NamedTypeDecl();
+        Type *get_base() const { return base; }
+        void set_base( Type *newValue ) { base = newValue; }
+        std::list< TypeDecl* >& get_parameters() { return parameters; }
+        std::list< DeclarationWithType* >& get_assertions() { return assertions; }
+        virtual NamedTypeDecl *clone() const = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
   protected:
     virtual std::string typeString() const = 0;
   private:
     Type *base;
     std::list< TypeDecl* > parameters;
     std::list< DeclarationWithType* > assertions;
+        virtual std::string typeString() const = 0;
+  private:
+        Type *base;
+        std::list< TypeDecl* > parameters;
+        std::list< DeclarationWithType* > assertions;
 };
 class TypeDecl : public NamedTypeDecl {
     typedef NamedTypeDecl Parent;
   public:
     enum Kind { Any, Dtype, Ftype };
     TypeDecl( const std::string &name, StorageClass sc, Type *type, Kind kind );
     TypeDecl( const TypeDecl &other );
     Kind get_kind() const { return kind; }
     virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual TypeDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
     virtual std::string typeString() const;
     Kind kind;
+        typedef NamedTypeDecl Parent;
+  public:
+        enum Kind { Any, Dtype, Ftype };
+        TypeDecl( const std::string &name, StorageClass sc, Type *type, Kind kind );
+        TypeDecl( const TypeDecl &other );
+        Kind get_kind() const { return kind; }
+        virtual TypeDecl *clone() const { return new TypeDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual TypeDecl *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
+        Kind kind;
 };
 class TypedefDecl : public NamedTypeDecl {
     typedef NamedTypeDecl Parent;
   public:
     TypedefDecl( const std::string &name, StorageClass sc, Type *type ) : Parent( name, sc, type ) {}
     TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
     virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
     virtual std::string typeString() const;
+        typedef NamedTypeDecl Parent;
+  public:
+        TypedefDecl( const std::string &name, StorageClass sc, Type *type ) : Parent( name, sc, type ) {}
+        TypedefDecl( const TypedefDecl &other ) : Parent( other ) {}
+        virtual TypedefDecl *clone() const { return new TypedefDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
 };
 class AggregateDecl : public Declaration {
     typedef Declaration Parent;
   public:
     AggregateDecl( const std::string &name );
     AggregateDecl( const AggregateDecl &other );
     virtual ~AggregateDecl();
     std::list<Declaration*>& get_members() { return members; }
     std::list<TypeDecl*>& get_parameters() { return parameters; }
     virtual void print( std::ostream &os, int indent = 0 ) const;
     virtual void printShort( std::ostream &os, int indent = 0 ) const;
+        typedef Declaration Parent;
+  public:
+        AggregateDecl( const std::string &name );
+        AggregateDecl( const AggregateDecl &other );
+        virtual ~AggregateDecl();
+        std::list<Declaration*>& get_members() { return members; }
+        std::list<TypeDecl*>& get_parameters() { return parameters; }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printShort( std::ostream &os, int indent = 0 ) const;
   protected:
     virtual std::string typeString() const = 0;
   private:
     std::list<Declaration*> members;
     std::list<TypeDecl*> parameters;
+        virtual std::string typeString() const = 0;
+  private:
+        std::list<Declaration*> members;
+        std::list<TypeDecl*> parameters;
 };
 class StructDecl : public AggregateDecl {
     typedef AggregateDecl Parent;
   public:
     StructDecl( const std::string &name ) : Parent( name ) {}
     StructDecl( const StructDecl &other ) : Parent( other ) {}
     virtual StructDecl *clone() const { return new StructDecl( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
     virtual std::string typeString() const;
+        typedef AggregateDecl Parent;
+  public:
+        StructDecl( const std::string &name ) : Parent( name ) {}
+        StructDecl( const StructDecl &other ) : Parent( other ) {}
+        virtual StructDecl *clone() const { return new StructDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
 };
 class UnionDecl : public AggregateDecl {
     typedef AggregateDecl Parent;
   public:
     UnionDecl( const std::string &name ) : Parent( name ) {}
     UnionDecl( const UnionDecl &other ) : Parent( other ) {}
     virtual UnionDecl *clone() const { return new UnionDecl( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
     virtual std::string typeString() const;
+        typedef AggregateDecl Parent;
+  public:
+        UnionDecl( const std::string &name ) : Parent( name ) {}
+        UnionDecl( const UnionDecl &other ) : Parent( other ) {}
+        virtual UnionDecl *clone() const { return new UnionDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
 };
 class EnumDecl : public AggregateDecl {
     typedef AggregateDecl Parent;
   public:
     EnumDecl( const std::string &name ) : Parent( name ) {}
     EnumDecl( const EnumDecl &other ) : Parent( other ) {}
     virtual EnumDecl *clone() const { return new EnumDecl( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
     virtual std::string typeString() const;
+        typedef AggregateDecl Parent;
+  public:
+        EnumDecl( const std::string &name ) : Parent( name ) {}
+        EnumDecl( const EnumDecl &other ) : Parent( other ) {}
+        virtual EnumDecl *clone() const { return new EnumDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
 };
 class ContextDecl : public AggregateDecl {
     typedef AggregateDecl Parent;
   public:
     ContextDecl( const std::string &name ) : Parent( name ) {}
     ContextDecl( const ContextDecl &other ) : Parent( other ) {}
     virtual ContextDecl *clone() const { return new ContextDecl( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
     virtual std::string typeString() const;
+        typedef AggregateDecl Parent;
+  public:
+        ContextDecl( const std::string &name ) : Parent( name ) {}
+        ContextDecl( const ContextDecl &other ) : Parent( other ) {}
+        virtual ContextDecl *clone() const { return new ContextDecl( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Declaration *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
 };
 #endif // DECLARATION_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/DeclarationWithType.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: DeclarationWithType.cc,v 1.9 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// DeclarationWithType.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:20:23 2015
+// Update Count     : 2
+//
 #include "Declaration.h"
 …
 #include "utility.h"
 DeclarationWithType::DeclarationWithType( const std::string &name, StorageClass sc, LinkageSpec::Type linkage )
+    : Declaration( name, sc, linkage )
+{
+                : Declaration( name, sc, linkage ) {
+}
 DeclarationWithType::DeclarationWithType( const DeclarationWithType &other )
+    : Declaration( other ), mangleName( other.mangleName )
+{
+                : Declaration( other ), mangleName( other.mangleName ) {
+}
+DeclarationWithType::~DeclarationWithType()
+{
+DeclarationWithType::~DeclarationWithType() {
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Expression.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Expression.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:27:07 2015
+// Update Count     : 2
+//
 #include <iostream>
 #include <cassert>
 …
-//*** Expression
 Expression::Expression( Expression *_aname ) : env( 0 ), argName( _aname ) {}
+Expression::Expression( const Expression &other )
+    : env( maybeClone( other.env ) )
+ {
+     cloneAll( other.results, results );
+     argName = other.get_argName();
+ }
+Expression::~Expression()
+{
+    delete env;
+    // delete argName;  // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
+    deleteAll( results );
+}
+void
+Expression::add_result( Type *t )
+{
+    if ( TupleType *tuple = dynamic_cast< TupleType* >( t ) ) {
+        std::copy( tuple->get_types().begin(), tuple->get_types().end(), back_inserter( results ) );
+    } else {
+        results.push_back(t);
+    }
+Expression::Expression( const Expression &other ) : env( maybeClone( other.env ) ) {
+        cloneAll( other.results, results );
+        argName = other.get_argName();
+}
+Expression::~Expression() {
+        delete env;
+        // delete argName;      // xxx -- there's a problem in cloning ConstantExpr I still don't know how to fix
+        deleteAll( results );
+}
+void Expression::add_result( Type *t ) {
+        if ( TupleType *tuple = dynamic_cast< TupleType* >( t ) ) {
+                std::copy( tuple->get_types().begin(), tuple->get_types().end(), back_inserter( results ) );
+        } else {
+                results.push_back(t);
+        } // if
+}
 void Expression::print(std::ostream &os, int indent) const {
+    if ( env ) {
+        os << std::string(indent, ' ') << "with environment:" << std::endl;
+        env->print( os, indent+2 );
+    }
+    if ( argName ) {
+        os << std::string(indent, ' ') << "with designator:";
+        argName->print( os, indent+2 );
+    }
+}
+//*** ConstantExpr
+ConstantExpr::ConstantExpr(Constant _c, Expression *_aname ):
+    Expression( _aname ), constant(_c)
+{
+    add_result( constant.get_type()->clone() );
+}
+ConstantExpr::ConstantExpr( const ConstantExpr &other)
+    : Expression( other ), constant( other.constant )
+{}
+        if ( env ) {
+                os << std::string(indent, ' ') << "with environment:" << std::endl;
+                env->print( os, indent+2 );
+        } // if
+        if ( argName ) {
+                os << std::string(indent, ' ') << "with designator:";
+                argName->print( os, indent+2 );
+        } // if
+}
+ConstantExpr::ConstantExpr( Constant _c, Expression *_aname ) : Expression( _aname ), constant( _c ) {
+        add_result( constant.get_type()->clone() );
+}
+ConstantExpr::ConstantExpr( const ConstantExpr &other) : Expression( other ), constant( other.constant ) {
+}
 ConstantExpr::~ConstantExpr() {}
+void ConstantExpr::print(std::ostream &os, int indent) const {
+    os << std::string(indent, ' ') << "Constant Expression: " ;
+    constant.print(os);
+    os << std::endl;
+    Expression::print( os, indent );
+}
+//*** VariableExpr
+VariableExpr::VariableExpr( DeclarationWithType *_var, Expression *_aname ) : Expression( _aname ), var( _var )
+{
+    add_result( var->get_type()->clone() );
+    for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
+        (*i)->set_isLvalue( true );
+    }
+}
+VariableExpr::VariableExpr( const VariableExpr &other )
+    : Expression( other ), var( other.var )
+{
+}
+VariableExpr::~VariableExpr()
+{
+    // don't delete the declaration, since it points somewhere else in the tree
+}
+void VariableExpr::print(std::ostream &os, int indent) const {
+    os << std::string(indent, ' ') << "Variable Expression: ";
+    Declaration *decl = get_var();
+    // if ( decl != 0) decl->print(os, indent + 2);
+    if ( decl != 0) decl->printShort(os, indent + 2);
+    os << std::endl;
+    Expression::print( os, indent );
+}
+//*** SizeofExpr
+void ConstantExpr::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ') << "Constant Expression: " ;
+        constant.print(os);
+        os << std::endl;
+        Expression::print( os, indent );
+}
+VariableExpr::VariableExpr( DeclarationWithType *_var, Expression *_aname ) : Expression( _aname ), var( _var ) {
+        add_result( var->get_type()->clone() );
+        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
+                (*i)->set_isLvalue( true );
+        } // for
+}
+VariableExpr::VariableExpr( const VariableExpr &other ) : Expression( other ), var( other.var ) {
+}
+VariableExpr::~VariableExpr() {
+        // don't delete the declaration, since it points somewhere else in the tree
+}
+void VariableExpr::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ') << "Variable Expression: ";
+        Declaration *decl = get_var();
+        // if ( decl != 0) decl->print(os, indent + 2);
+        if ( decl != 0) decl->printShort(os, indent + 2);
+        os << std::endl;
+        Expression::print( os, indent );
+}
 SizeofExpr::SizeofExpr( Expression *expr_, Expression *_aname ) :
+    Expression( _aname ), expr(expr_), type(0), isType(false)
+{
+    add_result( new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ) );
+                Expression( _aname ), expr(expr_), type(0), isType(false) {
+        add_result( new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ) );
+}
 SizeofExpr::SizeofExpr( Type *type_, Expression *_aname ) :
+    Expression( _aname ), expr(0), type(type_), isType(true)
+{
+    add_result( new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ) );
+}
+SizeofExpr::SizeofExpr( const SizeofExpr &other )
+    : Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType )
+{
+}
+SizeofExpr::~SizeofExpr(){
+    delete expr;
+    delete type;
+                Expression( _aname ), expr(0), type(type_), isType(true) {
+        add_result( new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ) );
+}
+SizeofExpr::SizeofExpr( const SizeofExpr &other ) :
+        Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
+}
+SizeofExpr::~SizeofExpr() {
+        delete expr;
+        delete type;
+}
 void SizeofExpr::print( std::ostream &os, int indent) const {
+    os << std::string(indent, ' ') << "Sizeof Expression on: ";
+    if (isType)
+        type->print(os, indent + 2);
+    else
+        expr->print(os, indent + 2);
+    os << std::endl;
+    Expression::print( os, indent );
+}
+//*** AttrExpr
+        os << std::string(indent, ' ') << "Sizeof Expression on: ";
+        if (isType)
+                type->print(os, indent + 2);
+        else
+                expr->print(os, indent + 2);
+        os << std::endl;
+        Expression::print( os, indent );
+}
 AttrExpr::AttrExpr( Expression *attr, Expression *expr_, Expression *_aname ) :
+    Expression( _aname ), attr( attr ), expr(expr_), type(0), isType(false)
+{
+                Expression( _aname ), attr( attr ), expr(expr_), type(0), isType(false) {
+}
 AttrExpr::AttrExpr( Expression *attr, Type *type_, Expression *_aname ) :
+    Expression( _aname ), attr( attr ), expr(0), type(type_), isType(true)
+{
+}
+AttrExpr::AttrExpr( const AttrExpr &other )
+    : Expression( other ), attr( maybeClone( other.attr ) ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType )
+{
+}
+AttrExpr::~AttrExpr(){
+    delete attr;
+    delete expr;
+    delete type;
+                Expression( _aname ), attr( attr ), expr(0), type(type_), isType(true) {
+}
+AttrExpr::AttrExpr( const AttrExpr &other ) :
+                Expression( other ), attr( maybeClone( other.attr ) ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
+}
+AttrExpr::~AttrExpr() {
+        delete attr;
+        delete expr;
+        delete type;
+}
 void AttrExpr::print( std::ostream &os, int indent) const {
+    os << std::string(indent, ' ') << "Attr ";
+    attr->print( os, indent + 2 );
+    if ( isType || expr ) {
+        os << "applied to: ";
+        if (isType)
+            type->print(os, indent + 2);
+        else
+            expr->print(os, indent + 2);
+    }
+    os << std::endl;
+    Expression::print( os, indent );
+}
+//*** CastExpr
+CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_)
+{
+    add_result(toType);
+        os << std::string(indent, ' ') << "Attr ";
+        attr->print( os, indent + 2 );
+        if ( isType || expr ) {
+                os << "applied to: ";
+                if (isType)
+                        type->print(os, indent + 2);
+                else
+                        expr->print(os, indent + 2);
+        } // if
+        os << std::endl;
+        Expression::print( os, indent );
+}
+CastExpr::CastExpr( Expression *arg_, Type *toType, Expression *_aname ) : Expression( _aname ), arg(arg_) {
+        add_result(toType);
+}
 …
+}
+CastExpr::CastExpr( const CastExpr &other )
+    : Expression( other ), arg( maybeClone( other.arg ) )
+{
+CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+}
 CastExpr::~CastExpr() {
     delete arg;
+        delete arg;
+}
 …
 void CastExpr::print( std::ostream &os, int indent ) const {
+    os << std::string(indent, ' ') << "Cast of:" << std::endl;
+    arg->print(os, indent+2);
+    os << std::endl << std::string(indent, ' ') << "to:" << std::endl;
+    if ( results.empty() ) {
+        os << std::string(indent+2, ' ') << "nothing" << std::endl;
+    } else {
+        printAll(results, os, indent+2);
+    }
+    Expression::print( os, indent );
+}
+//*** UntypedMemberExpr
+        os << std::string(indent, ' ') << "Cast of:" << std::endl;
+        arg->print(os, indent+2);
+        os << std::endl << std::string(indent, ' ') << "to:" << std::endl;
+        if ( results.empty() ) {
+                os << std::string(indent+2, ' ') << "nothing" << std::endl;
+        } else {
+                printAll(results, os, indent+2);
+        } // if
+        Expression::print( os, indent );
+}
 UntypedMemberExpr::UntypedMemberExpr( std::string _member, Expression *_aggregate, Expression *_aname ) :
+    Expression( _aname ), member(_member), aggregate(_aggregate) {}
+UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other )
+    : Expression( other ),   member( other.member ), aggregate( maybeClone( other.aggregate ) )
+{
+                Expression( _aname ), member(_member), aggregate(_aggregate) {}
+UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
+                Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
+}
 UntypedMemberExpr::~UntypedMemberExpr() {
     delete aggregate;
+        delete aggregate;
+}
 void UntypedMemberExpr::print( std::ostream &os, int indent ) const {
+    os << std::string(indent, ' ') << "Member Expression, with field: " << get_member();
+    Expression *agg = get_aggregate();
+    os << std::string(indent, ' ') << "from aggregate: ";
+    if (agg != 0) agg->print(os, indent + 2);
+    Expression::print( os, indent );
+}
+//*** MemberExpr
+        os << std::string(indent, ' ') << "Member Expression, with field: " << get_member();
+        Expression *agg = get_aggregate();
+        os << std::string(indent, ' ') << "from aggregate: ";
+        if (agg != 0) agg->print(os, indent + 2);
+        Expression::print( os, indent );
+}
 MemberExpr::MemberExpr( DeclarationWithType *_member, Expression *_aggregate, Expression *_aname ) :
+    Expression( _aname ), member(_member), aggregate(_aggregate)
+{
+    add_result( member->get_type()->clone() );
+    for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
+        (*i)->set_isLvalue( true );
+    }
+}
+MemberExpr::MemberExpr( const MemberExpr &other )
+    : Expression( other ),   member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) )
+{
+                Expression( _aname ), member(_member), aggregate(_aggregate) {
+        add_result( member->get_type()->clone() );
+        for ( std::list< Type* >::iterator i = get_results().begin(); i != get_results().end(); ++i ) {
+                (*i)->set_isLvalue( true );
+        } // for
+}
+MemberExpr::MemberExpr( const MemberExpr &other ) :
+                Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
+}
 MemberExpr::~MemberExpr() {
     delete member;
     delete aggregate;
+        delete member;
+        delete aggregate;
+}
 void MemberExpr::print( std::ostream &os, int indent ) const {
+    os << std::string(indent, ' ') << "Member Expression, with field: " << std::endl;
+    assert( member );
+    os << std::string(indent + 2, ' ');
+    member->print( os, indent + 2 );
+    os << std::endl;
+    Expression *agg = get_aggregate();
+    os << std::string(indent, ' ') << "from aggregate: " << std::endl;
+    if (agg != 0) agg->print(os, indent + 2);
+    Expression::print( os, indent );
+}
+//*** UntypedExpr
+        os << std::string(indent, ' ') << "Member Expression, with field: " << std::endl;
+        assert( member );
+        os << std::string(indent + 2, ' ');
+        member->print( os, indent + 2 );
+        os << std::endl;
+        Expression *agg = get_aggregate();
+        os << std::string(indent, ' ') << "from aggregate: " << std::endl;
+        if (agg != 0) agg->print(os, indent + 2);
+        Expression::print( os, indent );
+}
 UntypedExpr::UntypedExpr( Expression *_function, Expression *_aname ) : Expression( _aname ), function( _function ) {}
+UntypedExpr::UntypedExpr( const UntypedExpr &other )
+    : Expression( other ), function( maybeClone( other.function ) )
+{
+    cloneAll( other.args, args );
+UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
+                Expression( other ), function( maybeClone( other.function ) ) {
+        cloneAll( other.args, args );
+}
 UntypedExpr::UntypedExpr( Expression *_function, std::list<Expression *> &_args, Expression *_aname ) :
     Expression( _aname ), function(_function), args(_args) {}
+                Expression( _aname ), function(_function), args(_args) {}
 UntypedExpr::~UntypedExpr() {}
 void UntypedExpr::print( std::ostream &os, int indent ) const {
+    os << std::string(indent, ' ') << "Applying untyped: " << std::endl;
+    function->print(os, indent + 4);
+    os << "\r" << std::string(indent, ' ') << "...to: " << std::endl;
+    printArgs(os, indent + 4);
+    Expression::print( os, indent );
+}
+void UntypedExpr::printArgs(std::ostream &os, int indent ) const {
+    std::list<Expression *>::const_iterator i;
+    for (i = args.begin(); i != args.end(); i++)
+        (*i)->print(os, indent);
+}
+//*** NameExpr
+        os << std::string(indent, ' ') << "Applying untyped: " << std::endl;
+        function->print(os, indent + 4);
+        os << "\r" << std::string(indent, ' ') << "...to: " << std::endl;
+        printArgs(os, indent + 4);
+        Expression::print( os, indent );
+}
+void UntypedExpr::printArgs( std::ostream &os, int indent ) const {
+        std::list<Expression *>::const_iterator i;
+        for (i = args.begin(); i != args.end(); i++)
+                (*i)->print(os, indent);
+}
 NameExpr::NameExpr( std::string _name, Expression *_aname ) : Expression( _aname ), name(_name) {}
+NameExpr::NameExpr( const NameExpr &other )
+    : Expression( other ), name( other.name )
+{
+NameExpr::NameExpr( const NameExpr &other ) : Expression( other ), name( other.name ) {
+}
 …
 void NameExpr::print( std::ostream &os, int indent ) const {
+    os << std::string(indent, ' ') << "Name: " << get_name() << std::endl;
+    Expression::print( os, indent );
+}
+//*** LogicalExpr
+        os << std::string(indent, ' ') << "Name: " << get_name() << std::endl;
+        Expression::print( os, indent );
+}
 LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp, Expression *_aname ) :
+    Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp)
+{
+    add_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+}
+LogicalExpr::LogicalExpr( const LogicalExpr &other )
+    : Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), isAnd( other.isAnd )
+{
+                Expression( _aname ), arg1(arg1_), arg2(arg2_), isAnd(andp) {
+        add_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+}
+LogicalExpr::LogicalExpr( const LogicalExpr &other ) :
+                Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), isAnd( other.isAnd ) {
+}
 LogicalExpr::~LogicalExpr(){
     delete arg1;
     delete arg2;
+        delete arg1;
+        delete arg2;
+}
 void LogicalExpr::print( std::ostream &os, int indent )const {
+    os << std::string(indent, ' ') << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
+    arg1->print(os);
+    os << " and ";
+    arg2->print(os);
+    os << std::endl;
+    Expression::print( os, indent );
+}
+//*** ConditionalExpr
+        os << std::string(indent, ' ') << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
+        arg1->print(os);
+        os << " and ";
+        arg2->print(os);
+        os << std::endl;
+        Expression::print( os, indent );
+}
 ConditionalExpr::ConditionalExpr( Expression *arg1_, Expression *arg2_, Expression *arg3_, Expression *_aname ) :
+    Expression( _aname ), arg1(arg1_), arg2(arg2_), arg3(arg3_) {}
+ConditionalExpr::ConditionalExpr( const ConditionalExpr &other )
+     : Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), arg3( maybeClone( other.arg3 ) )
+ {
+ }
+                Expression( _aname ), arg1(arg1_), arg2(arg2_), arg3(arg3_) {}
+ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
+                Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), arg3( maybeClone( other.arg3 ) ) {
+}
 ConditionalExpr::~ConditionalExpr() {
     delete arg1;
     delete arg2;
     delete arg3;
+        delete arg1;
+        delete arg2;
+        delete arg3;
+}
 void ConditionalExpr::print( std::ostream &os, int indent ) const {
+    os << std::string(indent, ' ') << "Conditional expression on: " << std::endl;
+    arg1->print( os, indent+2 );
+    os << std::string(indent, ' ') << "First alternative:" << std::endl;
+    arg2->print( os, indent+2 );
+    os << std::string(indent, ' ') << "Second alternative:" << std::endl;
+    arg3->print( os, indent+2 );
+    os << std::endl;
+    Expression::print( os, indent );
+}
+//*** UntypedValofExpr
+void UntypedValofExpr::print( std::ostream &os, int indent ) const
+{
+    os << std::string(indent, ' ') << "Valof Expression: " << std::endl;
+    if ( get_body() != 0 )
+        get_body()->print( os, indent + 2 );
+}
+        os << std::string(indent, ' ') << "Conditional expression on: " << std::endl;
+        arg1->print( os, indent+2 );
+        os << std::string(indent, ' ') << "First alternative:" << std::endl;
+        arg2->print( os, indent+2 );
+        os << std::string(indent, ' ') << "Second alternative:" << std::endl;
+        arg3->print( os, indent+2 );
+        os << std::endl;
+        Expression::print( os, indent );
+}
+void UntypedValofExpr::print( std::ostream &os, int indent ) const {
+        os << std::string(indent, ' ') << "Valof Expression: " << std::endl;
+        if ( get_body() != 0 )
+                get_body()->print( os, indent + 2 );
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Expression.h

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: Expression.h,v 1.31 2005/08/29 20:59:25 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Expression.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:46:15 2015
+// Update Count     : 3
+//
 #ifndef EXPRESSION_H
 …
 #include "Constant.h"
+class Expression
+{
+public:
+    Expression(Expression *_aname = 0 );
+    Expression( const Expression &other );
+    virtual ~Expression();
+    std::list<Type *>& get_results() { return results; }
+    void add_result(Type *t);
+    TypeSubstitution *get_env() const { return env; }
+    void set_env( TypeSubstitution *newValue ) { env = newValue; }
+    Expression *get_argName() const { return argName; }
+    void set_argName( Expression *name ) { argName = name; }
+    virtual Expression *clone() const = 0;
+    virtual void accept( Visitor &v ) = 0;
+    virtual Expression *acceptMutator( Mutator &m ) = 0;
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+protected:
+    std::list<Type *> results;
+    TypeSubstitution *env;
+    Expression* argName; // if expression is used as an argument, it can be "designated" by this name
+class Expression {
+  public:
+        Expression(Expression *_aname = 0 );
+        Expression( const Expression &other );
+        virtual ~Expression();
+        std::list<Type *>& get_results() { return results; }
+        void add_result(Type *t);
+        TypeSubstitution *get_env() const { return env; }
+        void set_env( TypeSubstitution *newValue ) { env = newValue; }
+        Expression *get_argName() const { return argName; }
+        void set_argName( Expression *name ) { argName = name; }
+        virtual Expression *clone() const = 0;
+        virtual void accept( Visitor &v ) = 0;
+        virtual Expression *acceptMutator( Mutator &m ) = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  protected:
+        std::list<Type *> results;
+        TypeSubstitution *env;
+        Expression* argName; // if expression is used as an argument, it can be "designated" by this name
 };
 // ParamEntry contains the i.d. of a declaration and a type that is derived from that declaration,
 // but subject to decay-to-pointer and type parameter renaming
+struct ParamEntry
+{
     ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ) {}
     ParamEntry( UniqueId decl, Type *actualType, Type *formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ) {}
     ParamEntry( const ParamEntry &other );
     ~ParamEntry();
     ParamEntry &operator=( const ParamEntry &other );
     UniqueId decl;
     Type *actualType;
     Type *formalType;
     Expression* expr;
+struct ParamEntry {
+        ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ) {}
+        ParamEntry( UniqueId decl, Type *actualType, Type *formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ) {}
+        ParamEntry( const ParamEntry &other );
+        ~ParamEntry();
+        ParamEntry &operator=( const ParamEntry &other );
+        UniqueId decl;
+        Type *actualType;
+        Type *formalType;
+        Expression* expr;
 };
 …
 // ApplicationExpr represents the application of a function to a set of parameters.  This is the
 // result of running an UntypedExpr through the expression analyzer.
+class ApplicationExpr : public Expression
+{
+public:
+    ApplicationExpr( Expression *function );
+    ApplicationExpr( const ApplicationExpr &other );
+    virtual ~ApplicationExpr();
+    Expression *get_function() const { return function; }
+    void set_function( Expression *newValue ) { function = newValue; }
+    std::list<Expression *>& get_args() { return args; }
+    InferredParams &get_inferParams() { return inferParams; }
+    virtual ApplicationExpr *clone() const { return new ApplicationExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Expression *function;
+    std::list<Expression *> args;
+    InferredParams inferParams;
+class ApplicationExpr : public Expression {
+  public:
+        ApplicationExpr( Expression *function );
+        ApplicationExpr( const ApplicationExpr &other );
+        virtual ~ApplicationExpr();
+        Expression *get_function() const { return function; }
+        void set_function( Expression *newValue ) { function = newValue; }
+        std::list<Expression *>& get_args() { return args; }
+        InferredParams &get_inferParams() { return inferParams; }
+        virtual ApplicationExpr *clone() const { return new ApplicationExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *function;
+        std::list<Expression *> args;
+        InferredParams inferParams;
 };
 …
 // particular overload for the function name has not yet been determined.  Most operators are
 // converted into functional form automatically, to permit operator overloading.
+class UntypedExpr : public Expression
+{
+public:
+    UntypedExpr( Expression *function, Expression *_aname = 0 );
+    UntypedExpr( const UntypedExpr &other );
+    UntypedExpr( Expression *function, std::list<Expression *> &args, Expression *_aname = 0 );
+    virtual ~UntypedExpr();
+    Expression *get_function() const { return function; }
+    void set_function( Expression *newValue ) { function = newValue; }
+    void set_args( std::list<Expression *> &listArgs ) { args = listArgs; }
+    std::list<Expression*>::iterator begin_args() { return args.begin(); }
+    std::list<Expression*>::iterator end_args() { return args.end(); }
+    std::list<Expression*>& get_args() { return args; }
+    virtual UntypedExpr *clone() const { return new UntypedExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+    virtual void printArgs(std::ostream &os, int indent = 0) const;
+private:
+    Expression *function;
+    std::list<Expression*> args;
+class UntypedExpr : public Expression {
+  public:
+        UntypedExpr( Expression *function, Expression *_aname = 0 );
+        UntypedExpr( const UntypedExpr &other );
+        UntypedExpr( Expression *function, std::list<Expression *> &args, Expression *_aname = 0 );
+        virtual ~UntypedExpr();
+        Expression *get_function() const { return function; }
+        void set_function( Expression *newValue ) { function = newValue; }
+        void set_args( std::list<Expression *> &listArgs ) { args = listArgs; }
+        std::list<Expression*>::iterator begin_args() { return args.begin(); }
+        std::list<Expression*>::iterator end_args() { return args.end(); }
+        std::list<Expression*>& get_args() { return args; }
+        virtual UntypedExpr *clone() const { return new UntypedExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        virtual void printArgs(std::ostream &os, int indent = 0) const;
+  private:
+        Expression *function;
+        std::list<Expression*> args;
 };
 // this class contains a name whose meaning is still not determined
+class NameExpr : public Expression
+{
+public:
+    NameExpr( std::string name, Expression *_aname = 0 );
+    NameExpr( const NameExpr &other );
+    virtual ~NameExpr();
+    std::string get_name() const { return name; }
+    void set_name( std::string newValue ) { name = newValue; }
+    virtual NameExpr *clone() const { return new NameExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    std::string name;
+class NameExpr : public Expression {
+  public:
+        NameExpr( std::string name, Expression *_aname = 0 );
+        NameExpr( const NameExpr &other );
+        virtual ~NameExpr();
+        std::string get_name() const { return name; }
+        void set_name( std::string newValue ) { name = newValue; }
+        virtual NameExpr *clone() const { return new NameExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::string name;
 };
 …
 // AddressExpr represents a address-of expression, e.g. &e
+class AddressExpr : public Expression
+{
+public:
+    AddressExpr( Expression *arg, Expression *_aname = 0 );
+    AddressExpr( const AddressExpr &other );
+    virtual ~AddressExpr();
+    Expression *get_arg() const { return arg; }
+    void set_arg(Expression *newValue ) { arg = newValue; }
+    virtual AddressExpr *clone() const { return new AddressExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Expression *arg;
+};
+class LabelAddressExpr : public Expression
+{
+public:
+    LabelAddressExpr( Expression *arg );
+    LabelAddressExpr( const AddressExpr &other );
+    virtual ~LabelAddressExpr();
+    Expression *get_arg() const { return arg; }
+    void set_arg(Expression *newValue ) { arg = newValue; }
+    virtual LabelAddressExpr *clone() const { return new LabelAddressExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Expression *arg;
+class AddressExpr : public Expression {
+  public:
+        AddressExpr( Expression *arg, Expression *_aname = 0 );
+        AddressExpr( const AddressExpr &other );
+        virtual ~AddressExpr();
+        Expression *get_arg() const { return arg; }
+        void set_arg(Expression *newValue ) { arg = newValue; }
+        virtual AddressExpr *clone() const { return new AddressExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *arg;
+};
+class LabelAddressExpr : public Expression {
+  public:
+        LabelAddressExpr( Expression *arg );
+        LabelAddressExpr( const AddressExpr &other );
+        virtual ~LabelAddressExpr();
+        Expression *get_arg() const { return arg; }
+        void set_arg(Expression *newValue ) { arg = newValue; }
+        virtual LabelAddressExpr *clone() const { return new LabelAddressExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *arg;
 };
 // CastExpr represents a type cast expression, e.g. (int)e
+class CastExpr : public Expression
+{
+public:
+    CastExpr( Expression *arg, Expression *_aname = 0 );
+    CastExpr( Expression *arg, Type *toType, Expression *_aname = 0 );
+    CastExpr( const CastExpr &other );
+    virtual ~CastExpr();
+    Expression *get_arg() const { return arg; }
+    void set_arg(Expression *newValue ) { arg = newValue; }
+    virtual CastExpr *clone() const { return new CastExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Expression *arg;
+};
+// UntypedMemberExpr represents a member selection operation, e.g. q.p
+// before processing by the expression analyzer
+class UntypedMemberExpr : public Expression
+{
+public:
+    UntypedMemberExpr( std::string member, Expression *aggregate, Expression *_aname = 0 );
+    UntypedMemberExpr( const UntypedMemberExpr &other );
+    virtual ~UntypedMemberExpr();
+    std::string get_member() const { return member; }
+    void set_member( const std::string &newValue ) { member = newValue; }
+    Expression *get_aggregate() const { return aggregate; }
+    void set_aggregate( Expression *newValue ) { aggregate = newValue; }
+    virtual UntypedMemberExpr *clone() const { return new UntypedMemberExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    std::string member;
+    Expression *aggregate;
+};
+// MemberExpr represents a member selection operation, e.g. q.p
+// after processing by the expression analyzer
+class MemberExpr : public Expression
+{
+public:
+    MemberExpr( DeclarationWithType *member, Expression *aggregate, Expression *_aname = 0 );
+    MemberExpr( const MemberExpr &other );
+    virtual ~MemberExpr();
+    DeclarationWithType *get_member() const { return member; }
+    void set_member( DeclarationWithType *newValue ) { member = newValue; }
+    Expression *get_aggregate() const { return aggregate; }
+    void set_aggregate( Expression *newValue ) { aggregate = newValue; }
+    virtual MemberExpr *clone() const { return new MemberExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    DeclarationWithType *member;
+    Expression *aggregate;
+class CastExpr : public Expression {
+  public:
+        CastExpr( Expression *arg, Expression *_aname = 0 );
+        CastExpr( Expression *arg, Type *toType, Expression *_aname = 0 );
+        CastExpr( const CastExpr &other );
+        virtual ~CastExpr();
+        Expression *get_arg() const { return arg; }
+        void set_arg(Expression *newValue ) { arg = newValue; }
+        virtual CastExpr *clone() const { return new CastExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *arg;
+};
+// UntypedMemberExpr represents a member selection operation, e.g. q.p before processing by the expression analyzer
+class UntypedMemberExpr : public Expression {
+  public:
+        UntypedMemberExpr( std::string member, Expression *aggregate, Expression *_aname = 0 );
+        UntypedMemberExpr( const UntypedMemberExpr &other );
+        virtual ~UntypedMemberExpr();
+        std::string get_member() const { return member; }
+        void set_member( const std::string &newValue ) { member = newValue; }
+        Expression *get_aggregate() const { return aggregate; }
+        void set_aggregate( Expression *newValue ) { aggregate = newValue; }
+        virtual UntypedMemberExpr *clone() const { return new UntypedMemberExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::string member;
+        Expression *aggregate;
+};
+// MemberExpr represents a member selection operation, e.g. q.p after processing by the expression analyzer
+class MemberExpr : public Expression {
+  public:
+        MemberExpr( DeclarationWithType *member, Expression *aggregate, Expression *_aname = 0 );
+        MemberExpr( const MemberExpr &other );
+        virtual ~MemberExpr();
+        DeclarationWithType *get_member() const { return member; }
+        void set_member( DeclarationWithType *newValue ) { member = newValue; }
+        Expression *get_aggregate() const { return aggregate; }
+        void set_aggregate( Expression *newValue ) { aggregate = newValue; }
+        virtual MemberExpr *clone() const { return new MemberExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        DeclarationWithType *member;
+        Expression *aggregate;
 };
 // VariableExpr represents an expression that simply refers to the value of a named variable
+class VariableExpr : public Expression
+{
+public:
+    VariableExpr( DeclarationWithType *var, Expression *_aname = 0 );
+    VariableExpr( const VariableExpr &other );
+    virtual ~VariableExpr();
+    DeclarationWithType *get_var() const { return var; }
+    void set_var( DeclarationWithType *newValue ) { var = newValue; }
+    virtual VariableExpr *clone() const { return new VariableExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    DeclarationWithType *var;
+class VariableExpr : public Expression {
+  public:
+        VariableExpr( DeclarationWithType *var, Expression *_aname = 0 );
+        VariableExpr( const VariableExpr &other );
+        virtual ~VariableExpr();
+        DeclarationWithType *get_var() const { return var; }
+        void set_var( DeclarationWithType *newValue ) { var = newValue; }
+        virtual VariableExpr *clone() const { return new VariableExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        DeclarationWithType *var;
 };
 // ConstantExpr represents an expression that simply refers to the value of a constant
+class ConstantExpr : public Expression
+{
+public:
+    ConstantExpr( Constant constant, Expression *_aname = 0 );
+    ConstantExpr( const ConstantExpr &other );
+    virtual ~ConstantExpr();
+    Constant *get_constant() { return &constant; }
+    void set_constant( const Constant &newValue ) { constant = newValue; }
+    virtual ConstantExpr *clone() const { return new ConstantExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Constant constant;
+class ConstantExpr : public Expression {
+  public:
+        ConstantExpr( Constant constant, Expression *_aname = 0 );
+        ConstantExpr( const ConstantExpr &other );
+        virtual ~ConstantExpr();
+        Constant *get_constant() { return &constant; }
+        void set_constant( const Constant &newValue ) { constant = newValue; }
+        virtual ConstantExpr *clone() const { return new ConstantExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Constant constant;
 };
 // SizeofExpr represents a sizeof expression (could be sizeof(int) or sizeof 3+4)
+class SizeofExpr : public Expression
+{
+public:
+    SizeofExpr( Expression *expr, Expression *_aname = 0 );
+    SizeofExpr( const SizeofExpr &other );
+    SizeofExpr( Type *type, Expression *_aname = 0 );
+    virtual ~SizeofExpr();
+    Expression *get_expr() const { return expr; }
+    void set_expr( Expression *newValue ) { expr = newValue; }
+    Type *get_type() const { return type; }
+    void set_type( Type *newValue ) { type = newValue; }
+    bool get_isType() const { return isType; }
+    void set_isType( bool newValue ) { isType = newValue; }
+    virtual SizeofExpr *clone() const { return new SizeofExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Expression *expr;
+    Type *type;
+    bool isType;
+class SizeofExpr : public Expression {
+  public:
+        SizeofExpr( Expression *expr, Expression *_aname = 0 );
+        SizeofExpr( const SizeofExpr &other );
+        SizeofExpr( Type *type, Expression *_aname = 0 );
+        virtual ~SizeofExpr();
+        Expression *get_expr() const { return expr; }
+        void set_expr( Expression *newValue ) { expr = newValue; }
+        Type *get_type() const { return type; }
+        void set_type( Type *newValue ) { type = newValue; }
+        bool get_isType() const { return isType; }
+        void set_isType( bool newValue ) { isType = newValue; }
+        virtual SizeofExpr *clone() const { return new SizeofExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *expr;
+        Type *type;
+        bool isType;
 };
 // AttrExpr represents an @attribute expression (like sizeof, but user-defined)
+class AttrExpr : public Expression
+{
+public:
+    AttrExpr(Expression *attr, Expression *expr, Expression *_aname = 0 );
+    AttrExpr( const AttrExpr &other );
+    AttrExpr( Expression *attr, Type *type, Expression *_aname = 0 );
+    virtual ~AttrExpr();
+    Expression *get_attr() const { return attr; }
+    void set_attr( Expression *newValue ) { attr = newValue; }
+    Expression *get_expr() const { return expr; }
+    void set_expr( Expression *newValue ) { expr = newValue; }
+    Type *get_type() const { return type; }
+    void set_type( Type *newValue ) { type = newValue; }
+    bool get_isType() const { return isType; }
+    void set_isType( bool newValue ) { isType = newValue; }
+    virtual AttrExpr *clone() const { return new AttrExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Expression *attr;
+    Expression *expr;
+    Type *type;
+    bool isType;
+class AttrExpr : public Expression {
+  public:
+        AttrExpr(Expression *attr, Expression *expr, Expression *_aname = 0 );
+        AttrExpr( const AttrExpr &other );
+        AttrExpr( Expression *attr, Type *type, Expression *_aname = 0 );
+        virtual ~AttrExpr();
+        Expression *get_attr() const { return attr; }
+        void set_attr( Expression *newValue ) { attr = newValue; }
+        Expression *get_expr() const { return expr; }
+        void set_expr( Expression *newValue ) { expr = newValue; }
+        Type *get_type() const { return type; }
+        void set_type( Type *newValue ) { type = newValue; }
+        bool get_isType() const { return isType; }
+        void set_isType( bool newValue ) { isType = newValue; }
+        virtual AttrExpr *clone() const { return new AttrExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *attr;
+        Expression *expr;
+        Type *type;
+        bool isType;
 };
 // LogicalExpr represents a short-circuit boolean expression (&& or ||)
+class LogicalExpr : public Expression
+{
+public:
+    LogicalExpr( Expression *arg1, Expression *arg2, bool andp = true, Expression *_aname = 0 );
+    LogicalExpr( const LogicalExpr &other );
+    virtual ~LogicalExpr();
+    bool get_isAnd() const { return isAnd; }
+    Expression *get_arg1() { return arg1; }
+    void set_arg1( Expression *newValue ) { arg1 = newValue; }
+    Expression *get_arg2() const { return arg2; }
+    void set_arg2( Expression *newValue ) { arg2 = newValue; }
+    virtual LogicalExpr *clone() const { return new LogicalExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Expression *arg1;
+    Expression *arg2;
+    bool isAnd;
+class LogicalExpr : public Expression {
+  public:
+        LogicalExpr( Expression *arg1, Expression *arg2, bool andp = true, Expression *_aname = 0 );
+        LogicalExpr( const LogicalExpr &other );
+        virtual ~LogicalExpr();
+        bool get_isAnd() const { return isAnd; }
+        Expression *get_arg1() { return arg1; }
+        void set_arg1( Expression *newValue ) { arg1 = newValue; }
+        Expression *get_arg2() const { return arg2; }
+        void set_arg2( Expression *newValue ) { arg2 = newValue; }
+        virtual LogicalExpr *clone() const { return new LogicalExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *arg1;
+        Expression *arg2;
+        bool isAnd;
 };
 // ConditionalExpr represents the three-argument conditional ( p ? a : b )
+class ConditionalExpr : public Expression
+{
+public:
+    ConditionalExpr( Expression *arg1, Expression *arg2, Expression *arg3, Expression *_aname = 0 );
+    ConditionalExpr( const ConditionalExpr &other );
+    virtual ~ConditionalExpr();
+    Expression *get_arg1() const { return arg1; }
+    void set_arg1( Expression *newValue ) { arg1 = newValue; }
+    Expression *get_arg2() const { return arg2; }
+    void set_arg2( Expression *newValue ) { arg2 = newValue; }
+    Expression *get_arg3() const { return arg3; }
+    void set_arg3( Expression *newValue ) { arg3 = newValue; }
+    virtual ConditionalExpr *clone() const { return new ConditionalExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Expression *arg1;
+    Expression *arg2;
+    Expression *arg3;
+class ConditionalExpr : public Expression {
+  public:
+        ConditionalExpr( Expression *arg1, Expression *arg2, Expression *arg3, Expression *_aname = 0 );
+        ConditionalExpr( const ConditionalExpr &other );
+        virtual ~ConditionalExpr();
+        Expression *get_arg1() const { return arg1; }
+        void set_arg1( Expression *newValue ) { arg1 = newValue; }
+        Expression *get_arg2() const { return arg2; }
+        void set_arg2( Expression *newValue ) { arg2 = newValue; }
+        Expression *get_arg3() const { return arg3; }
+        void set_arg3( Expression *newValue ) { arg3 = newValue; }
+        virtual ConditionalExpr *clone() const { return new ConditionalExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *arg1;
+        Expression *arg2;
+        Expression *arg3;
 };
 // CommaExpr represents the sequence operator ( a, b )
+class CommaExpr : public Expression
+{
+public:
+    CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname = 0 );
+    CommaExpr( const CommaExpr &other );
+    virtual ~CommaExpr();
+    Expression *get_arg1() const { return arg1; }
+    void set_arg1( Expression *newValue ) { arg1 = newValue; }
+    Expression *get_arg2() const { return arg2; }
+    void set_arg2( Expression *newValue ) { arg2 = newValue; }
+    virtual CommaExpr *clone() const { return new CommaExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Expression *arg1;
+    Expression *arg2;
+class CommaExpr : public Expression {
+  public:
+        CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname = 0 );
+        CommaExpr( const CommaExpr &other );
+        virtual ~CommaExpr();
+        Expression *get_arg1() const { return arg1; }
+        void set_arg1( Expression *newValue ) { arg1 = newValue; }
+        Expression *get_arg2() const { return arg2; }
+        void set_arg2( Expression *newValue ) { arg2 = newValue; }
+        virtual CommaExpr *clone() const { return new CommaExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *arg1;
+        Expression *arg2;
 };
 // TupleExpr represents a tuple expression ( [a, b, c] )
+class TupleExpr : public Expression
+{
+public:
+    TupleExpr( Expression *_aname = 0 );
+    TupleExpr( const TupleExpr &other );
+    virtual ~TupleExpr();
+    void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
+    std::list<Expression*>& get_exprs() { return exprs; }
+    virtual TupleExpr *clone() const { return new TupleExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    std::list<Expression*> exprs;
+class TupleExpr : public Expression {
+  public:
+        TupleExpr( Expression *_aname = 0 );
+        TupleExpr( const TupleExpr &other );
+        virtual ~TupleExpr();
+        void set_exprs( std::list<Expression*> newValue ) { exprs = newValue; }
+        std::list<Expression*>& get_exprs() { return exprs; }
+        virtual TupleExpr *clone() const { return new TupleExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::list<Expression*> exprs;
 };
 // SolvedTupleExpr represents a TupleExpr whose components have been type-resolved. It is effectively a shell for the code generator to work on
+class SolvedTupleExpr : public Expression
+{
+public:
+    SolvedTupleExpr( Expression *_aname = 0 ) : Expression( _aname ) {}
+    SolvedTupleExpr( std::list<Expression *> &, Expression *_aname = 0 );
+    SolvedTupleExpr( const SolvedTupleExpr &other );
+    virtual ~SolvedTupleExpr() {}
+    std::list<Expression*> &get_exprs() { return exprs; }
+    virtual SolvedTupleExpr *clone() const { return new SolvedTupleExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    std::list<Expression*> exprs;
+class SolvedTupleExpr : public Expression {
+  public:
+        SolvedTupleExpr( Expression *_aname = 0 ) : Expression( _aname ) {}
+        SolvedTupleExpr( std::list<Expression *> &, Expression *_aname = 0 );
+        SolvedTupleExpr( const SolvedTupleExpr &other );
+        virtual ~SolvedTupleExpr() {}
+        std::list<Expression*> &get_exprs() { return exprs; }
+        virtual SolvedTupleExpr *clone() const { return new SolvedTupleExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::list<Expression*> exprs;
 };
 // TypeExpr represents a type used in an expression (e.g. as a type generator parameter)
+class TypeExpr : public Expression
+{
+public:
+    TypeExpr( Type *type );
+    TypeExpr( const TypeExpr &other );
+    virtual ~TypeExpr();
+    Type *get_type() const { return type; }
+    void set_type( Type *newValue ) { type = newValue; }
+    virtual TypeExpr *clone() const { return new TypeExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Type *type;
+class TypeExpr : public Expression {
+  public:
+        TypeExpr( Type *type );
+        TypeExpr( const TypeExpr &other );
+        virtual ~TypeExpr();
+        Type *get_type() const { return type; }
+        void set_type( Type *newValue ) { type = newValue; }
+        virtual TypeExpr *clone() const { return new TypeExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Type *type;
 };
 // ValofExpr represents a GCC 'lambda expression'
+class UntypedValofExpr : public Expression
+{
+public:
+    UntypedValofExpr( Statement *_body, Expression *_aname = 0 ) : Expression( _aname ), body ( _body ) {}
+    virtual ~UntypedValofExpr() {}
+    Expression *get_value();
+    Statement *get_body() const { return body; }
+    virtual UntypedValofExpr *clone() const { return new UntypedValofExpr( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+private:
+    Statement *body;
+};
+#endif /* #ifndef EXPRESSION_H */
+/*
+    Local Variables:
+    mode: c++
+    End:
+*/
+class UntypedValofExpr : public Expression {
+  public:
+        UntypedValofExpr( Statement *_body, Expression *_aname = 0 ) : Expression( _aname ), body ( _body ) {}
+        virtual ~UntypedValofExpr() {}
+        Expression *get_value();
+        Statement *get_body() const { return body; }
+        virtual UntypedValofExpr *clone() const { return new UntypedValofExpr( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Expression *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Statement *body;
+};
+#endif // EXPRESSION_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/FunctionDecl.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// FunctionDecl.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 08:48:46 2015
+// Update Count     : 1
+//
 #include <cassert>
 …
 #include "utility.h"
 FunctionDecl::FunctionDecl( const std::string &name, StorageClass sc, LinkageSpec::Type linkage, FunctionType *type, CompoundStmt *statements, bool isInline )
         : Parent( name, sc, linkage ), type( type ), statements( statements ), isInline( isInline ) {
     // this is a brazen hack to force the function "main" to have C linkage
     if ( name == "main" ) {
         set_linkage( LinkageSpec::C );
+    }
+        // this is a brazen hack to force the function "main" to have C linkage
+        if ( name == "main" ) {
+                set_linkage( LinkageSpec::C );
+        } // if
+}
 FunctionDecl::FunctionDecl( const FunctionDecl &other )
     : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ), isInline( other.isInline ) {
+        : Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ), isInline( other.isInline ) {
+}
 FunctionDecl::~FunctionDecl() {
     delete type;
     delete statements;
+        delete type;
+        delete statements;
+}
 Type * FunctionDecl::get_type() const {
     return type;
+        return type;
+}
 void FunctionDecl::set_type( Type *t ) {
     type = dynamic_cast< FunctionType* >( t );
     assert( type );
+        type = dynamic_cast< FunctionType* >( t );
+        assert( type );
+}
 void FunctionDecl::print( std::ostream &os, int indent ) const {
     using std::endl;
     using std::string;
     if ( get_name() != "" ) {
         os << get_name() << ": a ";
+    }
     if ( get_linkage() != LinkageSpec::Cforall ) {
         os << LinkageSpec::toString( get_linkage() ) << " ";
+    }
     if ( isInline ) {
         os << "inline ";
+    }
     if ( get_storageClass() != NoStorageClass ) {
         os << storageClassName[ get_storageClass() ] << ' ';
+    }
     if ( get_type() ) {
         get_type()->print( os, indent );
     } else {
         os << "untyped entity ";
+    }
     if ( ! oldIdents.empty() ) {
         os << string( indent+2, ' ' ) << "with parameter names" << endl;
         for ( std::list< std::string >::const_iterator i = oldIdents.begin(); i != oldIdents.end(); ++i ) {
             os << string( indent+4, ' ' ) << *i << endl;
+        }
+    }
     if ( ! oldDecls.empty() ) {
         os << string( indent+2, ' ' ) << "with parameter declarations" << endl;
         printAll( oldDecls, os, indent+4 );
+    }
     if ( statements ) {
         os << string( indent+2, ' ' ) << "with body " << endl;
         statements->print( os, indent+4 );
+    }
+        using std::endl;
+        using std::string;
+        if ( get_name() != "" ) {
+                os << get_name() << ": a ";
+        } // if
+        if ( get_linkage() != LinkageSpec::Cforall ) {
+                os << LinkageSpec::toString( get_linkage() ) << " ";
+        } // if
+        if ( isInline ) {
+                os << "inline ";
+        } // if
+        if ( get_storageClass() != NoStorageClass ) {
+                os << storageClassName[ get_storageClass() ] << ' ';
+        } // if
+        if ( get_type() ) {
+                get_type()->print( os, indent );
+        } else {
+                os << "untyped entity ";
+        } // if
+        if ( ! oldIdents.empty() ) {
+                os << string( indent+2, ' ' ) << "with parameter names" << endl;
+                for ( std::list< std::string >::const_iterator i = oldIdents.begin(); i != oldIdents.end(); ++i ) {
+                        os << string( indent+4, ' ' ) << *i << endl;
+                } // for
+        } // if
+        if ( ! oldDecls.empty() ) {
+                os << string( indent+2, ' ' ) << "with parameter declarations" << endl;
+                printAll( oldDecls, os, indent+4 );
+        } // if
+        if ( statements ) {
+                os << string( indent+2, ' ' ) << "with body " << endl;
+                statements->print( os, indent+4 );
+        } // if
+}
 void FunctionDecl::printShort( std::ostream &os, int indent ) const {
     using std::endl;
     using std::string;
     if ( get_name() != "" ) {
         os << get_name() << ": a ";
+    }
     if ( isInline ) {
         os << "inline ";
+    }
     if ( get_storageClass() != NoStorageClass ) {
         os << storageClassName[ get_storageClass() ] << ' ';
+    }
     if ( get_type() ) {
         get_type()->print( os, indent );
     } else {
         os << "untyped entity ";
+    }
+        using std::endl;
+        using std::string;
+        if ( get_name() != "" ) {
+                os << get_name() << ": a ";
+        } // if
+        if ( isInline ) {
+                os << "inline ";
+        } // if
+        if ( get_storageClass() != NoStorageClass ) {
+                os << storageClassName[ get_storageClass() ] << ' ';
+        } // if
+        if ( get_type() ) {
+                get_type()->print( os, indent );
+        } else {
+                os << "untyped entity ";
+        } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/FunctionType.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// FunctionType.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 09:01:28 2015
+// Update Count     : 1
+//
 #include <algorithm>
 …
 #include "utility.h"
 FunctionType::FunctionType( const Type::Qualifiers &tq, bool isVarArgs ) : Type( tq ), isVarArgs( isVarArgs ) {
+}
 FunctionType::FunctionType( const FunctionType &other ) : Type( other ), isVarArgs( other.isVarArgs ) {
     cloneAll( other.returnVals, returnVals );
     cloneAll( other.parameters, parameters );
+        cloneAll( other.returnVals, returnVals );
+        cloneAll( other.parameters, parameters );
+}
 FunctionType::~FunctionType() {
     deleteAll( returnVals );
     deleteAll( parameters );
+        deleteAll( returnVals );
+        deleteAll( parameters );
+}
 void FunctionType::print( std::ostream &os, int indent ) const {
     using std::string;
     using std::endl;
+        using std::string;
+        using std::endl;
     Type::print( os, indent );
     os << "function" << endl;
     if ( ! parameters.empty() ) {
         os << string( indent + 2, ' ' ) << "with parameters" << endl;
         printAll( parameters, os, indent + 4 );
         if ( isVarArgs ) {
             os << string( indent + 4, ' ' ) << "and a variable number of other arguments" << endl;
+        }
     } else if ( isVarArgs ) {
         os << string( indent + 4, ' ' ) << "accepting unspecified arguments" << endl;
+    }
     os << string( indent + 2, ' ' ) << "returning ";
     if ( returnVals.empty() ) {
         os << endl << string( indent + 4, ' ' ) << "nothing " << endl;
     } else {
         os << endl;
         printAll( returnVals, os, indent + 4 );
+    }
+        Type::print( os, indent );
+        os << "function" << endl;
+        if ( ! parameters.empty() ) {
+                os << string( indent + 2, ' ' ) << "with parameters" << endl;
+                printAll( parameters, os, indent + 4 );
+                if ( isVarArgs ) {
+                        os << string( indent + 4, ' ' ) << "and a variable number of other arguments" << endl;
+                } // if
+        } else if ( isVarArgs ) {
+                os << string( indent + 4, ' ' ) << "accepting unspecified arguments" << endl;
+        } // if
+        os << string( indent + 2, ' ' ) << "returning ";
+        if ( returnVals.empty() ) {
+                os << endl << string( indent + 4, ' ' ) << "nothing " << endl;
+        } else {
+                os << endl;
+                printAll( returnVals, os, indent + 4 );
+        } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Initializer.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Initializer.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 09:02:45 2015
+// Update Count     : 2
+//
 #include "Initializer.h"
 #include "Expression.h"
 #include "utility.h"
 Initializer::Initializer() {}
 …
 std::string Initializer::designator_name( Expression *des ) {
     if ( NameExpr *n = dynamic_cast<NameExpr *>(des) )
         return n->get_name();
     else
         throw 0;
+        if ( NameExpr *n = dynamic_cast<NameExpr *>(des) )
+                return n->get_name();
+        else
+                throw 0;
+}
 …
 SingleInit::SingleInit( const SingleInit &other ) : value ( other.value ) {
     cloneAll(other.designators, designators );
+        cloneAll(other.designators, designators );
+}
 …
 void SingleInit::print( std::ostream &os, int indent ) {
     os << std::endl << std::string(indent, ' ' ) << "Simple Initializer: ";
     value->print( os, indent+2 );
+        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 );
+        } // if
+}
 ListInit::ListInit( std::list<Initializer*> &_initializers, std::list<Expression *> &_designators )
     : initializers( _initializers ), designators( _designators ) {
+        : initializers( _initializers ), designators( _designators ) {
+}
 …
 ListInit *ListInit::clone() const {
     return new ListInit( *this );
+        return new ListInit( *this );
+}
 void ListInit::print( std::ostream &os, int indent ) {
     os << std::endl << std::string(indent, ' ') << "Compound initializer:  ";
     if ( ! designators.empty() ) {
         os << std::string(indent + 2, ' ' ) << "designated by: [";
         for ( std::list < Expression * >::iterator i = designators.begin();
                     i != designators.end(); i++ ) {
             ( *i )->print(os, indent + 4 );
+        }
+        os << std::endl << std::string(indent, ' ') << "Compound initializer:  ";
+        if ( ! designators.empty() ) {
+                os << std::string(indent + 2, ' ' ) << "designated by: [";
+                for ( std::list < Expression * >::iterator i = designators.begin();
+                          i != designators.end(); i++ ) {
+                        ( *i )->print(os, indent + 4 );
+                } // for
         os << std::string(indent + 2, ' ' ) << "]";
+    }
+                os << std::string(indent + 2, ' ' ) << "]";
+        } // if
     for ( std::list<Initializer *>::iterator i = initializers.begin(); i != initializers.end(); i++ )
         (*i)->print( os, indent + 2 );
+        for ( std::list<Initializer *>::iterator i = initializers.begin(); i != initializers.end(); i++ )
+                (*i)->print( os, indent + 2 );
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Initializer.h

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Initializer.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 09:03:48 2015
+// Update Count     : 1
+//
 #ifndef INITIALIZER_H
 #define INITIALIZER_H
 …
 #include <cassert>
 // Initializer: base class for object initializers (provide default values)
 class Initializer {
   public:
     //  Initializer( std::string _name = std::string(""), int _pos = 0 );
     Initializer( );
     virtual ~Initializer();
+        //      Initializer( std::string _name = std::string(""), int _pos = 0 );
+        Initializer( );
+        virtual ~Initializer();
     static std::string designator_name( Expression *designator );
+        static std::string designator_name( Expression *designator );
     //  void set_name( std::string newValue ) { name = newValue; }
     //  std::string get_name() const { return name; }
+        //      void set_name( std::string newValue ) { name = newValue; }
+        //      std::string get_name() const { return name; }
     //  void set_pos( int newValue ) { pos = newValue; }
     //  int get_pos() const { return pos; }
     virtual void set_designators( std::list<Expression *> & ) { assert(false); }
     virtual std::list<Expression *> &get_designators() {
         assert(false);
         std::list<Expression *> *ret = 0; return *ret;  // never reached
+    }
+        //      void set_pos( int newValue ) { pos = newValue; }
+        //      int get_pos() const { return pos; }
+        virtual void set_designators( std::list<Expression *> & ) { assert(false); }
+        virtual std::list<Expression *> &get_designators() {
+                assert(false);
+                std::list<Expression *> *ret = 0; return *ret;  // never reached
+        }
     virtual Initializer *clone() const = 0;
     virtual void accept( Visitor &v ) = 0;
     virtual Initializer *acceptMutator( Mutator &m ) = 0;
     virtual void print( std::ostream &os, int indent = 0 );
+        virtual Initializer *clone() const = 0;
+        virtual void accept( Visitor &v ) = 0;
+        virtual Initializer *acceptMutator( Mutator &m ) = 0;
+        virtual void print( std::ostream &os, int indent = 0 );
   private:
     //  std::string name;
     //  int pos;
+        //      std::string name;
+        //      int pos;
 };
 …
 class SingleInit : public Initializer {
   public:
     SingleInit( Expression *value, std::list< Expression *> &designators );
     SingleInit( const SingleInit &other );
     virtual ~SingleInit();
     Expression *get_value() { return value; }
     void set_value( Expression *newValue ) { value = newValue; }
+        SingleInit( Expression *value, std::list< Expression *> &designators );
+        SingleInit( const SingleInit &other );
+        virtual ~SingleInit();
+        Expression *get_value() { return value; }
+        void set_value( Expression *newValue ) { value = newValue; }
     void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
     std::list<Expression *> &get_designators() { return designators; }
+        void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
+        std::list<Expression *> &get_designators() { return designators; }
     virtual SingleInit *clone() const;
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 );
+        virtual SingleInit *clone() const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
   private:
     //Constant *value;
     Expression *value;  // has to be a compile-time constant
     std::list< Expression * > designators;
+        //Constant *value;
+        Expression *value;      // has to be a compile-time constant
+        std::list< Expression * > designators;
 };
 …
 class ListInit : public Initializer {
   public:
     ListInit( std::list<Initializer*> &,
               std::list<Expression *> &designators = *(new std::list<Expression *>()) );
     virtual ~ListInit();
+        ListInit( std::list<Initializer*> &,
+                          std::list<Expression *> &designators = *(new std::list<Expression *>()) );
+        virtual ~ListInit();
     void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
     std::list<Expression *> &get_designators() { return designators; }
     void set_initializers( std::list<Initializer*> &newValue ) { initializers = newValue; }
     std::list<Initializer*> &get_initializers() { return initializers; }
+        void set_designators( std::list<Expression *> &newValue ) { designators = newValue; }
+        std::list<Expression *> &get_designators() { return designators; }
+        void set_initializers( std::list<Initializer*> &newValue ) { initializers = newValue; }
+        std::list<Initializer*> &get_initializers() { return initializers; }
     std::list<Initializer*>::iterator begin_initializers() { return initializers.begin(); }
     std::list<Initializer*>::iterator end_initializers() { return initializers.end(); }
+        std::list<Initializer*>::iterator begin_initializers() { return initializers.begin(); }
+        std::list<Initializer*>::iterator end_initializers() { return initializers.end(); }
     virtual ListInit *clone() const;
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 );
+        virtual ListInit *clone() const;
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Initializer *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
   private:
     std::list<Initializer*> initializers;  // order *is* important
     std::list<Expression *> designators;
+        std::list<Initializer*> initializers;  // order *is* important
+        std::list<Expression *> designators;
 };
 #endif // INITIALIZER_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Mutator.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Mutator.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 10:10:46 2015
+// Update Count     : 1
+//
 #include <cassert>
 #include "Mutator.h"
 …
 ObjectDecl *Mutator::mutate( ObjectDecl *objectDecl ) {
     objectDecl->set_type( maybeMutate( objectDecl->get_type(), *this ) );
     objectDecl->set_init( maybeMutate( objectDecl->get_init(), *this ) );
     objectDecl->set_bitfieldWidth( maybeMutate( objectDecl->get_bitfieldWidth(), *this ) );
     return objectDecl;
+        objectDecl->set_type( maybeMutate( objectDecl->get_type(), *this ) );
+        objectDecl->set_init( maybeMutate( objectDecl->get_init(), *this ) );
+        objectDecl->set_bitfieldWidth( maybeMutate( objectDecl->get_bitfieldWidth(), *this ) );
+        return objectDecl;
+}
 DeclarationWithType *Mutator::mutate( FunctionDecl *functionDecl ) {
     functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
     mutateAll( functionDecl->get_oldDecls(), *this );
     functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
     return functionDecl;
+        functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
+        mutateAll( functionDecl->get_oldDecls(), *this );
+        functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+        return functionDecl;
+}
 Declaration *Mutator::handleAggregateDecl( AggregateDecl *aggregateDecl ) {
     mutateAll( aggregateDecl->get_parameters(), *this );
     mutateAll( aggregateDecl->get_members(), *this );
     return aggregateDecl;
+        mutateAll( aggregateDecl->get_parameters(), *this );
+        mutateAll( aggregateDecl->get_members(), *this );
+        return aggregateDecl;
+}
 Declaration *Mutator::mutate( StructDecl *aggregateDecl ) {
     handleAggregateDecl( aggregateDecl );
     return aggregateDecl;
+        handleAggregateDecl( aggregateDecl );
+        return aggregateDecl;
+}
 Declaration *Mutator::mutate( UnionDecl *aggregateDecl ) {
     handleAggregateDecl( aggregateDecl );
     return aggregateDecl;
+        handleAggregateDecl( aggregateDecl );
+        return aggregateDecl;
+}
 Declaration *Mutator::mutate( EnumDecl *aggregateDecl ) {
     handleAggregateDecl( aggregateDecl );
     return aggregateDecl;
+        handleAggregateDecl( aggregateDecl );
+        return aggregateDecl;
+}
 Declaration *Mutator::mutate( ContextDecl *aggregateDecl ) {
     handleAggregateDecl( aggregateDecl );
     return aggregateDecl;
+        handleAggregateDecl( aggregateDecl );
+        return aggregateDecl;
+}
 Declaration *Mutator::handleNamedTypeDecl( NamedTypeDecl *typeDecl ) {
     mutateAll( typeDecl->get_parameters(), *this );
     mutateAll( typeDecl->get_assertions(), *this );
     typeDecl->set_base( maybeMutate( typeDecl->get_base(), *this ) );
     return typeDecl;
+        mutateAll( typeDecl->get_parameters(), *this );
+        mutateAll( typeDecl->get_assertions(), *this );
+        typeDecl->set_base( maybeMutate( typeDecl->get_base(), *this ) );
+        return typeDecl;
+}
 TypeDecl *Mutator::mutate( TypeDecl *typeDecl ) {
     handleNamedTypeDecl( typeDecl );
     return typeDecl;
+        handleNamedTypeDecl( typeDecl );
+        return typeDecl;
+}
 Declaration *Mutator::mutate( TypedefDecl *typeDecl ) {
     handleNamedTypeDecl( typeDecl );
     return typeDecl;
+        handleNamedTypeDecl( typeDecl );
+        return typeDecl;
+}
 CompoundStmt *Mutator::mutate( CompoundStmt *compoundStmt ) {
     mutateAll( compoundStmt->get_kids(), *this );
     return compoundStmt;
+        mutateAll( compoundStmt->get_kids(), *this );
+        return compoundStmt;
+}
 Statement *Mutator::mutate( ExprStmt *exprStmt ) {
     exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
     return 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 ) );
     return 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 ) );
     return 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 ) );
     return 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 ) {
     switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
     mutateAll( switchStmt->get_branches(), *this );
     return switchStmt;
+        switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
+        mutateAll( switchStmt->get_branches(), *this );
+        return switchStmt;
+}
 Statement *Mutator::mutate( ChooseStmt *switchStmt ) {
     switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
     mutateAll( switchStmt->get_branches(), *this );
     return switchStmt;
+        switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) );
+        mutateAll( switchStmt->get_branches(), *this );
+        return switchStmt;
+}
 Statement *Mutator::mutate( FallthruStmt *fallthruStmt ) {
     return fallthruStmt;
+        return fallthruStmt;
+}
 Statement *Mutator::mutate( CaseStmt *caseStmt ) {
     caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
     mutateAll (caseStmt->get_statements(), *this );
     return caseStmt;
+        caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
+        mutateAll (caseStmt->get_statements(), *this );
+        return caseStmt;
+}
 Statement *Mutator::mutate( BranchStmt *branchStmt ) {
     return branchStmt;
+        return branchStmt;
+}
 Statement *Mutator::mutate( ReturnStmt *returnStmt ) {
     returnStmt->set_expr( maybeMutate( returnStmt->get_expr(), *this ) );
     return returnStmt;
+        returnStmt->set_expr( maybeMutate( returnStmt->get_expr(), *this ) );
+        return returnStmt;
+}
 Statement *Mutator::mutate( TryStmt *tryStmt ) {
     tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
     mutateAll( tryStmt->get_catchers(), *this );
     return tryStmt;
+        tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) );
+        mutateAll( tryStmt->get_catchers(), *this );
+        return tryStmt;
+}
 Statement *Mutator::mutate( CatchStmt *catchStmt ) {
     catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
     catchStmt->set_body( maybeMutate( catchStmt->get_body(), *this ) );
     return catchStmt;
+        catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) );
+        catchStmt->set_body( maybeMutate( catchStmt->get_body(), *this ) );
+        return catchStmt;
+}
 Statement *Mutator::mutate( FinallyStmt *finalStmt ) {
     finalStmt->set_block( maybeMutate( finalStmt->get_block(), *this ) );
     return finalStmt;
+        finalStmt->set_block( maybeMutate( finalStmt->get_block(), *this ) );
+        return finalStmt;
+}
 NullStmt *Mutator::mutate( NullStmt *nullStmt ) {
     return nullStmt;
+        return nullStmt;
+}
 Statement *Mutator::mutate( DeclStmt *declStmt ) {
     declStmt->set_decl( maybeMutate( declStmt->get_decl(), *this ) );
     return declStmt;
+        declStmt->set_decl( maybeMutate( declStmt->get_decl(), *this ) );
+        return declStmt;
+}
 Expression *Mutator::mutate( ApplicationExpr *applicationExpr ) {
     mutateAll( applicationExpr->get_results(), *this );
     applicationExpr->set_function( maybeMutate( applicationExpr->get_function(), *this ) );
     mutateAll( applicationExpr->get_args(), *this );
     return applicationExpr;
+        mutateAll( applicationExpr->get_results(), *this );
+        applicationExpr->set_function( maybeMutate( applicationExpr->get_function(), *this ) );
+        mutateAll( applicationExpr->get_args(), *this );
+        return applicationExpr;
+}
 Expression *Mutator::mutate( UntypedExpr *untypedExpr ) {
     mutateAll( untypedExpr->get_results(), *this );
     mutateAll( untypedExpr->get_args(), *this );
     return untypedExpr;
+        mutateAll( untypedExpr->get_results(), *this );
+        mutateAll( untypedExpr->get_args(), *this );
+        return untypedExpr;
+}
 Expression *Mutator::mutate( NameExpr *nameExpr ) {
     mutateAll( nameExpr->get_results(), *this );
     return nameExpr;
+        mutateAll( nameExpr->get_results(), *this );
+        return nameExpr;
+}
 Expression *Mutator::mutate( AddressExpr *addressExpr ) {
     mutateAll( addressExpr->get_results(), *this );
     addressExpr->set_arg( maybeMutate( addressExpr->get_arg(), *this ) );
     return addressExpr;
+        mutateAll( addressExpr->get_results(), *this );
+        addressExpr->set_arg( maybeMutate( addressExpr->get_arg(), *this ) );
+        return addressExpr;
+}
 Expression *Mutator::mutate( LabelAddressExpr *labelAddressExpr ) {
     mutateAll( labelAddressExpr->get_results(), *this );
     labelAddressExpr->set_arg( maybeMutate( labelAddressExpr->get_arg(), *this ) );
     return labelAddressExpr;
+        mutateAll( labelAddressExpr->get_results(), *this );
+        labelAddressExpr->set_arg( maybeMutate( labelAddressExpr->get_arg(), *this ) );
+        return labelAddressExpr;
+}
 Expression *Mutator::mutate( CastExpr *castExpr ) {
     mutateAll( castExpr->get_results(), *this );
     castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
     return castExpr;
+        mutateAll( castExpr->get_results(), *this );
+        castExpr->set_arg( maybeMutate( castExpr->get_arg(), *this ) );
+        return castExpr;
+}
 Expression *Mutator::mutate( UntypedMemberExpr *memberExpr ) {
     mutateAll( memberExpr->get_results(), *this );
     memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
     return memberExpr;
+        mutateAll( memberExpr->get_results(), *this );
+        memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
+        return memberExpr;
+}
 Expression *Mutator::mutate( MemberExpr *memberExpr ) {
     mutateAll( memberExpr->get_results(), *this );
     memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
     return memberExpr;
+        mutateAll( memberExpr->get_results(), *this );
+        memberExpr->set_aggregate( maybeMutate( memberExpr->get_aggregate(), *this ) );
+        return memberExpr;
+}
 Expression *Mutator::mutate( VariableExpr *variableExpr ) {
     mutateAll( variableExpr->get_results(), *this );
     return variableExpr;
+        mutateAll( variableExpr->get_results(), *this );
+        return variableExpr;
+}
 Expression *Mutator::mutate( ConstantExpr *constantExpr ) {
     mutateAll( constantExpr->get_results(), *this );
+        mutateAll( constantExpr->get_results(), *this );
 //  maybeMutate( constantExpr->get_constant(), *this )
     return constantExpr;
+        return constantExpr;
+}
 Expression *Mutator::mutate( SizeofExpr *sizeofExpr ) {
     mutateAll( sizeofExpr->get_results(), *this );
     if ( sizeofExpr->get_isType() ) {
         sizeofExpr->set_type( maybeMutate( sizeofExpr->get_type(), *this ) );
     } else {
         sizeofExpr->set_expr( maybeMutate( sizeofExpr->get_expr(), *this ) );
+    }
     return sizeofExpr;
+        mutateAll( sizeofExpr->get_results(), *this );
+        if ( sizeofExpr->get_isType() ) {
+                sizeofExpr->set_type( maybeMutate( sizeofExpr->get_type(), *this ) );
+        } else {
+                sizeofExpr->set_expr( maybeMutate( sizeofExpr->get_expr(), *this ) );
+        }
+        return sizeofExpr;
+}
 Expression *Mutator::mutate( AttrExpr *attrExpr ) {
     mutateAll( attrExpr->get_results(), *this );
     if ( attrExpr->get_isType() ) {
         attrExpr->set_type( maybeMutate( attrExpr->get_type(), *this ) );
     } else {
         attrExpr->set_expr( maybeMutate( attrExpr->get_expr(), *this ) );
+    }
     return attrExpr;
+        mutateAll( attrExpr->get_results(), *this );
+        if ( attrExpr->get_isType() ) {
+                attrExpr->set_type( maybeMutate( attrExpr->get_type(), *this ) );
+        } else {
+                attrExpr->set_expr( maybeMutate( attrExpr->get_expr(), *this ) );
+        }
+        return attrExpr;
+}
 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 ) );
     return logicalExpr;
+        mutateAll( logicalExpr->get_results(), *this );
+        logicalExpr->set_arg1( maybeMutate( logicalExpr->get_arg1(), *this ) );
+        logicalExpr->set_arg2( maybeMutate( logicalExpr->get_arg2(), *this ) );
+        return logicalExpr;
+}
 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 ) );
     return 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 ) );
+        return conditionalExpr;
+}
 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 ) );
     return commaExpr;
+        mutateAll( commaExpr->get_results(), *this );
+        commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
+        commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
+        return commaExpr;
+}
 Expression *Mutator::mutate( TupleExpr *tupleExpr ) {
     mutateAll( tupleExpr->get_results(), *this );
     mutateAll( tupleExpr->get_exprs(), *this );
     return tupleExpr;
+        mutateAll( tupleExpr->get_results(), *this );
+        mutateAll( tupleExpr->get_exprs(), *this );
+        return tupleExpr;
+}
 Expression *Mutator::mutate( SolvedTupleExpr *tupleExpr ) {
     mutateAll( tupleExpr->get_results(), *this );
     mutateAll( tupleExpr->get_exprs(), *this );
     return tupleExpr;
+        mutateAll( tupleExpr->get_results(), *this );
+        mutateAll( tupleExpr->get_exprs(), *this );
+        return tupleExpr;
+}
 Expression *Mutator::mutate( TypeExpr *typeExpr ) {
     mutateAll( typeExpr->get_results(), *this );
     typeExpr->set_type( maybeMutate( typeExpr->get_type(), *this ) );
     return typeExpr;
+        mutateAll( typeExpr->get_results(), *this );
+        typeExpr->set_type( maybeMutate( typeExpr->get_type(), *this ) );
+        return typeExpr;
+}
 Expression *Mutator::mutate( UntypedValofExpr *valofExpr ) {
     mutateAll( valofExpr->get_results(), *this );
     return valofExpr;
+        mutateAll( valofExpr->get_results(), *this );
+        return valofExpr;
+}
 Type *Mutator::mutate( VoidType *voidType ) {
     mutateAll( voidType->get_forall(), *this );
     return voidType;
+        mutateAll( voidType->get_forall(), *this );
+        return voidType;
+}
 Type *Mutator::mutate( BasicType *basicType ) {
     mutateAll( basicType->get_forall(), *this );
     return basicType;
+        mutateAll( basicType->get_forall(), *this );
+        return basicType;
+}
 Type *Mutator::mutate( PointerType *pointerType ) {
     mutateAll( pointerType->get_forall(), *this );
     pointerType->set_base( maybeMutate( pointerType->get_base(), *this ) );
     return pointerType;
+        mutateAll( pointerType->get_forall(), *this );
+        pointerType->set_base( maybeMutate( pointerType->get_base(), *this ) );
+        return pointerType;
+}
 Type *Mutator::mutate( ArrayType *arrayType ) {
     mutateAll( arrayType->get_forall(), *this );
     arrayType->set_dimension( maybeMutate( arrayType->get_dimension(), *this ) );
     arrayType->set_base( maybeMutate( arrayType->get_base(), *this ) );
     return arrayType;
+        mutateAll( arrayType->get_forall(), *this );
+        arrayType->set_dimension( maybeMutate( arrayType->get_dimension(), *this ) );
+        arrayType->set_base( maybeMutate( arrayType->get_base(), *this ) );
+        return arrayType;
+}
 Type *Mutator::mutate( FunctionType *functionType ) {
     mutateAll( functionType->get_forall(), *this );
     mutateAll( functionType->get_returnVals(), *this );
     mutateAll( functionType->get_parameters(), *this );
     return functionType;
+        mutateAll( functionType->get_forall(), *this );
+        mutateAll( functionType->get_returnVals(), *this );
+        mutateAll( functionType->get_parameters(), *this );
+        return functionType;
+}
 Type *Mutator::handleReferenceToType( ReferenceToType *aggregateUseType ) {
     mutateAll( aggregateUseType->get_forall(), *this );
     mutateAll( aggregateUseType->get_parameters(), *this );
     return aggregateUseType;
+        mutateAll( aggregateUseType->get_forall(), *this );
+        mutateAll( aggregateUseType->get_parameters(), *this );
+        return aggregateUseType;
+}
 Type *Mutator::mutate( StructInstType *aggregateUseType ) {
     handleReferenceToType( aggregateUseType );
     return aggregateUseType;
+        handleReferenceToType( aggregateUseType );
+        return aggregateUseType;
+}
 Type *Mutator::mutate( UnionInstType *aggregateUseType ) {
     handleReferenceToType( aggregateUseType );
     return aggregateUseType;
+        handleReferenceToType( aggregateUseType );
+        return aggregateUseType;
+}
 Type *Mutator::mutate( EnumInstType *aggregateUseType ) {
     handleReferenceToType( aggregateUseType );
     return aggregateUseType;
+        handleReferenceToType( aggregateUseType );
+        return aggregateUseType;
+}
 Type *Mutator::mutate( ContextInstType *aggregateUseType ) {
     handleReferenceToType( aggregateUseType );
     mutateAll( aggregateUseType->get_members(), *this );
     return aggregateUseType;
+        handleReferenceToType( aggregateUseType );
+        mutateAll( aggregateUseType->get_members(), *this );
+        return aggregateUseType;
+}
 Type *Mutator::mutate( TypeInstType *aggregateUseType ) {
     handleReferenceToType( aggregateUseType );
     return aggregateUseType;
+        handleReferenceToType( aggregateUseType );
+        return aggregateUseType;
+}
 Type *Mutator::mutate( TupleType *tupleType ) {
     mutateAll( tupleType->get_forall(), *this );
     mutateAll( tupleType->get_types(), *this );
     return tupleType;
+        mutateAll( tupleType->get_forall(), *this );
+        mutateAll( tupleType->get_types(), *this );
+        return tupleType;
+}
 Type *Mutator::mutate( TypeofType *typeofType ) {
     assert( typeofType->get_expr() );
     typeofType->set_expr( typeofType->get_expr()->acceptMutator( *this ) );
     return typeofType;
+        assert( typeofType->get_expr() );
+        typeofType->set_expr( typeofType->get_expr()->acceptMutator( *this ) );
+        return typeofType;
+}
 Type *Mutator::mutate( AttrType *attrType ) {
     if ( attrType->get_isType() ) {
         assert( attrType->get_type() );
         attrType->set_type( attrType->get_type()->acceptMutator( *this ) );
     } else {
         assert( attrType->get_expr() );
         attrType->set_expr( attrType->get_expr()->acceptMutator( *this ) );
+    }
     return attrType;
+        if ( attrType->get_isType() ) {
+                assert( attrType->get_type() );
+                attrType->set_type( attrType->get_type()->acceptMutator( *this ) );
+        } else {
+                assert( attrType->get_expr() );
+                attrType->set_expr( attrType->get_expr()->acceptMutator( *this ) );
+        }
+        return attrType;
+}
 Initializer *Mutator::mutate( SingleInit *singleInit ) {
     singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
     return singleInit;
+        singleInit->set_value( singleInit->get_value()->acceptMutator( *this ) );
+        return singleInit;
+}
 Initializer *Mutator::mutate( ListInit *listInit ) {
     mutateAll( listInit->get_designators(), *this );
     mutateAll( listInit->get_initializers(), *this );
     return listInit;
+        mutateAll( listInit->get_designators(), *this );
+        mutateAll( listInit->get_initializers(), *this );
+        return listInit;
+}
 Subrange *Mutator::mutate( Subrange *subrange ) {
     return subrange;
+        return subrange;
+}
 Constant *Mutator::mutate( Constant *constant ) {
+    return constant;
+}
+        return constant;
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Mutator.h

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Mutator.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 10:12:28 2015
+// Update Count     : 3
+//
 #include <cassert>
 …
 #include "SemanticError.h"
 #ifndef SYNTREE_MUTATOR_H
 #define SYNTREE_MUTATOR_H
+#ifndef MUTATOR_H
+#define MUTATOR_H
 class Mutator {
   protected:
     Mutator();
     virtual ~Mutator();
+        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 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( SingleInit *singleInit );
     virtual Initializer* mutate( ListInit *listInit );
+        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 );
+        virtual Constant *mutate( Constant *constant );
   private:
     virtual Declaration* handleAggregateDecl(AggregateDecl *aggregateDecl );
     virtual Declaration* handleNamedTypeDecl(NamedTypeDecl *typeDecl );
     virtual Type* handleReferenceToType(ReferenceToType *aggregateUseType );
+        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;
+        if ( tree ) {
+                TreeType *newnode = dynamic_cast< TreeType* >( tree->acceptMutator( mutator ) );
+                assert( newnode );
+                return newnode;
 ///         return tree->acceptMutator( mutator );
     } else {
         return 0;
+    }
+        } else {
+                return 0;
+        } // if
+}
 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 ) {
+        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;
+    }
+                                *i = dynamic_cast< typename Container::value_type >( (*i)->acceptMutator( mutator ) );
+                                assert( *i );
+                        } // if
+                } catch( SemanticError &e ) {
+                        errors.append( e );
+                } // try
+        } // for
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        } // if
+}
 #endif // SYNTREE_MUTATOR_H
+#endif // MUTATOR_H
 // Local Variables: //
+// tab-width: 4 //
 // mode: c++ //
+// End:  //
+// compile-command: "make install" //
+// End: //

translator/SynTree/NamedTypeDecl.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// NamedTypeDecl.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 10:13:19 2015
+// Update Count     : 1
+//
 #include "Declaration.h"
 #include "Type.h"
 #include "utility.h"
 NamedTypeDecl::NamedTypeDecl( const std::string &name, StorageClass sc, Type *base )
+    : Parent( name, sc, LinkageSpec::Cforall ), base( base )
+{}
+        : Parent( name, sc, LinkageSpec::Cforall ), base( base ) {}
 NamedTypeDecl::NamedTypeDecl( const TypeDecl &other )
+    : Parent( other ), base( maybeClone( other.base ) )
+{
+    cloneAll( other.parameters, parameters );
+    cloneAll( other.assertions, assertions );
+        : Parent( other ), base( maybeClone( other.base ) ) {
+        cloneAll( other.parameters, parameters );
+        cloneAll( other.assertions, assertions );
+}
 NamedTypeDecl::~NamedTypeDecl() {
     delete base;
     deleteAll( parameters );
     deleteAll( assertions );
+        delete base;
+        deleteAll( parameters );
+        deleteAll( assertions );
+}
 void NamedTypeDecl::print( std::ostream &os, int indent ) const {
     using namespace std;
     if ( get_name() != "" ) {
         os << get_name() << ": a ";
     } // if
     if ( get_storageClass() != NoStorageClass ) {
         os << storageClassName[ get_storageClass() ] << ' ';
     } // if
     os << typeString();
     if ( base ) {
         os << " for ";
         base->print( os, indent );
     } // if
     if ( ! parameters.empty() ) {
         os << endl << string( indent, ' ' ) << "with parameters" << endl;
         printAll( parameters, os, indent+2 );
     } // if
     if ( ! assertions.empty() ) {
         os << endl << string( indent, ' ' ) << "with assertions" << endl;
         printAll( assertions, os, indent+2 );
     } // if
+        using namespace std;
+        if ( get_name() != "" ) {
+                os << get_name() << ": a ";
+        } // if
+        if ( get_storageClass() != NoStorageClass ) {
+                os << storageClassName[ get_storageClass() ] << ' ';
+        } // if
+        os << typeString();
+        if ( base ) {
+                os << " for ";
+                base->print( os, indent );
+        } // if
+        if ( ! parameters.empty() ) {
+                os << endl << string( indent, ' ' ) << "with parameters" << endl;
+                printAll( parameters, os, indent+2 );
+        } // if
+        if ( ! assertions.empty() ) {
+                os << endl << string( indent, ' ' ) << "with assertions" << endl;
+                printAll( assertions, os, indent+2 );
+        } // if
+}
 void NamedTypeDecl::printShort( std::ostream &os, int indent ) const {
     using namespace std;
     if ( get_name() != "" ) {
         os << get_name() << ": a ";
     } // if
     if ( get_storageClass() != NoStorageClass ) {
         os << storageClassName[ get_storageClass() ] << ' ';
     } // if
     os << typeString();
     if ( base ) {
         os << " for ";
         base->print( os, indent );
     } // if
     if ( ! parameters.empty() ) {
         os << endl << string( indent, ' ' ) << "with parameters" << endl;
         printAll( parameters, os, indent+2 );
     } // if
+        using namespace std;
+        if ( get_name() != "" ) {
+                os << get_name() << ": a ";
+        } // if
+        if ( get_storageClass() != NoStorageClass ) {
+                os << storageClassName[ get_storageClass() ] << ' ';
+        } // if
+        os << typeString();
+        if ( base ) {
+                os << " for ";
+                base->print( os, indent );
+        } // if
+        if ( ! parameters.empty() ) {
+                os << endl << string( indent, ' ' ) << "with parameters" << endl;
+                printAll( parameters, os, indent+2 );
+        } // if
+}
 std::string TypedefDecl::typeString() const { return "typedef"; }
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/ObjectDecl.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// ObjectDecl.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 10:14:18 2015
+// Update Count     : 2
+//
 #include "Declaration.h"
 #include "Type.h"
 …
 #include "utility.h"
 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() {
     delete type;
     delete init;
     delete bitfieldWidth;
+        delete type;
+        delete init;
+        delete bitfieldWidth;
+}
 void ObjectDecl::print( std::ostream &os, int indent ) const {
     if ( get_name() != "" ) {
         os << get_name() << ": a ";
+    }
+        if ( get_name() != "" ) {
+                os << get_name() << ": a ";
+        } // if
     if ( get_linkage() != LinkageSpec::Cforall ) {
         os << LinkageSpec::toString( get_linkage() ) << " ";
+    }
+        if ( get_linkage() != LinkageSpec::Cforall ) {
+                os << LinkageSpec::toString( get_linkage() ) << " ";
+        } // if
     if ( get_storageClass() != NoStorageClass ) {
         os << storageClassName[ get_storageClass() ] << ' ';
+    }
+        if ( get_storageClass() != NoStorageClass ) {
+                os << storageClassName[ get_storageClass() ] << ' ';
+        } // if
     if ( get_type() ) {
         get_type()->print( os, indent );
     } else {
         os << "untyped entity ";
+    }
+        if ( get_type() ) {
+                get_type()->print( os, indent );
+        } else {
+                os << "untyped entity ";
+        } // if
     if ( init ) {
         os << "with initializer ";
         init->print( os, indent );
+    }
+        if ( init ) {
+                os << "with initializer ";
+                init->print( os, indent );
+        } // if
     if ( bitfieldWidth ) {
         os << "with bitfield width ";
         bitfieldWidth->print( os );
+    }
+        if ( bitfieldWidth ) {
+                os << "with bitfield width ";
+                bitfieldWidth->print( os );
+        } // if
+}
 void ObjectDecl::printShort( std::ostream &os, int indent ) const {
     if ( get_name() != "" ) {
         os << get_name() << ": a ";
+    }
+        if ( get_name() != "" ) {
+                os << get_name() << ": a ";
+        } // if
     if ( get_storageClass() != NoStorageClass ) {
         os << storageClassName[ get_storageClass() ] << ' ';
+    }
+        if ( get_storageClass() != NoStorageClass ) {
+                os << storageClassName[ get_storageClass() ] << ' ';
+        } // if
     if ( get_type() ) {
         get_type()->print( os, indent );
     } else {
         os << "untyped entity ";
+    }
+        if ( get_type() ) {
+                get_type()->print( os, indent );
+        } else {
+                os << "untyped entity ";
+        } // if
     if ( bitfieldWidth ) {
         os << "with bitfield width ";
         bitfieldWidth->print( os );
+    }
+        if ( bitfieldWidth ) {
+                os << "with bitfield width ";
+                bitfieldWidth->print( os );
+        } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/PointerType.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: PointerType.cc,v 1.8 2005/08/29 20:59:26 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// PointerType.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 10:15:16 2015
+// Update Count     : 2
+//
 #include "Type.h"
 …
 #include "utility.h"
 PointerType::PointerType( const Type::Qualifiers &tq, Type *base )
+    : Type( tq ), base( base ), dimension( 0 ), isVarLen( false ), isStatic( false )
+{
+    base->set_isLvalue( false );
+        : Type( tq ), base( base ), dimension( 0 ), isVarLen( false ), isStatic( false ) {
+        base->set_isLvalue( false );
+}
 PointerType::PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic )
+    : Type( tq ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic )
+{
+    base->set_isLvalue( false );
+        : Type( tq ), base( base ), dimension( dimension ), isVarLen( isVarLen ), isStatic( isStatic ) {
+        base->set_isLvalue( false );
+}
 PointerType::PointerType( const PointerType &other )
+    : Type( other ), base( maybeClone( other.base ) ), dimension( maybeClone( other.dimension ) ),
+        isVarLen( other.isVarLen ), isStatic( other.isStatic )
+{
+        : Type( other ), base( maybeClone( other.base ) ), dimension( maybeClone( other.dimension ) ),
+          isVarLen( other.isVarLen ), isStatic( other.isStatic ) {
+}
+PointerType::~PointerType()
+{
+    delete base;
+    delete dimension;
+PointerType::~PointerType() {
+        delete base;
+        delete dimension;
+}
+void
+PointerType::print( std::ostream &os, int indent ) const
+{
+    Type::print( os, indent );
+    os << "pointer to ";
+    if ( isStatic ) {
+        os << "static ";
+    }
+    if ( isVarLen ) {
+        os << "variable length array of ";
+    } else if ( dimension ) {
+        os << "array of ";
+        dimension->print( os, indent );
+    }
+    if ( base ) {
+        base->print( os, indent );
+    }
+void PointerType::print( std::ostream &os, int indent ) const {
+        Type::print( os, indent );
+        os << "pointer to ";
+        if ( isStatic ) {
+                os << "static ";
+        } // if
+        if ( isVarLen ) {
+                os << "variable length array of ";
+        } else if ( dimension ) {
+                os << "array of ";
+                dimension->print( os, indent );
+        } // if
+        if ( base ) {
+                base->print( os, indent );
+        } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/ReferenceToType.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: ReferenceToType.cc,v 1.16 2005/08/29 20:59:26 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// ReferenceToType.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 10:49:00 2015
+// Update Count     : 2
+//
 #include <string>
 …
 #include "utility.h"
+ReferenceToType::ReferenceToType( const Type::Qualifiers &tq, const std::string &name )
+    : Type( tq ), name( name )
+{
+ReferenceToType::ReferenceToType( const Type::Qualifiers &tq, const std::string &name ) : Type( tq ), name( name ) {
+}
+ReferenceToType::ReferenceToType( const ReferenceToType &other )
+    : Type( other ), name( other.name )
+{
+ReferenceToType::ReferenceToType( const ReferenceToType &other ) : Type( other ), name( other.name ) {
     cloneAll( other.parameters, parameters );
+}
+ReferenceToType::~ReferenceToType()
+{
+ReferenceToType::~ReferenceToType() {
     deleteAll( parameters );
+}
+void
+ReferenceToType::print( std::ostream &os, int indent ) const
+{
+void ReferenceToType::print( std::ostream &os, int indent ) const {
     using std::endl;
 …
     os << "instance of " << typeString() << " " << name << " ";
     if ( ! parameters.empty() ) {
         os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
         printAll( parameters, os, indent+2 );
+    }
+                os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
+                printAll( parameters, os, indent+2 );
+    } // if
+}
 namespace {
+void
+doLookup( const std::list< Declaration* > &members, const std::list< TypeDecl* > &parms, const std::list< Expression* > &args, const std::string &name, std::list< Declaration* > &foundDecls )
+{
     std::list< Declaration* > found;
+    for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
         if ( (*i)->get_name() == name ) {
             found.push_back( *i );
+        void doLookup( const std::list< Declaration* > &members, const std::list< TypeDecl* > &parms, const std::list< Expression* > &args, const std::string &name, std::list< Declaration* > &foundDecls ) {
+                std::list< Declaration* > found;
+                for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
+                        if ( (*i)->get_name() == name ) {
+                                found.push_back( *i );
+                        } // if
+                } // for
+                applySubstitution( parms.begin(), parms.end(), args.begin(), found.begin(), found.end(), back_inserter( foundDecls ) );
+        }
+    }
-    applySubstitution( parms.begin(), parms.end(), args.begin(), found.begin(), found.end(), back_inserter( foundDecls ) );
+}
 } // namespace
 std::string StructInstType::typeString() const { return "struct"; }
+void
+StructInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const
+{
+void StructInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
     assert( baseStruct );
     doLookup( baseStruct->get_members(), baseStruct->get_parameters(), parameters, name, foundDecls );
 …
 std::string UnionInstType::typeString() const { return "union"; }
+void
+UnionInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const
+{
+void UnionInstType::lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const {
     assert( baseUnion );
     doLookup( baseUnion->get_members(), baseUnion->get_parameters(), parameters, name, foundDecls );
 …
 std::string ContextInstType::typeString() const { return "context"; }
+ContextInstType::ContextInstType( const ContextInstType &other )
+    : Parent( other )
+{
+ContextInstType::ContextInstType( const ContextInstType &other ) : Parent( other ) {
     cloneAll( other.members, members );
+}
+ContextInstType::~ContextInstType()
+{
+ContextInstType::~ContextInstType() {
     deleteAll( members );
+}
+TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType ) : Parent( tq, name )
+{
+TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType ) : Parent( tq, name ) {
     set_baseType( baseType );
+}
+TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype ) : Parent( tq, name ), baseType( 0 ), isFtype( isFtype )
+{
+TypeInstType::TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype ) : Parent( tq, name ), baseType( 0 ), isFtype( isFtype ) {
+}
+void TypeInstType::set_baseType( TypeDecl *newValue )
+{
+void TypeInstType::set_baseType( TypeDecl *newValue ) {
     baseType = newValue;
     isFtype = newValue->get_kind() == TypeDecl::Ftype;
 …
 std::string TypeInstType::typeString() const { return "type"; }
+void
+TypeInstType::print( std::ostream &os, int indent ) const
+{
+void TypeInstType::print( std::ostream &os, int indent ) const {
     using std::endl;
 …
     os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " a function type) ";
     if ( ! parameters.empty() ) {
         os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
         printAll( parameters, os, indent+2 );
+    }
+                os << endl << std::string( indent, ' ' ) << "with parameters" << endl;
+                printAll( parameters, os, indent+2 );
+    } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Statement.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Statement.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 10:55:19 2015
+// Update Count     : 2
+//
 #include <functional>
 #include <algorithm>
 …
 using std::endl;
+Statement::Statement(std::list<Label> _labels):
+    labels(_labels) {}
+void Statement::print(std::ostream &, int indent) {}
+Statement::Statement( std::list<Label> _labels ) : labels(_labels ) {}
+void Statement::print( std::ostream &, int indent ) {}
 Statement::~Statement() {}
+ExprStmt::ExprStmt( std::list<Label> _labels, Expression *_expr ):
+    Statement(_labels), expr(_expr) {}
+ExprStmt::ExprStmt( std::list<Label> _labels, Expression *_expr ) : Statement(_labels ), expr(_expr ) {}
 ExprStmt::~ExprStmt() {}
 void ExprStmt::print( std::ostream &os, int indent ) {
     os << "\r" << string(indent, ' ') << "Expression Statement:" << endl;
     expr->print(os, indent + 2);
+        os << "\r" << string(indent, ' ') << "Expression Statement:" << endl;
+        expr->print( os, indent + 2 );
+}
 const char *BranchStmt::brType[] = { "Goto", "Break", "Continue" };
+BranchStmt::BranchStmt( std::list<Label> labels, Label _target, Type _type )
+    throw (SemanticError) :
+    Statement(labels), target(_target), type(_type)
+{
+    //actually this is a syntactic error signaled by the parser
+    if (type == BranchStmt::Goto && target.size() == 0)
+        throw SemanticError("goto without target");
+}
+BranchStmt::BranchStmt( std::list<Label> labels, Expression *_computedTarget, Type _type)
+    throw (SemanticError) :
+    Statement(labels), computedTarget(_computedTarget), type(_type)
+{
+    if (type != BranchStmt::Goto || computedTarget == 0)
+        throw SemanticError("Computed target not valid in branch statement");
+BranchStmt::BranchStmt( std::list<Label> labels, Label _target, Type _type ) throw ( SemanticError ) :
+        Statement( labels ), target(_target ), type(_type ) {
+        //actually this is a syntactic error signaled by the parser
+        if ( type == BranchStmt::Goto && target.size() == 0 )
+                throw SemanticError("goto without target");
+}
+BranchStmt::BranchStmt( std::list<Label> labels, Expression *_computedTarget, Type _type ) throw ( SemanticError ) :
+        Statement( labels ), computedTarget(_computedTarget ), type(_type ) {
+        if ( type != BranchStmt::Goto || computedTarget == 0 )
+                throw SemanticError("Computed target not valid in branch statement");
+}
 void BranchStmt::print( std::ostream &os, int indent ){
+    os << "\r" << string(indent, ' ') << "Branch (" << brType[type] << ")" << endl ;
+}
+ReturnStmt::ReturnStmt( std::list<Label> labels, Expression *_expr, bool throwP ) :
+    Statement( labels ), expr( _expr ), isThrow( throwP ) {}
+        os << "\r" << string( indent, ' ') << "Branch (" << brType[type] << ")" << endl ;
+}
+ReturnStmt::ReturnStmt( std::list<Label> labels, Expression *_expr, bool throwP ) : Statement( labels ), expr( _expr ), isThrow( throwP ) {}
 ReturnStmt::~ReturnStmt() {
+    delete expr;
+}
+void ReturnStmt::print( std::ostream &os, int indent ){
+    os << "\r" << std::string(indent, ' ') << string ( isThrow? "Throw":"Return" ) << " Statement, returning: ";
+    if (expr != 0) expr->print(os);
+    os << endl;
+}
+        delete expr;
+}
+void ReturnStmt::print( std::ostream &os, int indent ) {
+        os << "\r" << std::string( indent, ' ') << string ( isThrow? "Throw":"Return" ) << " Statement, returning: ";
+        if ( expr != 0 ) expr->print( os );
+        os << endl;
+}
 IfStmt::IfStmt( std::list<Label> _labels, Expression *_condition, Statement *_thenPart, Statement *_elsePart ):
     Statement(_labels), condition(_condition), thenPart(_thenPart), elsePart(_elsePart) {}
+        Statement(_labels ), condition(_condition ), thenPart(_thenPart ), elsePart(_elsePart ) {}
 IfStmt::~IfStmt() {}
 void IfStmt::print( std::ostream &os, int indent ){
     os << "\r" << string(indent, ' ') << "If on condition: " << endl ;
     condition->print(os, indent + 4);
     os << string(indent, ' ') << ".... and branches: " << endl;
     thenPart->print(os, indent + 4);
     if (elsePart != 0){
         elsePart->print(os, indent + 4);
+    }
+}
 SwitchStmt::SwitchStmt(std::list<Label> _labels, Expression * _condition, std::list<Statement *> &_branches):
+    Statement(_labels), condition(_condition), branches(_branches)
 { }
+        os << "\r" << string( indent, ' ') << "If on condition: " << endl ;
+        condition->print( os, indent + 4 );
+        os << string( indent, ' ') << ".... and branches: " << endl;
+        thenPart->print( os, indent + 4 );
+        if ( elsePart != 0 ) {
+                elsePart->print( os, indent + 4 );
+        } // if
+}
+SwitchStmt::SwitchStmt( std::list<Label> _labels, Expression * _condition, std::list<Statement *> &_branches ):
+        Statement(_labels ), condition(_condition ), branches(_branches ) {
+}
 SwitchStmt::~SwitchStmt() {
+    delete condition;
+    // destroy branches
+}
+void SwitchStmt::add_case(CaseStmt *c) {}
+void SwitchStmt::print(std::ostream &os, int indent) {
+    os << "\r" << string(indent, ' ') << "Switch on condition: ";
+    condition->print(os);
+    os << endl;
+    // branches
+    std::list<Statement *>::iterator i;
+    for (i = branches.begin(); i != branches.end(); i++)
+        (*i)->print(os, indent + 4);
+    //for_each(branches.begin(), branches.end(), mem_fun(bind1st(&Statement::print), os));
+}
+CaseStmt::CaseStmt( std::list<Label> _labels, Expression *_condition,
+                                        std::list<Statement *> &_statements, bool deflt )
+    throw (SemanticError) :
+    Statement(_labels), condition(_condition), stmts(_statements), _isDefault(deflt)
+{
+    if (isDefault() && condition != 0)
+        throw SemanticError("default with conditions");
+        delete condition;
+        // destroy branches
+}
+void SwitchStmt::add_case( CaseStmt *c ) {}
+void SwitchStmt::print( std::ostream &os, int indent ) {
+        os << "\r" << string( indent, ' ') << "Switch on condition: ";
+        condition->print( os );
+        os << endl;
+        // branches
+        std::list<Statement *>::iterator i;
+        for ( i = branches.begin(); i != branches.end(); i++)
+                (*i )->print( os, indent + 4 );
+        //for_each( branches.begin(), branches.end(), mem_fun( bind1st(&Statement::print ), os ));
+}
+CaseStmt::CaseStmt( std::list<Label> _labels, Expression *_condition, std::list<Statement *> &_statements, bool deflt ) throw ( SemanticError ) :
+        Statement(_labels ), condition(_condition ), stmts(_statements ), _isDefault( deflt ) {
+        if ( isDefault() && condition != 0 )
+                throw SemanticError("default with conditions");
+}
 CaseStmt::~CaseStmt() {
     delete condition;
+}
 void CaseStmt::print(std::ostream &os, int indent) {
     os << "\r" << string(indent, ' ');
     if (isDefault())
         os << "Default ";
     else {
         os << "Case ";
         condition->print(os);
+    }
     os << endl;
     std::list<Statement *>::iterator i;
     for (i = stmts.begin(); i != stmts.end(); i++)
         (*i)->print(os, indent + 4);
+        delete condition;
+}
+void CaseStmt::print( std::ostream &os, int indent ) {
+        os << "\r" << string( indent, ' ');
+        if ( isDefault())
+                os << "Default ";
+        else {
+                os << "Case ";
+                condition->print( os );
+        } // if
+        os << endl;
+        std::list<Statement *>::iterator i;
+        for ( i = stmts.begin(); i != stmts.end(); i++)
+                (*i )->print( os, indent + 4 );
+}
 //ChooseStmt::ChooseStmt( std::list<Label> labels, Expression *condition, Statement *body ) {}
 ChooseStmt::ChooseStmt(std::list<Label> _labels, Expression * _condition, std::list<Statement *> &_branches):
+    Statement(_labels), condition(_condition), branches(_branches)
 { }
+ChooseStmt::ChooseStmt( std::list<Label> _labels, Expression * _condition, std::list<Statement *> &_branches ):
+        Statement(_labels ), condition(_condition ), branches(_branches ) {
+}
 ChooseStmt::~ChooseStmt() {
+    delete condition;
+}
+void ChooseStmt::add_case(CaseStmt *c) {}
+void ChooseStmt::print(std::ostream &os, int indent) {
+    os << "\r" << string(indent, ' ') << "Choose on condition: ";
+    condition->print(os);
+    os << endl;
+    // branches
+    std::list<Statement *>::iterator i;
+    for (i = branches.begin(); i != branches.end(); i++)
+        (*i)->print(os, indent + 4);
+    //for_each(branches.begin(), branches.end(), mem_fun(bind1st(&Statement::print), os));
+}
+void FallthruStmt::print(std::ostream &os, int indent) {
+    os << "\r" << string(indent, ' ') << "Fall-through statement" << endl;
+}
+WhileStmt::WhileStmt( std::list<Label> labels, Expression *condition_,
+                                            Statement *body_, bool isDoWhile_ ):
+    Statement( labels ), condition(condition_), body(body_), isDoWhile(isDoWhile_)
+{}
+        delete condition;
+}
+void ChooseStmt::add_case( CaseStmt *c ) {}
+void ChooseStmt::print( std::ostream &os, int indent ) {
+        os << "\r" << string( indent, ' ') << "Choose on condition: ";
+        condition->print( os );
+        os << endl;
+        // branches
+        std::list<Statement *>::iterator i;
+        for ( i = branches.begin(); i != branches.end(); i++)
+                (*i )->print( os, indent + 4 );
+        //for_each( branches.begin(), branches.end(), mem_fun( bind1st(&Statement::print ), os ));
+}
+void FallthruStmt::print( std::ostream &os, int indent ) {
+        os << "\r" << string( indent, ' ') << "Fall-through statement" << endl;
+}
+WhileStmt::WhileStmt( std::list<Label> labels, Expression *condition_, Statement *body_, bool isDoWhile_ ):
+        Statement( labels ), condition( condition_), body( body_), isDoWhile( isDoWhile_) {
+}
 WhileStmt::~WhileStmt(){
     delete body;
+        delete body;
+}
 void WhileStmt::print( std::ostream &os, int indent ){
+    os << "\r" << string(indent, ' ') << "While on condition: " << endl ;
+    condition->print(os, indent + 4);
+    os << string(indent, ' ') << ".... with body: " << endl;
+    if (body != 0) body->print(os, indent + 4);
+}
+ForStmt::ForStmt( std::list<Label> labels, Statement *initialization_,
+                                    Expression *condition_, Expression *increment_, Statement *body_ ):
+    Statement( labels ), initialization( initialization_ ),
+    condition( condition_ ), increment( increment_ ), body( body_ )
+{ }
+        os << "\r" << string( indent, ' ') << "While on condition: " << endl ;
+        condition->print( os, indent + 4 );
+        os << string( indent, ' ') << ".... with body: " << endl;
+        if ( body != 0 ) body->print( os, indent + 4 );
+}
+ForStmt::ForStmt( std::list<Label> labels, Statement *initialization_, Expression *condition_, Expression *increment_, Statement *body_ ):
+        Statement( labels ), initialization( initialization_ ), condition( condition_ ), increment( increment_ ), body( body_ ) {
+}
 ForStmt::~ForStmt() {
     delete initialization;
     delete condition;
     delete increment;
     delete body;
+        delete initialization;
+        delete condition;
+        delete increment;
+        delete body;
+}
 void ForStmt::print( std::ostream &os, int indent ){
     os << "\r" << string(indent, ' ') << "For Statement" << endl ;
     os << "\r" << string(indent + 2, ' ') << "initialization: \n";
     if (initialization != 0)
         initialization->print(os, indent + 4);
     os << "\n\r" << string(indent + 2, ' ') << "condition: \n";
     if (condition != 0)
         condition->print(os, indent + 4);
     os << "\n\r" << string(indent + 2, ' ') << "increment: \n";
     if (increment != 0)
         increment->print(os, indent + 4);
     os << "\n\r" << string(indent + 2, ' ') << "statement block: \n";
     if (body != 0)
         body->print(os, indent + 4);
     os << endl;
+        os << "\r" << string( indent, ' ') << "For Statement" << endl ;
+        os << "\r" << string( indent + 2, ' ') << "initialization: \n";
+        if ( initialization != 0 )
+                initialization->print( os, indent + 4 );
+        os << "\n\r" << string( indent + 2, ' ') << "condition: \n";
+        if ( condition != 0 )
+                condition->print( os, indent + 4 );
+        os << "\n\r" << string( indent + 2, ' ') << "increment: \n";
+        if ( increment != 0 )
+                increment->print( os, indent + 4 );
+        os << "\n\r" << string( indent + 2, ' ') << "statement block: \n";
+        if ( body != 0 )
+                body->print( os, indent + 4 );
+        os << endl;
+}
 TryStmt::TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<Statement *> &_handlers, FinallyStmt *_finallyBlock ) :
+    Statement( labels ), block( tryBlock ),  handlers( _handlers ), finallyBlock( _finallyBlock )
 { }
 TryStmt::TryStmt( const TryStmt &other) : Statement( other.labels ) {
     block = other.block;
     std::copy( other.handlers.begin(), other.handlers.end(), back_inserter(handlers) );
     finallyBlock = other.finallyBlock;
+        Statement( labels ), block( tryBlock ),  handlers( _handlers ), finallyBlock( _finallyBlock ) {
+}
+TryStmt::TryStmt( const TryStmt &other ) : Statement( other.labels ) {
+        block = other.block;
+        std::copy( other.handlers.begin(), other.handlers.end(), back_inserter( handlers ) );
+        finallyBlock = other.finallyBlock;
+}
 TryStmt::~TryStmt(){
     delete block;
+        delete block;
+}
 void TryStmt::print( std::ostream &os, int indent ) {
     os << "\r" << string(indent, ' ') << "Try Statement" << endl;
     os << string(indent + 2, ' ') << "with block: " << endl;
     block->print(os, indent + 4);
     // handlers
     os << string(indent + 2, ' ') << "and handlers: " << endl;
     std::list<Statement *>::iterator i;
     for (i = handlers.begin(); i != handlers.end(); i++)
         (*i)->print(os, indent + 4);
     // finally block
     if ( finallyBlock != 0 ) {
         os << string(indent + 2, ' ') << "Finally block: " << endl;
         finallyBlock->print(os, indent + 4 );
+    }
+        os << "\r" << string( indent, ' ') << "Try Statement" << endl;
+        os << string( indent + 2, ' ') << "with block: " << endl;
+        block->print( os, indent + 4 );
+        // handlers
+        os << string( indent + 2, ' ') << "and handlers: " << endl;
+        std::list<Statement *>::iterator i;
+        for ( i = handlers.begin(); i != handlers.end(); i++)
+                (*i )->print( os, indent + 4 );
+        // finally block
+        if ( finallyBlock != 0 ) {
+                os << string( indent + 2, ' ') << "Finally block: " << endl;
+                finallyBlock->print( os, indent + 4 );
+        } // if
+}
 CatchStmt::CatchStmt( std::list<Label> labels, Declaration *_decl, Statement *_body, bool isCatchRest ) :
+    Statement( labels ), decl ( _decl ), body( _body ), catchRest ( isCatchRest )
 { }
+        Statement( labels ), decl ( _decl ), body( _body ), catchRest ( isCatchRest ) {
+}
 CatchStmt::~CatchStmt(){
     delete decl;
     delete body;
+        delete decl;
+        delete body;
+}
 void CatchStmt::print( std::ostream &os, int indent ) {
+    os << "\r" << string(indent, ' ') << "Catch Statement" << endl;
+    os << "\r" << string(indent, ' ') << "... catching" << endl;
+    if ( decl ) {
+        decl->printShort( os, indent + 4 );
+        os << endl;
+    } else if ( catchRest )
+        os << "\r" << string(indent + 4 , ' ') << "the rest" << endl;
+    else
+        os << "\r" << string(indent + 4 , ' ') << ">>> Error:  this catch clause must have a declaration <<<" << endl;
+}
+FinallyStmt::FinallyStmt( std::list<Label> labels, CompoundStmt *_block ) :
+    Statement( labels ), block( _block )
+{
+    assert( labels.empty() ); // finally statement cannot be labeled
+}
+FinallyStmt::~FinallyStmt(){
+    delete block;
+        os << "\r" << string( indent, ' ') << "Catch Statement" << endl;
+        os << "\r" << string( indent, ' ') << "... catching" << endl;
+        if ( decl ) {
+                decl->printShort( os, indent + 4 );
+                os << endl;
+        } else if ( catchRest )
+                os << "\r" << string( indent + 4 , ' ') << "the rest" << endl;
+        else
+                os << "\r" << string( indent + 4 , ' ') << ">>> Error:  this catch clause must have a declaration <<<" << endl;
+}
+FinallyStmt::FinallyStmt( std::list<Label> labels, CompoundStmt *_block ) : Statement( labels ), block( _block ) {
+        assert( labels.empty() ); // finally statement cannot be labeled
+}
+FinallyStmt::~FinallyStmt() {
+        delete block;
+}
 void FinallyStmt::print( std::ostream &os, int indent ) {
     os << "\r" << string(indent, ' ') << "Finally Statement" << endl;
     os << string(indent + 2, ' ') << "with block: " << endl;
     block->print(os, indent + 4);
+        os << "\r" << string( indent, ' ') << "Finally Statement" << endl;
+        os << string( indent + 2, ' ') << "with block: " << endl;
+        block->print( os, indent + 4 );
+}
 …
 void NullStmt::print( std::ostream &os, int indent ) {
+    os << "\r" << string(indent, ' ') << "Null Statement" << endl ;
+}
+/*
+Local Variables:
+compile-command: "cd ..; gmake"
+End:
+*/
+        os << "\r" << string( indent, ' ') << "Null Statement" << endl ;
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Statement.h

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Statement.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 10:57:40 2015
+// Update Count     : 2
+//
 #ifndef STATEMENT_H
 #define STATEMENT_H
 …
 #include "Common/SemanticError.h"
+class Statement
+{
+public:
+    Statement( std::list<Label> labels );
+    virtual ~Statement();
+    std::list<Label> & get_labels() { return labels; }
+    virtual Statement *clone() const = 0;
+    virtual void accept( Visitor &v ) = 0;
+    virtual Statement *acceptMutator( Mutator &m ) = 0;
+    virtual void print( std::ostream &os, int indent = 0 );
+protected:
+    std::list<Label> labels;
+};
+class CompoundStmt : public Statement
+{
+public:
+    CompoundStmt( std::list<Label> labels );
+    CompoundStmt( const CompoundStmt &other );
+    virtual ~CompoundStmt();
+    std::list<Statement*>& get_kids() { return kids; }
+    virtual CompoundStmt *clone() const { return new CompoundStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    std::list<Statement*> kids;
+};
+class ExprStmt : public Statement
+{
+public:
+    ExprStmt( std::list<Label> labels, Expression *expr );
+    virtual ~ExprStmt();
+    Expression *get_expr() { return expr; }
+    void set_expr( Expression *newValue ) { expr = newValue; }
+    virtual ExprStmt *clone() const { return new ExprStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    Expression *expr;
+};
+class IfStmt : public Statement
+{
+public:
+    IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart );
+    virtual ~IfStmt();
+    Expression *get_condition() { return condition; }
+    void set_condition( Expression *newValue ) { condition = newValue; }
+    Statement *get_thenPart() { return thenPart; }
+    void set_thenPart( Statement *newValue ) { thenPart = newValue; }
+    Statement *get_elsePart() { return elsePart; }
+    void set_elsePart( Statement *newValue ) { elsePart = newValue; }
+    virtual IfStmt *clone() const { return new IfStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    Expression *condition;
+    Statement *thenPart;
+    Statement *elsePart;
+};
+class SwitchStmt : public Statement
+{
+public:
+    SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &branches );
+    virtual ~SwitchStmt();
+    Expression *get_condition() { return condition; }
+    void set_condition( Expression *newValue ) { condition = newValue; }
+    std::list<Statement *>& get_branches() { return branches; }
+    void add_case( CaseStmt * );
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual SwitchStmt *clone() const { return new SwitchStmt( *this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    Expression * condition;
+    std::list<Statement *> branches; // should be list of CaseStmt
+};
+class ChooseStmt : public Statement
+{
+public:
+    ChooseStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &branches );
+    virtual ~ChooseStmt();
+    Expression *get_condition() { return condition; }
+    void set_condition( Expression *newValue ) { condition = newValue; }
+    std::list<Statement *>& get_branches() { return branches; }
+    void add_case( CaseStmt * );
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual ChooseStmt *clone() const { return new ChooseStmt( *this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    Expression *condition;
+    std::list<Statement *> branches; // should be list of CaseStmt
+class Statement {
+  public:
+        Statement( std::list<Label> labels );
+        virtual ~Statement();
+        std::list<Label> & get_labels() { return labels; }
+        virtual Statement *clone() const = 0;
+        virtual void accept( Visitor &v ) = 0;
+        virtual Statement *acceptMutator( Mutator &m ) = 0;
+        virtual void print( std::ostream &os, int indent = 0 );
+  protected:
+        std::list<Label> labels;
+};
+class CompoundStmt : public Statement {
+  public:
+        CompoundStmt( std::list<Label> labels );
+        CompoundStmt( const CompoundStmt &other );
+        virtual ~CompoundStmt();
+        std::list<Statement*>& get_kids() { return kids; }
+        virtual CompoundStmt *clone() const { return new CompoundStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual CompoundStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        std::list<Statement*> kids;
+};
+class ExprStmt : public Statement {
+  public:
+        ExprStmt( std::list<Label> labels, Expression *expr );
+        virtual ~ExprStmt();
+        Expression *get_expr() { return expr; }
+        void set_expr( Expression *newValue ) { expr = newValue; }
+        virtual ExprStmt *clone() const { return new ExprStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Expression *expr;
+};
+class IfStmt : public Statement {
+  public:
+        IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart );
+        virtual ~IfStmt();
+        Expression *get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
+        Statement *get_thenPart() { return thenPart; }
+        void set_thenPart( Statement *newValue ) { thenPart = newValue; }
+        Statement *get_elsePart() { return elsePart; }
+        void set_elsePart( Statement *newValue ) { elsePart = newValue; }
+        virtual IfStmt *clone() const { return new IfStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Expression *condition;
+        Statement *thenPart;
+        Statement *elsePart;
+};
+class SwitchStmt : public Statement {
+  public:
+        SwitchStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &branches );
+        virtual ~SwitchStmt();
+        Expression *get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
+        std::list<Statement *>& get_branches() { return branches; }
+        void add_case( CaseStmt * );
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual SwitchStmt *clone() const { return new SwitchStmt( *this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Expression * condition;
+        std::list<Statement *> branches; // should be list of CaseStmt
+};
+class ChooseStmt : public Statement {
+  public:
+        ChooseStmt( std::list<Label> labels, Expression *condition, std::list<Statement *> &branches );
+        virtual ~ChooseStmt();
+        Expression *get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
+        std::list<Statement *>& get_branches() { return branches; }
+        void add_case( CaseStmt * );
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual ChooseStmt *clone() const { return new ChooseStmt( *this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Expression *condition;
+        std::list<Statement *> branches; // should be list of CaseStmt
 };
 class FallthruStmt : public Statement {
+public:
+    FallthruStmt( std::list<Label> labels ) : Statement( labels ) { }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual FallthruStmt *clone() const { return new FallthruStmt( *this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+};
+class CaseStmt : public Statement
+{
+public:
+    CaseStmt( std::list<Label> labels, Expression *conditions,
+            std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+    virtual ~CaseStmt();
+    bool isDefault() { return _isDefault; }
+    void set_default(bool b) { _isDefault = b; }
+    Expression * &get_condition() { return condition; }
+    void set_condition( Expression *newValue ) { condition = newValue; }
+    std::list<Statement *> &get_statements() { return stmts; }
+    void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual CaseStmt *clone() const { return new CaseStmt( *this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    Expression * condition;
+    std::list<Statement *> stmts;
+    bool _isDefault;
+};
+class WhileStmt : public Statement
+{
+public:
+    WhileStmt( std::list<Label> labels, Expression *condition,
+                                    Statement *body, bool isDoWhile = false );
+    virtual ~WhileStmt();
+    Expression *get_condition() { return condition; }
+    void set_condition( Expression *newValue ) { condition = newValue; }
+    Statement *get_body() { return body; }
+    void set_body( Statement *newValue ) { body = newValue; }
+    bool get_isDoWhile() { return isDoWhile; }
+    void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
+    virtual WhileStmt *clone() const { return new WhileStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    Expression *condition;
+    Statement *body;
+    bool isDoWhile;
+};
+class ForStmt : public Statement
+{
+public:
+    ForStmt( std::list<Label> labels, Statement *initialization = 0,
+         Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
+    virtual ~ForStmt();
+    Statement *get_initialization() { return initialization; }
+    void set_initialization( Statement *newValue ) { initialization = newValue; }
+    Expression *get_condition() { return condition; }
+    void set_condition( Expression *newValue ) { condition = newValue; }
+    Expression *get_increment() { return increment; }
+    void set_increment( Expression *newValue ) { increment = newValue; }
+    Statement *get_body() { return body; }
+    void set_body( Statement *newValue ) { body = newValue; }
+    virtual ForStmt *clone() const { return new ForStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    Statement *initialization;
+    Expression *condition;
+    Expression *increment;
+    Statement *body;
+};
+class BranchStmt : public Statement
+{
+public:
+    enum Type { Goto = 0 , Break, Continue };
+    BranchStmt( std::list<Label> labels, Label target, Type ) throw (SemanticError);
+    BranchStmt( std::list<Label> labels, Expression *computedTarget, Type ) throw (SemanticError);
+    virtual ~BranchStmt() {}
+    Label get_target() { return target; }
+    void set_target( Label newValue ) { target = newValue; }
+    Expression *get_computedTarget() { return computedTarget; }
+    void set_target( Expression * newValue ) { computedTarget = newValue; }
+    Type get_type() { return type; }
+    const char *get_typename() { return brType[ type ]; }
+    virtual BranchStmt *clone() const { return new BranchStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    static const char *brType[];
+    Label target;
+    Expression *computedTarget;
+    Type type;
+};
+class ReturnStmt : public Statement
+{
+public:
+    ReturnStmt( std::list<Label> labels, Expression *expr, bool throwP = false );
+    virtual ~ReturnStmt();
+    Expression *get_expr() { return expr; }
+    void set_expr( Expression *newValue ) { expr = newValue; }
+    virtual ReturnStmt *clone() const { return new ReturnStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    Expression *expr;
+    bool isThrow;
+};
+class NullStmt : public CompoundStmt
+{
+public:
+    NullStmt();
+    NullStmt( std::list<Label> labels );
+    virtual ~NullStmt();
+    virtual NullStmt *clone() const { return new NullStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+};
+class TryStmt : public Statement
+{
+public:
+    TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<Statement *> &handlers, FinallyStmt *finallyBlock = 0 );
+    TryStmt( const TryStmt &other );
+    virtual ~TryStmt();
+    CompoundStmt *get_block() const { return block; }
+    void set_block( CompoundStmt *newValue ) { block = newValue; }
+    std::list<Statement *>& get_catchers() { return handlers; }
+    FinallyStmt *get_finally() const { return finallyBlock; }
+    void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
+    virtual TryStmt *clone() const { return new TryStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    CompoundStmt *block;
+    std::list<Statement *> handlers;
+    FinallyStmt *finallyBlock;
+  public:
+        FallthruStmt( std::list<Label> labels ) : Statement( labels ) { }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual FallthruStmt *clone() const { return new FallthruStmt( *this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+};
+class CaseStmt : public Statement {
+  public:
+        CaseStmt( std::list<Label> labels, Expression *conditions,
+              std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+        virtual ~CaseStmt();
+        bool isDefault() { return _isDefault; }
+        void set_default(bool b) { _isDefault = b; }
+        Expression * &get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
+        std::list<Statement *> &get_statements() { return stmts; }
+        void set_statements( std::list<Statement *> &newValue ) { stmts = newValue; }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual CaseStmt *clone() const { return new CaseStmt( *this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Expression * condition;
+        std::list<Statement *> stmts;
+        bool _isDefault;
+};
+class WhileStmt : public Statement {
+  public:
+        WhileStmt( std::list<Label> labels, Expression *condition,
+               Statement *body, bool isDoWhile = false );
+        virtual ~WhileStmt();
+        Expression *get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
+        Statement *get_body() { return body; }
+        void set_body( Statement *newValue ) { body = newValue; }
+        bool get_isDoWhile() { return isDoWhile; }
+        void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
+        virtual WhileStmt *clone() const { return new WhileStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Expression *condition;
+        Statement *body;
+        bool isDoWhile;
+};
+class ForStmt : public Statement {
+  public:
+        ForStmt( std::list<Label> labels, Statement *initialization = 0,
+             Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
+        virtual ~ForStmt();
+        Statement *get_initialization() { return initialization; }
+        void set_initialization( Statement *newValue ) { initialization = newValue; }
+        Expression *get_condition() { return condition; }
+        void set_condition( Expression *newValue ) { condition = newValue; }
+        Expression *get_increment() { return increment; }
+        void set_increment( Expression *newValue ) { increment = newValue; }
+        Statement *get_body() { return body; }
+        void set_body( Statement *newValue ) { body = newValue; }
+        virtual ForStmt *clone() const { return new ForStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Statement *initialization;
+        Expression *condition;
+        Expression *increment;
+        Statement *body;
+};
+class BranchStmt : public Statement {
+  public:
+        enum Type { Goto = 0 , Break, Continue };
+        BranchStmt( std::list<Label> labels, Label target, Type ) throw (SemanticError);
+        BranchStmt( std::list<Label> labels, Expression *computedTarget, Type ) throw (SemanticError);
+        virtual ~BranchStmt() {}
+        Label get_target() { return target; }
+        void set_target( Label newValue ) { target = newValue; }
+        Expression *get_computedTarget() { return computedTarget; }
+        void set_target( Expression * newValue ) { computedTarget = newValue; }
+        Type get_type() { return type; }
+        const char *get_typename() { return brType[ type ]; }
+        virtual BranchStmt *clone() const { return new BranchStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        static const char *brType[];
+        Label target;
+        Expression *computedTarget;
+        Type type;
+};
+class ReturnStmt : public Statement {
+  public:
+        ReturnStmt( std::list<Label> labels, Expression *expr, bool throwP = false );
+        virtual ~ReturnStmt();
+        Expression *get_expr() { return expr; }
+        void set_expr( Expression *newValue ) { expr = newValue; }
+        virtual ReturnStmt *clone() const { return new ReturnStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Expression *expr;
+        bool isThrow;
+};
+class NullStmt : public CompoundStmt {
+  public:
+        NullStmt();
+        NullStmt( std::list<Label> labels );
+        virtual ~NullStmt();
+        virtual NullStmt *clone() const { return new NullStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual NullStmt *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+};
+class TryStmt : public Statement {
+  public:
+        TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<Statement *> &handlers, FinallyStmt *finallyBlock = 0 );
+        TryStmt( const TryStmt &other );
+        virtual ~TryStmt();
+        CompoundStmt *get_block() const { return block; }
+        void set_block( CompoundStmt *newValue ) { block = newValue; }
+        std::list<Statement *>& get_catchers() { return handlers; }
+        FinallyStmt *get_finally() const { return finallyBlock; }
+        void set_finally( FinallyStmt *newValue ) { finallyBlock = newValue; }
+        virtual TryStmt *clone() const { return new TryStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        CompoundStmt *block;
+        std::list<Statement *> handlers;
+        FinallyStmt *finallyBlock;
 };
+class CatchStmt : public Statement
+{
+public:
+    CatchStmt( std::list<Label> labels, Declaration *decl, Statement *body, bool isCatchRest = false );
+    virtual ~CatchStmt();
+    Declaration *get_decl() { return decl; }
+    void set_decl( Declaration *newValue ) { decl = newValue; }
+    Statement *get_body() { return body; }
+    void set_body( Statement *newValue ) { body = newValue; }
+    virtual CatchStmt *clone() const { return new CatchStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    Declaration *decl;
+    Statement *body;
+    bool catchRest;
+};
+class FinallyStmt : public Statement
+{
+public:
+    FinallyStmt( std::list<Label> labels, CompoundStmt *block );
+    virtual ~FinallyStmt();
+    CompoundStmt *get_block() const { return block; }
+    void set_block( CompoundStmt *newValue ) { block = newValue; }
+    virtual FinallyStmt *clone() const { return new FinallyStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    CompoundStmt *block;
+class CatchStmt : public Statement {
+  public:
+        CatchStmt( std::list<Label> labels, Declaration *decl, Statement *body, bool isCatchRest = false );
+        virtual ~CatchStmt();
+        Declaration *get_decl() { return decl; }
+        void set_decl( Declaration *newValue ) { decl = newValue; }
+        Statement *get_body() { return body; }
+        void set_body( Statement *newValue ) { body = newValue; }
+        virtual CatchStmt *clone() const { return new CatchStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Declaration *decl;
+        Statement *body;
+        bool catchRest;
+};
+class FinallyStmt : public Statement {
+  public:
+        FinallyStmt( std::list<Label> labels, CompoundStmt *block );
+        virtual ~FinallyStmt();
+        CompoundStmt *get_block() const { return block; }
+        void set_block( CompoundStmt *newValue ) { block = newValue; }
+        virtual FinallyStmt *clone() const { return new FinallyStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        CompoundStmt *block;
 };
 // represents a declaration that occurs as part of a compound statement
+class DeclStmt : public Statement
+{
+public:
+    DeclStmt( std::list<Label> labels, Declaration *decl );
+    DeclStmt( const DeclStmt &other );
+    virtual ~DeclStmt();
+    Declaration *get_decl() { return decl; }
+    void set_decl( Declaration *newValue ) { decl = newValue; }
+    virtual DeclStmt *clone() const { return new DeclStmt( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 );
+private:
+    Declaration *decl;
+};
+#endif /* #ifndef STATEMENT_H */
+/*
+    Local Variables:
+    mode: c++
+    End:
+*/
+class DeclStmt : public Statement {
+  public:
+        DeclStmt( std::list<Label> labels, Declaration *decl );
+        DeclStmt( const DeclStmt &other );
+        virtual ~DeclStmt();
+        Declaration *get_decl() { return decl; }
+        void set_decl( Declaration *newValue ) { decl = newValue; }
+        virtual DeclStmt *clone() const { return new DeclStmt( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Statement *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 );
+  private:
+        Declaration *decl;
+};
+#endif // STATEMENT_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/SynTree.h

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: SynTree.h,v 1.22 2005/08/29 20:59:26 rcbilson Exp $
+ *
+ * Forward declarations for syntax tree classes, so that they can be mutually
+ * interdependent
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// SynTree.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 10:58:22 2015
+// Update Count     : 1
+//
 #ifndef SYNTREE_H
 …
 #include <map>
 #include <iostream>
 class Declaration;
 …
 class TypeSubstitution;
+#endif // SYNTREE_H
+#endif /* #ifndef SYNTREE_H */
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/TupleExpr.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: TupleExpr.cc,v 1.11 2005/08/29 20:59:26 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// TupleExpr.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 10:59:19 2015
+// Update Count     : 1
+//
 #include "Expression.h"
 #include "utility.h"
+TupleExpr::TupleExpr( Expression *_aname ) : Expression( _aname )
+{
+TupleExpr::TupleExpr( Expression *_aname ) : Expression( _aname ) {
+}
+TupleExpr::TupleExpr( const TupleExpr &other )
+    : Expression( other )
+{
+    cloneAll( other.exprs, exprs );
+TupleExpr::TupleExpr( const TupleExpr &other ) : Expression( other ) {
+        cloneAll( other.exprs, exprs );
+}
+TupleExpr::~TupleExpr()
+{
+    deleteAll( exprs );
+TupleExpr::~TupleExpr() {
+        deleteAll( exprs );
+}
+void
+TupleExpr::print( std::ostream &os, int indent ) const
+{
+    os << std::string( indent, ' ' ) << "Tuple:" << std::endl;
+    printAll( exprs, os, indent+2 );
+    Expression::print( os, indent );
+void TupleExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Tuple:" << std::endl;
+        printAll( exprs, os, indent+2 );
+        Expression::print( os, indent );
+}
+SolvedTupleExpr::SolvedTupleExpr( std::list<Expression *> &_exprs, Expression *_aname )
+    :  Expression( _aname )
+{
+    std::copy(_exprs.begin(), _exprs.end(), back_inserter(exprs));
+SolvedTupleExpr::SolvedTupleExpr( std::list<Expression *> &_exprs, Expression *_aname ) : Expression( _aname ) {
+        std::copy(_exprs.begin(), _exprs.end(), back_inserter(exprs));
+}
+SolvedTupleExpr::SolvedTupleExpr( const SolvedTupleExpr &other )
+    : Expression( other )
+{
+    cloneAll( other.exprs, exprs );
+SolvedTupleExpr::SolvedTupleExpr( const SolvedTupleExpr &other ) : Expression( other ) {
+        cloneAll( other.exprs, exprs );
+}
+void
+SolvedTupleExpr::print( std::ostream &os, int indent ) const
+{
+    os << std::string( indent, ' ' ) << "Solved Tuple:" << std::endl;
+    printAll( exprs, os, indent+2 );
+    Expression::print( os, indent );
+void SolvedTupleExpr::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Solved Tuple:" << std::endl;
+        printAll( exprs, os, indent+2 );
+        Expression::print( os, indent );
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/TupleType.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: TupleType.cc,v 1.6 2005/08/29 20:59:26 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// TupleType.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:00:01 2015
+// Update Count     : 2
+//
 #include "Type.h"
 #include "utility.h"
+TupleType::TupleType( const Type::Qualifiers &tq )
+    : Type( tq )
+{
+TupleType::TupleType( const Type::Qualifiers &tq ) : Type( tq ) {
+}
+TupleType::TupleType( const TupleType& other )
+    : Type( other )
+{
+    cloneAll( other.types, types );
+TupleType::TupleType( const TupleType& other ) : Type( other ) {
+        cloneAll( other.types, types );
+}
+TupleType::~TupleType()
+{
+    deleteAll( types );
+TupleType::~TupleType() {
+        deleteAll( types );
+}
+void
+TupleType::print( std::ostream &os, int indent ) const
+{
+    Type::print( os, indent );
+    os << "tuple of types" << std::endl;
+    printAll( types, os, indent+2 );
+void TupleType::print( std::ostream &os, int indent ) const {
+        Type::print( os, indent );
+        os << "tuple of types" << std::endl;
+        printAll( types, os, indent+2 );
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Type.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Type.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:00:29 2015
+// Update Count     : 1
+//
 #include "SynTree.h"
 #include "Visitor.h"
 …
 void Type::print( std::ostream &os, int indent ) const {
     if ( ! forall.empty() ) {
         os << "forall" << std::endl;
         printAll( forall, os, indent + 4 );
         os << std::string( indent+2, ' ' );
+                os << "forall" << std::endl;
+                printAll( forall, os, indent + 4 );
+                os << std::string( indent+2, ' ' );
     } // if
     if ( tq.isConst ) {
         os << "const ";
+                os << "const ";
     } // if
     if ( tq.isVolatile ) {
         os << "volatile ";
+                os << "volatile ";
     } // if
     if ( tq.isRestrict ) {
         os << "restrict ";
+                os << "restrict ";
     } // if
     if ( tq.isLvalue ) {
         os << "lvalue ";
+                os << "lvalue ";
     } // if
     if ( tq.isAtomic ) {
         os << "_Atomic ";
+                os << "_Atomic ";
     } // if
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Type.h

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Type.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:01:40 2015
+// Update Count     : 1
+//
 #ifndef TYPE_H
 #define TYPE_H
 …
 #include "Mutator.h"
 class Type {
   public:
     struct Qualifiers {
       Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isAttribute( false ) {}
       Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isAttribute): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isAttribute( isAttribute ) {}
         Qualifiers &operator+=( const Qualifiers &other );
         Qualifiers &operator-=( const Qualifiers &other );
         Qualifiers operator+( const Type::Qualifiers &other );
         bool operator==( const Qualifiers &other );
         bool operator!=( const Qualifiers &other );
         bool operator<=( const Qualifiers &other );
         bool operator>=( const Qualifiers &other );
         bool operator<( const Qualifiers &other );
         bool operator>( const Qualifiers &other );
         bool isConst;
         bool isVolatile;
         bool isRestrict;
         bool isLvalue;
         bool isAtomic;
         bool isAttribute;
     };
     Type( const Qualifiers &tq );
     Type( const Type &other );
     virtual ~Type();
     Qualifiers &get_qualifiers() { return tq; }
     bool get_isConst() { return tq.isConst; }
     bool get_isVolatile() { return tq.isVolatile; }
     bool get_isRestrict() { return tq.isRestrict; }
     bool get_isLvalue() { return tq.isLvalue; }
     bool get_isAtomic() { return tq.isAtomic; }
     bool get_isAttribute() { return tq.isAttribute; }
     void set_isConst( bool newValue ) { tq.isConst = newValue; }
     void set_iisVolatile( bool newValue ) { tq.isVolatile = newValue; }
     void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; }
     void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; }
     void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
     void set_isAttribute( bool newValue ) { tq.isAttribute = newValue; }
     std::list<TypeDecl*>& get_forall() { return forall; }
     virtual Type *clone() const = 0;
     virtual void accept( Visitor &v ) = 0;
     virtual Type *acceptMutator( Mutator &m ) = 0;
     virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
     Qualifiers tq;
     std::list<TypeDecl*> forall;
+        struct Qualifiers {
+                Qualifiers(): isConst( false ), isVolatile( false ), isRestrict( false ), isLvalue( false ), isAtomic( false ), isAttribute( false ) {}
+                Qualifiers( bool isConst, bool isVolatile, bool isRestrict, bool isLvalue, bool isAtomic, bool isAttribute): isConst( isConst ), isVolatile( isVolatile ), isRestrict( isRestrict ), isLvalue( isLvalue ), isAtomic( isAtomic ), isAttribute( isAttribute ) {}
+                Qualifiers &operator+=( const Qualifiers &other );
+                Qualifiers &operator-=( const Qualifiers &other );
+                Qualifiers operator+( const Type::Qualifiers &other );
+                bool operator==( const Qualifiers &other );
+                bool operator!=( const Qualifiers &other );
+                bool operator<=( const Qualifiers &other );
+                bool operator>=( const Qualifiers &other );
+                bool operator<( const Qualifiers &other );
+                bool operator>( const Qualifiers &other );
+                bool isConst;
+                bool isVolatile;
+                bool isRestrict;
+                bool isLvalue;
+                bool isAtomic;
+                bool isAttribute;
+        };
+        Type( const Qualifiers &tq );
+        Type( const Type &other );
+        virtual ~Type();
+        Qualifiers &get_qualifiers() { return tq; }
+        bool get_isConst() { return tq.isConst; }
+        bool get_isVolatile() { return tq.isVolatile; }
+        bool get_isRestrict() { return tq.isRestrict; }
+        bool get_isLvalue() { return tq.isLvalue; }
+        bool get_isAtomic() { return tq.isAtomic; }
+        bool get_isAttribute() { return tq.isAttribute; }
+        void set_isConst( bool newValue ) { tq.isConst = newValue; }
+        void set_iisVolatile( bool newValue ) { tq.isVolatile = newValue; }
+        void set_isRestrict( bool newValue ) { tq.isRestrict = newValue; }
+        void set_isLvalue( bool newValue ) { tq.isLvalue = newValue; }
+        void set_isAtomic( bool newValue ) { tq.isAtomic = newValue; }
+        void set_isAttribute( bool newValue ) { tq.isAttribute = newValue; }
+        std::list<TypeDecl*>& get_forall() { return forall; }
+        virtual Type *clone() const = 0;
+        virtual void accept( Visitor &v ) = 0;
+        virtual Type *acceptMutator( Mutator &m ) = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Qualifiers tq;
+        std::list<TypeDecl*> forall;
 };
 class VoidType : public Type {
   public:
     VoidType( const Type::Qualifiers &tq );
     virtual VoidType *clone() const { return new VoidType( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 ) const;
+        VoidType( const Type::Qualifiers &tq );
+        virtual VoidType *clone() const { return new VoidType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
 };
 class BasicType : public Type {
   public:
     enum Kind {
         Bool,
         Char,
         SignedChar,
         UnsignedChar,
         ShortSignedInt,
         ShortUnsignedInt,
         SignedInt,
         UnsignedInt,
         LongSignedInt,
         LongUnsignedInt,
         LongLongSignedInt,
         LongLongUnsignedInt,
         Float,
         Double,
         LongDouble,
         FloatComplex,
         DoubleComplex,
         LongDoubleComplex,
         FloatImaginary,
         DoubleImaginary,
         LongDoubleImaginary,
         NUMBER_OF_BASIC_TYPES
     };
     static const char *typeNames[];                     // string names for basic types, MUST MATCH with Kind
     BasicType( const Type::Qualifiers &tq, Kind bt );
     Kind get_kind() { return kind; }
     void set_kind( Kind newValue ) { kind = newValue; }
     virtual BasicType *clone() const { return new BasicType( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 ) const;
     bool isInteger() const;
   private:
     Kind kind;
+        enum Kind {
+                Bool,
+                Char,
+                SignedChar,
+                UnsignedChar,
+                ShortSignedInt,
+                ShortUnsignedInt,
+                SignedInt,
+                UnsignedInt,
+                LongSignedInt,
+                LongUnsignedInt,
+                LongLongSignedInt,
+                LongLongUnsignedInt,
+                Float,
+                Double,
+                LongDouble,
+                FloatComplex,
+                DoubleComplex,
+                LongDoubleComplex,
+                FloatImaginary,
+                DoubleImaginary,
+                LongDoubleImaginary,
+                NUMBER_OF_BASIC_TYPES
+        };
+        static const char *typeNames[];                 // string names for basic types, MUST MATCH with Kind
+        BasicType( const Type::Qualifiers &tq, Kind bt );
+        Kind get_kind() { return kind; }
+        void set_kind( Kind newValue ) { kind = newValue; }
+        virtual BasicType *clone() const { return new BasicType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+        bool isInteger() const;
+  private:
+        Kind kind;
 };
 class PointerType : public Type {
   public:
     PointerType( const Type::Qualifiers &tq, Type *base );
     PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
     PointerType( const PointerType& );
     virtual ~PointerType();
     Type *get_base() { return base; }
     void set_base( Type *newValue ) { base = newValue; }
     Expression *get_dimension() { return dimension; }
     void set_dimension( Expression *newValue ) { dimension = newValue; }
     bool get_isVarLen() { return isVarLen; }
     void set_isVarLen( bool newValue ) { isVarLen = newValue; }
     bool get_isStatic() { return isStatic; }
     void set_isStatic( bool newValue ) { isStatic = newValue; }
     virtual PointerType *clone() const { return new PointerType( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
     Type *base;
     // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
     Expression *dimension;
     bool isVarLen;
     bool isStatic;
+        PointerType( const Type::Qualifiers &tq, Type *base );
+        PointerType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
+        PointerType( const PointerType& );
+        virtual ~PointerType();
+        Type *get_base() { return base; }
+        void set_base( Type *newValue ) { base = newValue; }
+        Expression *get_dimension() { return dimension; }
+        void set_dimension( Expression *newValue ) { dimension = newValue; }
+        bool get_isVarLen() { return isVarLen; }
+        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
+        bool get_isStatic() { return isStatic; }
+        void set_isStatic( bool newValue ) { isStatic = newValue; }
+        virtual PointerType *clone() const { return new PointerType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Type *base;
+        // In C99, pointer types can be qualified in many ways e.g., int f( int a[ static 3 ] )
+        Expression *dimension;
+        bool isVarLen;
+        bool isStatic;
 };
 class ArrayType : public Type {
   public:
     ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
     ArrayType( const ArrayType& );
     virtual ~ArrayType();
     Type *get_base() { return base; }
     void set_base( Type *newValue ) { base = newValue; }
     Expression *get_dimension() { return dimension; }
     void set_dimension( Expression *newValue ) { dimension = newValue; }
     bool get_isVarLen() { return isVarLen; }
     void set_isVarLen( bool newValue ) { isVarLen = newValue; }
     bool get_isStatic() { return isStatic; }
     void set_isStatic( bool newValue ) { isStatic = newValue; }
     virtual ArrayType *clone() const { return new ArrayType( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
     Type *base;
     Expression *dimension;
     bool isVarLen;
     bool isStatic;
+        ArrayType( const Type::Qualifiers &tq, Type *base, Expression *dimension, bool isVarLen, bool isStatic );
+        ArrayType( const ArrayType& );
+        virtual ~ArrayType();
+        Type *get_base() { return base; }
+        void set_base( Type *newValue ) { base = newValue; }
+        Expression *get_dimension() { return dimension; }
+        void set_dimension( Expression *newValue ) { dimension = newValue; }
+        bool get_isVarLen() { return isVarLen; }
+        void set_isVarLen( bool newValue ) { isVarLen = newValue; }
+        bool get_isStatic() { return isStatic; }
+        void set_isStatic( bool newValue ) { isStatic = newValue; }
+        virtual ArrayType *clone() const { return new ArrayType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Type *base;
+        Expression *dimension;
+        bool isVarLen;
+        bool isStatic;
 };
 class FunctionType : public Type {
   public:
     FunctionType( const Type::Qualifiers &tq, bool isVarArgs );
     FunctionType( const FunctionType& );
     virtual ~FunctionType();
     std::list<DeclarationWithType*>& get_returnVals() { return returnVals; }
     std::list<DeclarationWithType*>& get_parameters() { return parameters; }
     bool get_isVarArgs() { return isVarArgs; }
     void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
     virtual FunctionType *clone() const { return new FunctionType( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
     std::list<DeclarationWithType*> returnVals;
     std::list<DeclarationWithType*> parameters;
     // does the function accept a variable number of arguments following the arguments
     // specified in the parameters list.    This could be because of
     // - an ellipsis in a prototype declaration
     // - an unprototyped declaration
     bool isVarArgs;
+        FunctionType( const Type::Qualifiers &tq, bool isVarArgs );
+        FunctionType( const FunctionType& );
+        virtual ~FunctionType();
+        std::list<DeclarationWithType*>& get_returnVals() { return returnVals; }
+        std::list<DeclarationWithType*>& get_parameters() { return parameters; }
+        bool get_isVarArgs() { return isVarArgs; }
+        void set_isVarArgs( bool newValue ) { isVarArgs = newValue; }
+        virtual FunctionType *clone() const { return new FunctionType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::list<DeclarationWithType*> returnVals;
+        std::list<DeclarationWithType*> parameters;
+        // does the function accept a variable number of arguments following the arguments
+        // specified in the parameters list.    This could be because of
+        // - an ellipsis in a prototype declaration
+        // - an unprototyped declaration
+        bool isVarArgs;
 };
 class ReferenceToType : public Type {
   public:
     ReferenceToType( const Type::Qualifiers &tq, const std::string &name );
     ReferenceToType( const ReferenceToType &other );
     virtual ~ReferenceToType();
     std::string get_name() const { return name; }
     void set_name( std::string newValue ) { name = newValue; }
     std::list< Expression* >& get_parameters() { return parameters; }
     virtual ReferenceToType *clone() const = 0;
     virtual void accept( Visitor &v ) = 0;
     virtual Type *acceptMutator( Mutator &m ) = 0;
     virtual void print( std::ostream &os, int indent = 0 ) const;
+        ReferenceToType( const Type::Qualifiers &tq, const std::string &name );
+        ReferenceToType( const ReferenceToType &other );
+        virtual ~ReferenceToType();
+        std::string get_name() const { return name; }
+        void set_name( std::string newValue ) { name = newValue; }
+        std::list< Expression* >& get_parameters() { return parameters; }
+        virtual ReferenceToType *clone() const = 0;
+        virtual void accept( Visitor &v ) = 0;
+        virtual Type *acceptMutator( Mutator &m ) = 0;
+        virtual void print( std::ostream &os, int indent = 0 ) const;
   protected:
     virtual std::string typeString() const = 0;
     std::list< Expression* > parameters;
   private:
     std::string name;
+        virtual std::string typeString() const = 0;
+        std::list< Expression* > parameters;
+  private:
+        std::string name;
 };
 class StructInstType : public ReferenceToType {
+    typedef ReferenceToType Parent;
+  public:
+    StructInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseStruct( 0 ) {}
+    StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
+    StructDecl *get_baseStruct() const { return baseStruct; }
+    void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
+    // a utility function
+    void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
+    virtual StructInstType *clone() const { return new StructInstType( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+    virtual std::string typeString() const;
+    // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
+    // where the structure used in this type is actually defined
+    StructDecl *baseStruct;
+        typedef ReferenceToType Parent;
+  public:
+        StructInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseStruct( 0 ) {}
+        StructInstType( const StructInstType &other ) : Parent( other ), baseStruct( other.baseStruct ) {}
+        StructDecl *get_baseStruct() const { return baseStruct; }
+        void set_baseStruct( StructDecl *newValue ) { baseStruct = newValue; }
+        // a utility function
+        void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
+        virtual StructInstType *clone() const { return new StructInstType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
+        // this decl is not "owned" by the struct inst; it is merely a pointer to elsewhere in the tree,
+        // where the structure used in this type is actually defined
+        StructDecl *baseStruct;
 };
 class UnionInstType : public ReferenceToType {
     typedef ReferenceToType Parent;
   public:
     UnionInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseUnion( 0 ) {}
     UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
     UnionDecl *get_baseUnion() const { return baseUnion; }
     void set_baseUnion( UnionDecl *newValue ) { baseUnion = newValue; }
     // a utility function
     void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
     virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
     virtual std::string typeString() const;
     // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
     // where the union used in this type is actually defined
     UnionDecl *baseUnion;
+        typedef ReferenceToType Parent;
+  public:
+        UnionInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ), baseUnion( 0 ) {}
+        UnionInstType( const UnionInstType &other ) : Parent( other ), baseUnion( other.baseUnion ) {}
+        UnionDecl *get_baseUnion() const { return baseUnion; }
+        void set_baseUnion( UnionDecl *newValue ) { baseUnion = newValue; }
+        // a utility function
+        void lookup( const std::string &name, std::list< Declaration* > &foundDecls ) const;
+        virtual UnionInstType *clone() const { return new UnionInstType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
+        // this decl is not "owned" by the union inst; it is merely a pointer to elsewhere in the tree,
+        // where the union used in this type is actually defined
+        UnionDecl *baseUnion;
 };
 class EnumInstType : public ReferenceToType {
+    typedef ReferenceToType Parent;
+  public:
+    EnumInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
+    EnumInstType( const EnumInstType &other ) : Parent( other ) {}
+    virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+    virtual std::string typeString() const;
+        typedef ReferenceToType Parent;
+  public:
+        EnumInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
+        EnumInstType( const EnumInstType &other ) : Parent( other ) {}
+        virtual EnumInstType *clone() const { return new EnumInstType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
 };
 class ContextInstType : public ReferenceToType {
     typedef ReferenceToType Parent;
   public:
     ContextInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
     ContextInstType( const ContextInstType &other );
     ~ContextInstType();
     std::list< Declaration* >& get_members() { return members; }
     virtual ContextInstType *clone() const { return new ContextInstType( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
   private:
     virtual std::string typeString() const;
     // this member is filled in by the validate pass, which instantiates the members of the correponding
     // aggregate with the actual type parameters specified for this use of the context
     std::list< Declaration* > members;
+        typedef ReferenceToType Parent;
+  public:
+        ContextInstType( const Type::Qualifiers &tq, const std::string &name ) : Parent( tq, name ) {}
+        ContextInstType( const ContextInstType &other );
+        ~ContextInstType();
+        std::list< Declaration* >& get_members() { return members; }
+        virtual ContextInstType *clone() const { return new ContextInstType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+  private:
+        virtual std::string typeString() const;
+        // this member is filled in by the validate pass, which instantiates the members of the correponding
+        // aggregate with the actual type parameters specified for this use of the context
+        std::list< Declaration* > members;
 };
 class TypeInstType : public ReferenceToType {
     typedef ReferenceToType Parent;
   public:
     TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType );
     TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype );
     TypeInstType( const TypeInstType &other ) : Parent( other ), baseType( other.baseType ), isFtype( other.isFtype ) {}
     TypeDecl *get_baseType() const { return baseType; }
     void set_baseType( TypeDecl *newValue );
     bool get_isFtype() const { return isFtype; }
     void set_isFtype( bool newValue ) { isFtype = newValue; }
     virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
     virtual std::string typeString() const;
     // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
     // where the type used here is actually defined
     TypeDecl *baseType;
     bool isFtype;
+        typedef ReferenceToType Parent;
+  public:
+        TypeInstType( const Type::Qualifiers &tq, const std::string &name, TypeDecl *baseType );
+        TypeInstType( const Type::Qualifiers &tq, const std::string &name, bool isFtype );
+        TypeInstType( const TypeInstType &other ) : Parent( other ), baseType( other.baseType ), isFtype( other.isFtype ) {}
+        TypeDecl *get_baseType() const { return baseType; }
+        void set_baseType( TypeDecl *newValue );
+        bool get_isFtype() const { return isFtype; }
+        void set_isFtype( bool newValue ) { isFtype = newValue; }
+        virtual TypeInstType *clone() const { return new TypeInstType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        virtual std::string typeString() const;
+        // this decl is not "owned" by the type inst; it is merely a pointer to elsewhere in the tree,
+        // where the type used here is actually defined
+        TypeDecl *baseType;
+        bool isFtype;
 };
 class TupleType : public Type {
   public:
     TupleType( const Type::Qualifiers &tq );
     TupleType( const TupleType& );
     virtual ~TupleType();
     std::list<Type*>& get_types() { return types; }
     virtual TupleType *clone() const { return new TupleType( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
     std::list<Type*> types;
+        TupleType( const Type::Qualifiers &tq );
+        TupleType( const TupleType& );
+        virtual ~TupleType();
+        std::list<Type*>& get_types() { return types; }
+        virtual TupleType *clone() const { return new TupleType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::list<Type*> types;
 };
 class TypeofType : public Type {
   public:
     TypeofType( const Type::Qualifiers &tq, Expression *expr );
     TypeofType( const TypeofType& );
     virtual ~TypeofType();
     Expression *get_expr() const { return expr; }
     void set_expr( Expression *newValue ) { expr = newValue; }
     virtual TypeofType *clone() const { return new TypeofType( *this ); }
     virtual void accept( Visitor &v ) { v.visit( this ); }
     virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
     virtual void print( std::ostream &os, int indent = 0 ) const;
   private:
     Expression *expr;
+        TypeofType( const Type::Qualifiers &tq, Expression *expr );
+        TypeofType( const TypeofType& );
+        virtual ~TypeofType();
+        Expression *get_expr() const { return expr; }
+        void set_expr( Expression *newValue ) { expr = newValue; }
+        virtual TypeofType *clone() const { return new TypeofType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        Expression *expr;
 };
 class AttrType : public Type {
   public:
+    AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr );
+    AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type );
+    AttrType( const AttrType& );
+    virtual ~AttrType();
+    std::string get_name() const { return name; }
+    void set_name( const std::string &newValue ) { name = newValue; }
+    Expression *get_expr() const { return expr; }
+    void set_expr( Expression *newValue ) { expr = newValue; }
+    Type *get_type() const { return type; }
+    void set_type( Type *newValue ) { type = newValue; }
+    bool get_isType() const { return isType; }
+    void set_isType( bool newValue ) { isType = newValue; }
+    virtual AttrType *clone() const { return new AttrType( *this ); }
+    virtual void accept( Visitor &v ) { v.visit( this ); }
+    virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+    virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+    std::string name;
+    Expression *expr;
+    Type *type;
+    bool isType;
+        AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr );
+        AttrType( const Type::Qualifiers &tq, const std::string &name, Type *type );
+        AttrType( const AttrType& );
+        virtual ~AttrType();
+        std::string get_name() const { return name; }
+        void set_name( const std::string &newValue ) { name = newValue; }
+        Expression *get_expr() const { return expr; }
+        void set_expr( Expression *newValue ) { expr = newValue; }
+        Type *get_type() const { return type; }
+        void set_type( Type *newValue ) { type = newValue; }
+        bool get_isType() const { return isType; }
+        void set_isType( bool newValue ) { isType = newValue; }
+        virtual AttrType *clone() const { return new AttrType( *this ); }
+        virtual void accept( Visitor &v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator &m ) { return m.mutate( this ); }
+        virtual void print( std::ostream &os, int indent = 0 ) const;
+  private:
+        std::string name;
+        Expression *expr;
+        Type *type;
+        bool isType;
 };
 inline Type::Qualifiers &Type::Qualifiers::operator+=( const Type::Qualifiers &other ) {
     isConst |= other.isConst;
     isVolatile |= other.isVolatile;
     isRestrict |= other.isRestrict;
     isLvalue |= other.isLvalue;
     isAtomic |= other.isAtomic;
     return *this;
+        isConst |= other.isConst;
+        isVolatile |= other.isVolatile;
+        isRestrict |= other.isRestrict;
+        isLvalue |= other.isLvalue;
+        isAtomic |= other.isAtomic;
+        return *this;
+}
 inline Type::Qualifiers &Type::Qualifiers::operator-=( const Type::Qualifiers &other ) {
     if ( other.isConst ) isConst = 0;
     if ( other.isVolatile ) isVolatile = 0;
     if ( other.isRestrict ) isRestrict = 0;
     if ( other.isAtomic ) isAtomic = 0;
     return *this;
+        if ( other.isConst ) isConst = 0;
+        if ( other.isVolatile ) isVolatile = 0;
+        if ( other.isRestrict ) isRestrict = 0;
+        if ( other.isAtomic ) isAtomic = 0;
+        return *this;
+}
 inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
     Qualifiers q = other;
     q += *this;
     return q;
+        Qualifiers q = other;
+        q += *this;
+        return q;
+}
 inline bool Type::Qualifiers::operator==( const Qualifiers &other ) {
     return isConst == other.isConst
         && isVolatile == other.isVolatile
         && isRestrict == other.isRestrict
+        return isConst == other.isConst
+                && isVolatile == other.isVolatile
+                && isRestrict == other.isRestrict
 //      && isLvalue == other.isLvalue
         && isAtomic == other.isAtomic;
+                && isAtomic == other.isAtomic;
+}
 inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
     return isConst != other.isConst
         || isVolatile != other.isVolatile
         || isRestrict != other.isRestrict
+        return isConst != other.isConst
+                || isVolatile != other.isVolatile
+                || isRestrict != other.isRestrict
 //      || isLvalue != other.isLvalue
         || isAtomic != other.isAtomic;
+                || isAtomic != other.isAtomic;
+}
 inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
     return isConst <= other.isConst
         && isVolatile <= other.isVolatile
         && isRestrict <= other.isRestrict
+        return isConst <= other.isConst
+                && isVolatile <= other.isVolatile
+                && isRestrict <= other.isRestrict
 //      && isLvalue >= other.isLvalue
         && isAtomic == other.isAtomic;
+                && isAtomic == other.isAtomic;
+}
 inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
     return isConst >= other.isConst
         && isVolatile >= other.isVolatile
         && isRestrict >= other.isRestrict
+        return isConst >= other.isConst
+                && isVolatile >= other.isVolatile
+                && isRestrict >= other.isRestrict
 //      && isLvalue <= other.isLvalue
         && isAtomic == other.isAtomic;
+                && isAtomic == other.isAtomic;
+}
 inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
     return operator!=( other ) && operator<=( other );
+        return operator!=( other ) && operator<=( other );
+}
 inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
     return operator!=( other ) && operator>=( other );
+        return operator!=( other ) && operator>=( other );
+}
 #endif // TYPE_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/TypeDecl.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// TypeDecl.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:02:11 2015
+// Update Count     : 1
+//
 #include "Declaration.h"
 #include "Type.h"
 #include "utility.h"
+TypeDecl::TypeDecl( const std::string &name, StorageClass sc, Type *type, Kind kind )
+    : Parent( name, sc, type ), kind( kind )
+{
+TypeDecl::TypeDecl( const std::string &name, StorageClass sc, Type *type, Kind kind ) : Parent( name, sc, type ), kind( kind ) {
+}
+TypeDecl::TypeDecl( const TypeDecl &other )
+    : Parent( other ), kind( other.kind )
+{
+TypeDecl::TypeDecl( const TypeDecl &other ) : Parent( other ), kind( other.kind ) {
+}
+std::string
+TypeDecl::typeString() const
+{
+    static const char *kindNames[] = { "type", "incomplete type", "function type" };
+    return kindNames[ kind ];
+std::string TypeDecl::typeString() const {
+        static const char *kindNames[] = { "type", "incomplete type", "function type" };
+        return kindNames[ kind ];
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/TypeExpr.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: TypeExpr.cc,v 1.4 2005/08/29 20:59:26 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// TypeExpr.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:03:15 2015
+// Update Count     : 1
+//
 #include "Expression.h"
 …
 #include "utility.h"
+TypeExpr::TypeExpr( Type *type )
+    : type( type )
+{
+TypeExpr::TypeExpr( Type *type ) : type( type ) {
+}
+TypeExpr::TypeExpr( const TypeExpr &other )
+    : type( maybeClone( other.type ) )
+{
+TypeExpr::TypeExpr( const TypeExpr &other ) : type( maybeClone( other.type ) ) {
+}
+TypeExpr::~TypeExpr()
+{
+    delete type;
+TypeExpr::~TypeExpr() {
+        delete type;
+}
+void
+TypeExpr::print( std::ostream &os, int indent ) const
+{
+    if ( type ) type->print( os, indent );
+    Expression::print( os, indent );
+void TypeExpr::print( std::ostream &os, int indent ) const {
+        if ( type ) type->print( os, indent );
+        Expression::print( os, indent );
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/TypeSubstitution.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: TypeSubstitution.cc,v 1.9 2005/08/29 20:59:26 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// TypeSubstitution.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:10:04 2015
+// Update Count     : 2
+//
 #include "Type.h"
 #include "TypeSubstitution.h"
+TypeSubstitution::TypeSubstitution()
+{
+TypeSubstitution::TypeSubstitution() {
+}
+TypeSubstitution::TypeSubstitution( const TypeSubstitution &other )
+{
+    initialize( other, *this );
+TypeSubstitution::TypeSubstitution( const TypeSubstitution &other ) {
+        initialize( other, *this );
+}
+TypeSubstitution::~TypeSubstitution()
+{
+    for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
+        delete( i->second );
+    }
+    for ( VarEnvType::iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
+        delete( i->second );
+    }
+TypeSubstitution::~TypeSubstitution() {
+        for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
+                delete( i->second );
+        }
+        for ( VarEnvType::iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
+                delete( i->second );
+        }
+}
+TypeSubstitution &
+TypeSubstitution::operator=( const TypeSubstitution &other )
+{
+    if ( this == &other ) return *this;
+    initialize( other, *this );
+    return *this;
+TypeSubstitution &TypeSubstitution::operator=( const TypeSubstitution &other ) {
+        if ( this == &other ) return *this;
+        initialize( other, *this );
+        return *this;
+}
+void
+TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest )
+{
+    dest.typeEnv.clear();
+    dest.varEnv.clear();
+    dest.add( src );
+void TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest ) {
+        dest.typeEnv.clear();
+        dest.varEnv.clear();
+        dest.add( src );
+}
+void
+TypeSubstitution::add( const TypeSubstitution &other )
+{
+    for ( TypeEnvType::const_iterator i = other.typeEnv.begin(); i != other.typeEnv.end(); ++i ) {
+        typeEnv[ i->first ] = i->second->clone();
+    }
+    for ( VarEnvType::const_iterator i = other.varEnv.begin(); i != other.varEnv.end(); ++i ) {
+        varEnv[ i->first ] = i->second->clone();
+    }
+void TypeSubstitution::add( const TypeSubstitution &other ) {
+        for ( TypeEnvType::const_iterator i = other.typeEnv.begin(); i != other.typeEnv.end(); ++i ) {
+                typeEnv[ i->first ] = i->second->clone();
+        } // for
+        for ( VarEnvType::const_iterator i = other.varEnv.begin(); i != other.varEnv.end(); ++i ) {
+                varEnv[ i->first ] = i->second->clone();
+        } // for
+}
+void
+TypeSubstitution::add( std::string formalType, Type *actualType )
+{
+    TypeEnvType::iterator i = typeEnv.find( formalType );
+    if ( i != typeEnv.end() ) {
+        delete i->second;
+    }
+    typeEnv[ formalType ] = actualType->clone();
+void TypeSubstitution::add( std::string formalType, Type *actualType ) {
+        TypeEnvType::iterator i = typeEnv.find( formalType );
+        if ( i != typeEnv.end() ) {
+                delete i->second;
+        } // if
+        typeEnv[ formalType ] = actualType->clone();
+}
+void
+TypeSubstitution::remove( std::string formalType )
+{
+    TypeEnvType::iterator i = typeEnv.find( formalType );
+    if ( i != typeEnv.end() ) {
+        delete i->second;
+        typeEnv.erase( formalType );
+    }
+void TypeSubstitution::remove( std::string formalType ) {
+        TypeEnvType::iterator i = typeEnv.find( formalType );
+        if ( i != typeEnv.end() ) {
+                delete i->second;
+                typeEnv.erase( formalType );
+        } // if
+}
+Type *
+TypeSubstitution::lookup( std::string formalType ) const
+{
+    TypeEnvType::const_iterator i = typeEnv.find( formalType );
+    if ( i == typeEnv.end() ) {
+        return 0;
+    } else {
+        return i->second;
+    }
+Type *TypeSubstitution::lookup( std::string formalType ) const {
+        TypeEnvType::const_iterator i = typeEnv.find( formalType );
+        if ( i == typeEnv.end() ) {
+                return 0;
+        } else {
+                return i->second;
+        } // if
+}
+bool
+TypeSubstitution::empty() const
+{
+    return typeEnv.empty() && varEnv.empty();
+bool TypeSubstitution::empty() const {
+        return typeEnv.empty() && varEnv.empty();
+}
+void
+TypeSubstitution::normalize()
+{
+    do {
+        subCount = 0;
+        freeOnly = true;
+        for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
+            i->second = i->second->acceptMutator( *this );
+        }
+    } while ( subCount );
+void TypeSubstitution::normalize() {
+        do {
+                subCount = 0;
+                freeOnly = true;
+                for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
+                        i->second = i->second->acceptMutator( *this );
+                }
+        } while ( subCount );
+}
+Type*
+TypeSubstitution::mutate(TypeInstType *inst)
+{
+    BoundVarsType::const_iterator bound = boundVars.find( inst->get_name() );
+    if ( bound != boundVars.end() ) return inst;
+    TypeEnvType::const_iterator i = typeEnv.find( inst->get_name() );
+    if ( i == typeEnv.end() ) {
+        return inst;
+    } else {
+Type * TypeSubstitution::mutate( TypeInstType *inst ) {
+        BoundVarsType::const_iterator bound = boundVars.find( inst->get_name() );
+        if ( bound != boundVars.end() ) return inst;
+        TypeEnvType::const_iterator i = typeEnv.find( inst->get_name() );
+        if ( i == typeEnv.end() ) {
+                return inst;
+        } else {
 ///         std::cout << "found " << inst->get_name() << ", replacing with ";
 ///         i->second->print( std::cout );
 ///         std::cout << std::endl;
         subCount++;
         Type *newtype = i->second->clone();
         newtype->get_qualifiers() += inst->get_qualifiers();
         delete inst;
         return newtype;
+    }
+                subCount++;
+                Type *newtype = i->second->clone();
+                newtype->get_qualifiers() += inst->get_qualifiers();
+                delete inst;
+                return newtype;
+        } // if
+}
+Expression*
+TypeSubstitution::mutate(NameExpr *nameExpr)
+{
+    VarEnvType::const_iterator i = varEnv.find( nameExpr->get_name() );
+    if ( i == varEnv.end() ) {
+        return nameExpr;
+    } else {
+        subCount++;
+        delete nameExpr;
+        return i->second->clone();
+    }
+Expression * TypeSubstitution::mutate( NameExpr *nameExpr ) {
+        VarEnvType::const_iterator i = varEnv.find( nameExpr->get_name() );
+        if ( i == varEnv.end() ) {
+                return nameExpr;
+        } else {
+                subCount++;
+                delete nameExpr;
+                return i->second->clone();
+        } // if
+}
 template< typename TypeClass >
+Type *
+TypeSubstitution::handleType( TypeClass *type )
+{
+    BoundVarsType oldBoundVars( boundVars );
+    if ( freeOnly ) {
+        for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
+            boundVars.insert( (*tyvar)->get_name() );
+        }
+    }
+    Type *ret = Mutator::mutate( type );
+    boundVars = oldBoundVars;
+    return ret;
+Type *TypeSubstitution::handleType( TypeClass *type ) {
+        BoundVarsType oldBoundVars( boundVars );
+        if ( freeOnly ) {
+                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
+                        boundVars.insert( (*tyvar )->get_name() );
+                } // for
+        } // if
+        Type *ret = Mutator::mutate( type );
+        boundVars = oldBoundVars;
+        return ret;
+}
+Type*
+TypeSubstitution::mutate(VoidType *basicType)
+{
+    return handleType( basicType );
+Type * TypeSubstitution::mutate( VoidType *basicType ) {
+        return handleType( basicType );
+}
+Type*
+TypeSubstitution::mutate(BasicType *basicType)
+{
+    return handleType( basicType );
+Type * TypeSubstitution::mutate( BasicType *basicType ) {
+        return handleType( basicType );
+}
+Type*
+TypeSubstitution::mutate(PointerType *pointerType)
+{
+    return handleType( pointerType );
+Type * TypeSubstitution::mutate( PointerType *pointerType ) {
+        return handleType( pointerType );
+}
+Type*
+TypeSubstitution::mutate(ArrayType *arrayType)
+{
+    return handleType( arrayType );
+Type * TypeSubstitution::mutate( ArrayType *arrayType ) {
+        return handleType( arrayType );
+}
+Type*
+TypeSubstitution::mutate(FunctionType *functionType)
+{
+    return handleType( functionType );
+Type * TypeSubstitution::mutate( FunctionType *functionType ) {
+        return handleType( functionType );
+}
+Type*
+TypeSubstitution::mutate(StructInstType *aggregateUseType)
+{
+    return handleType( aggregateUseType );
+Type * TypeSubstitution::mutate( StructInstType *aggregateUseType ) {
+        return handleType( aggregateUseType );
+}
+Type*
+TypeSubstitution::mutate(UnionInstType *aggregateUseType)
+{
+    return handleType( aggregateUseType );
+Type * TypeSubstitution::mutate( UnionInstType *aggregateUseType ) {
+        return handleType( aggregateUseType );
+}
+Type*
+TypeSubstitution::mutate(EnumInstType *aggregateUseType)
+{
+    return handleType( aggregateUseType );
+Type * TypeSubstitution::mutate( EnumInstType *aggregateUseType ) {
+        return handleType( aggregateUseType );
+}
+Type*
+TypeSubstitution::mutate(ContextInstType *aggregateUseType)
+{
+    return handleType( aggregateUseType );
+Type * TypeSubstitution::mutate( ContextInstType *aggregateUseType ) {
+        return handleType( aggregateUseType );
+}
+Type*
+TypeSubstitution::mutate(TupleType *tupleType)
+{
+    return handleType( tupleType );
+Type * TypeSubstitution::mutate( TupleType *tupleType ) {
+        return handleType( tupleType );
+}
+void
+TypeSubstitution::print( std::ostream &os, int indent ) const
+{
+    os << std::string( indent, ' ' ) << "Types:" << std::endl;
+    for ( TypeEnvType::const_iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
+        os << std::string( indent+2, ' ' ) << i->first << " -> ";
+        i->second->print( os, indent+4 );
+        os << std::endl;
+    }
+    os << std::string( indent, ' ' ) << "Non-types:" << std::endl;
+    for ( VarEnvType::const_iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
+        os << std::string( indent+2, ' ' ) << i->first << " -> ";
+        i->second->print( os, indent+4 );
+        os << std::endl;
+    }
+void TypeSubstitution::print( std::ostream &os, int indent ) const {
+        os << std::string( indent, ' ' ) << "Types:" << std::endl;
+        for ( TypeEnvType::const_iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
+                os << std::string( indent+2, ' ' ) << i->first << " -> ";
+                i->second->print( os, indent+4 );
+                os << std::endl;
+        } // for
+        os << std::string( indent, ' ' ) << "Non-types:" << std::endl;
+        for ( VarEnvType::const_iterator i = varEnv.begin(); i != varEnv.end(); ++i ) {
+                os << std::string( indent+2, ' ' ) << i->first << " -> ";
+                i->second->print( os, indent+4 );
+                os << std::endl;
+        } // for
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/TypeSubstitution.h

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: TypeSubstitution.h,v 1.9 2005/08/29 20:59:26 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// TypeSubstitution.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:12:30 2015
+// Update Count     : 1
+//
 #ifndef SYNTREE_TYPESUBSTITUTION_H
 #define SYNTREE_TYPESUBSTITUTION_H
+#ifndef TYPESUBSTITUTION_H
+#define TYPESUBSTITUTION_H
 #include <map>
 …
 #include "SynTree/Expression.h"
+class TypeSubstitution : public Mutator {
+        typedef Mutator Parent;
+  public:
+        TypeSubstitution();
+        template< typename FormalIterator, typename ActualIterator >
+        TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
+        TypeSubstitution( const TypeSubstitution &other );
+        virtual ~TypeSubstitution();
+        TypeSubstitution &operator=( const TypeSubstitution &other );
+        template< typename SynTreeClass > int apply( SynTreeClass *&input );
+        template< typename SynTreeClass > int applyFree( SynTreeClass *&input );
+        void add( std::string formalType, Type *actualType );
+        void add( const TypeSubstitution &other );
+        void remove( std::string formalType );
+        Type *lookup( std::string formalType ) const;
+        bool empty() const;
+        template< typename FormalIterator, typename ActualIterator >
+        void add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
+        template< typename TypeInstListIterator >
+        void extract( TypeInstListIterator begin, TypeInstListIterator end, TypeSubstitution &result );
+        void normalize();
+class TypeSubstitution : public Mutator
+{
+    typedef Mutator Parent;
+public:
+    TypeSubstitution();
+    template< typename FormalIterator, typename ActualIterator >
+    TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
+    TypeSubstitution( const TypeSubstitution &other );
+    virtual ~TypeSubstitution();
+    TypeSubstitution &operator=( const TypeSubstitution &other );
+    template< typename SynTreeClass > int apply( SynTreeClass *&input );
+    template< typename SynTreeClass > int applyFree( SynTreeClass *&input );
+    void add( std::string formalType, Type *actualType );
+    void add( const TypeSubstitution &other );
+    void remove( std::string formalType );
+    Type *lookup( std::string formalType ) const;
+    bool empty() const;
+    template< typename FormalIterator, typename ActualIterator >
+    void add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin );
+    template< typename TypeInstListIterator >
+    void extract( TypeInstListIterator begin, TypeInstListIterator end, TypeSubstitution &result );
+    void normalize();
+        void print( std::ostream &os, int indent = 0 ) const;
+        TypeSubstitution *clone() const { return new TypeSubstitution( *this ); }
+  private:
+        virtual Type* mutate(TypeInstType *aggregateUseType);
+        virtual Expression* mutate(NameExpr *nameExpr);
+        template< typename TypeClass > Type *handleType( TypeClass *type );
+        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(TupleType *tupleType);
+        // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
+        void initialize( const TypeSubstitution &src, TypeSubstitution &dest );
+    void print( std::ostream &os, int indent = 0 ) const;
+    TypeSubstitution *clone() const { return new TypeSubstitution( *this ); }
+private:
+    virtual Type* mutate(TypeInstType *aggregateUseType);
+    virtual Expression* mutate(NameExpr *nameExpr);
+    template< typename TypeClass > Type *handleType( TypeClass *type );
+    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(TupleType *tupleType);
+    // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
+    void initialize( const TypeSubstitution &src, TypeSubstitution &dest );
+    typedef std::map< std::string, Type* > TypeEnvType;
+    typedef std::map< std::string, Expression* > VarEnvType;
+    typedef std::set< std::string > BoundVarsType;
+    TypeEnvType typeEnv;
+    VarEnvType varEnv;
+    BoundVarsType boundVars;
+    int subCount;
+    bool freeOnly;
+        typedef std::map< std::string, Type* > TypeEnvType;
+        typedef std::map< std::string, Expression* > VarEnvType;
+        typedef std::set< std::string > BoundVarsType;
+        TypeEnvType typeEnv;
+        VarEnvType varEnv;
+        BoundVarsType boundVars;
+        int subCount;
+        bool freeOnly;
 };
 template< typename FormalIterator, typename ActualIterator >
+void
+TypeSubstitution::add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin )
+{
+    // FormalIterator points to a TypeDecl
+    // ActualIterator points to a Type
+    FormalIterator formalIt = formalBegin;
+    ActualIterator actualIt = actualBegin;
+    for ( ; formalIt != formalEnd; ++formalIt, ++actualIt ) {
+        if ( TypeDecl *formal = dynamic_cast< TypeDecl* >( *formalIt ) ) {
+            if ( TypeExpr *actual = dynamic_cast< TypeExpr* >( *actualIt ) ) {
+                if ( formal->get_name() != "" ) {
+                    TypeEnvType::iterator i = typeEnv.find( formal->get_name() );
+                    if ( i != typeEnv.end() ) {
+                        delete i->second;
+                    }
+                    typeEnv[ formal->get_name() ] = actual->get_type()->clone();
+                }
+            } else {
+                throw SemanticError( "Attempt to provide non-type parameter for type parameter", formal );
+            }
+        } else {
+            // TODO: type check the formal and actual parameters
+            if ( (*formalIt)->get_name() != "" ) {
+                varEnv[ (*formalIt)->get_name() ] = (*actualIt)->clone();
+            }
+        }
+    }
+void TypeSubstitution::add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
+        // FormalIterator points to a TypeDecl
+        // ActualIterator points to a Type
+        FormalIterator formalIt = formalBegin;
+        ActualIterator actualIt = actualBegin;
+        for ( ; formalIt != formalEnd; ++formalIt, ++actualIt ) {
+                if ( TypeDecl *formal = dynamic_cast< TypeDecl* >( *formalIt ) ) {
+                        if ( TypeExpr *actual = dynamic_cast< TypeExpr* >( *actualIt ) ) {
+                                if ( formal->get_name() != "" ) {
+                                        TypeEnvType::iterator i = typeEnv.find( formal->get_name() );
+                                        if ( i != typeEnv.end() ) {
+                                                delete i->second;
+                                        } // if
+                                        typeEnv[ formal->get_name() ] = actual->get_type()->clone();
+                                } // if
+                        } else {
+                                throw SemanticError( "Attempt to provide non-type parameter for type parameter", formal );
+                        } // if
+                } else {
+                        // TODO: type check the formal and actual parameters
+                        if ( (*formalIt)->get_name() != "" ) {
+                                varEnv[ (*formalIt)->get_name() ] = (*actualIt)->clone();
+                        } // if
+                } // if
+        } // for
+}
 …
 TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin )
+{
     add( formalBegin, formalEnd, actualBegin );
+        add( formalBegin, formalEnd, actualBegin );
+}
 template< typename SynTreeClass >
+int
+TypeSubstitution::apply( SynTreeClass *&input )
+{
+    assert( input );
+    subCount = 0;
+    freeOnly = false;
+    input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
+    assert( input );
+int TypeSubstitution::apply( SynTreeClass *&input ) {
+        assert( input );
+        subCount = 0;
+        freeOnly = false;
+        input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
+        assert( input );
 ///     std::cout << "substitution result is: ";
 ///     newType->print( std::cout );
 ///     std::cout << std::endl;
     return subCount;
+        return subCount;
+}
 template< typename SynTreeClass >
+int
+TypeSubstitution::applyFree( SynTreeClass *&input )
+{
+    assert( input );
+    subCount = 0;
+    freeOnly = true;
+    input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
+    assert( input );
+int TypeSubstitution::applyFree( SynTreeClass *&input ) {
+        assert( input );
+        subCount = 0;
+        freeOnly = true;
+        input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
+        assert( input );
 ///     std::cout << "substitution result is: ";
 ///     newType->print( std::cout );
 ///     std::cout << std::endl;
     return subCount;
+        return subCount;
+}
 template< typename TypeInstListIterator >
+void
+TypeSubstitution::extract( TypeInstListIterator begin, TypeInstListIterator end, TypeSubstitution &result )
+{
+    while ( begin != end ) {
+        TypeEnvType::iterator cur = typeEnv.find( (*begin++)->get_name() );
+        if ( cur != typeEnv.end() ) {
+            result.typeEnv[ cur->first ] = cur->second;
+            typeEnv.erase( cur );
+        }
+    }
+void TypeSubstitution::extract( TypeInstListIterator begin, TypeInstListIterator end, TypeSubstitution &result ) {
+        while ( begin != end ) {
+                TypeEnvType::iterator cur = typeEnv.find( (*begin++)->get_name() );
+                if ( cur != typeEnv.end() ) {
+                        result.typeEnv[ cur->first ] = cur->second;
+                        typeEnv.erase( cur );
+                } // if
+        } // while
+}
 // helper function
 template< typename FormalIterator, typename ActualIterator, typename MemberIterator, typename OutputIterator >
+void
+applySubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actual, MemberIterator memberBegin, MemberIterator memberEnd, OutputIterator out )
+{
+    // Instantiate each member of the context given the actual parameters specified, and store the
+    // instantiations for use by the indexer
+void applySubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actual, MemberIterator memberBegin, MemberIterator memberEnd, OutputIterator out ) {
+        // Instantiate each member of the context given the actual parameters specified, and store the
+        // instantiations for use by the indexer
     TypeSubstitution sub = TypeSubstitution( formalBegin, formalEnd, actual );
     for ( std::list< Declaration* >::iterator i = memberBegin; i != memberEnd; ++i ) {
         Declaration *newdecl = (*i)->clone();
         sub.apply( newdecl );
         *out++ = newdecl;
+    }
+        TypeSubstitution sub = TypeSubstitution( formalBegin, formalEnd, actual );
+        for ( std::list< Declaration* >::iterator i = memberBegin; i != memberEnd; ++i ) {
+                Declaration *newdecl = (*i)->clone();
+                sub.apply( newdecl );
+                *out++ = newdecl;
+        } // for
+}
+#endif // TYPESUBSTITUTION_H
+#endif /* #ifndef SYNTREE_TYPESUBSTITUTION_H */
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/TypeofType.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: TypeofType.cc,v 1.3 2005/08/29 20:59:27 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// TypeofType.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:13:29 2015
+// Update Count     : 2
+//
 #include "Type.h"
 …
 #include "utility.h"
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr )
+    : Type( tq ), expr( expr )
+{
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr ) : Type( tq ), expr( expr ) {
+}
+TypeofType::TypeofType( const TypeofType &other )
+    : Type( other ), expr( maybeClone( other.expr ) )
+{
+TypeofType::TypeofType( const TypeofType &other ) : Type( other ), expr( maybeClone( other.expr ) ) {
+}
+TypeofType::~TypeofType()
+{
+    delete expr;
+TypeofType::~TypeofType() {
+        delete expr;
+}
+void
+TypeofType::print( std::ostream &os, int indent ) const
+{
+    Type::print( os, indent );
+    os << "type-of expression ";
+    if ( expr ) {
+        expr->print( os, indent );
+    }
+void TypeofType::print( std::ostream &os, int indent ) const {
+        Type::print( os, indent );
+        os << "type-of expression ";
+        if ( expr ) {
+                expr->print( os, indent );
+        }
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Visitor.cc

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Visitor.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:14:51 2015
+// Update Count     : 2
+//
 #include <cassert>
 #include "Visitor.h"
 …
 #include "Constant.h"
 Visitor::Visitor() {}
 Visitor::~Visitor() {}
+void Visitor::visit(ObjectDecl *objectDecl) {
+    maybeAccept( objectDecl->get_type(), *this );
+    maybeAccept( objectDecl->get_init(), *this );
+    maybeAccept( objectDecl->get_bitfieldWidth(), *this );
+}
+void Visitor::visit(FunctionDecl *functionDecl) {
+    maybeAccept( functionDecl->get_functionType(), *this );
+    acceptAll( functionDecl->get_oldDecls(), *this );
+    maybeAccept( functionDecl->get_statements(), *this );
+}
+void Visitor::visit(AggregateDecl *aggregateDecl) {
+    acceptAll( aggregateDecl->get_parameters(), *this );
+    acceptAll( aggregateDecl->get_members(), *this );
+}
+void Visitor::visit(StructDecl *aggregateDecl) {
+    visit( static_cast< AggregateDecl* >( aggregateDecl ) );
+}
+void Visitor::visit(UnionDecl *aggregateDecl) {
+    visit( static_cast< AggregateDecl* >( aggregateDecl ) );
+}
+void Visitor::visit(EnumDecl *aggregateDecl) {
+    visit( static_cast< AggregateDecl* >( aggregateDecl ) );
+}
+void Visitor::visit(ContextDecl *aggregateDecl) {
+    visit( static_cast< AggregateDecl* >( aggregateDecl ) );
+}
+void Visitor::visit(NamedTypeDecl *typeDecl) {
+    acceptAll( typeDecl->get_parameters(), *this );
+    acceptAll( typeDecl->get_assertions(), *this );
+    maybeAccept( typeDecl->get_base(), *this );
+}
+void Visitor::visit(TypeDecl *typeDecl) {
+    visit( static_cast< NamedTypeDecl* >( typeDecl ) );
+}
+void Visitor::visit(TypedefDecl *typeDecl) {
+    visit( static_cast< NamedTypeDecl* >( typeDecl ) );
+}
+void Visitor::visit(CompoundStmt *compoundStmt) {
+    acceptAll( compoundStmt->get_kids(), *this );
+}
+void Visitor::visit(ExprStmt *exprStmt) {
+    maybeAccept( exprStmt->get_expr(), *this );
+}
+void Visitor::visit(IfStmt *ifStmt) {
+    maybeAccept( ifStmt->get_condition(), *this );
+    maybeAccept( ifStmt->get_thenPart(), *this );
+    maybeAccept( ifStmt->get_elsePart(), *this );
+}
+void Visitor::visit(WhileStmt *whileStmt) {
+    maybeAccept( whileStmt->get_condition(), *this );
+    maybeAccept( whileStmt->get_body(), *this );
+}
+void Visitor::visit(ForStmt *forStmt) {
+    // ForStmt still needs to be fixed
+    maybeAccept( forStmt->get_initialization(), *this );
+    maybeAccept( forStmt->get_condition(), *this );
+    maybeAccept( forStmt->get_increment(), *this );
+    maybeAccept( forStmt->get_body(), *this );
+}
+void Visitor::visit(SwitchStmt *switchStmt) {
+    maybeAccept( switchStmt->get_condition(), *this );
+    acceptAll( switchStmt->get_branches(), *this );
+}
+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) {
+    maybeAccept( caseStmt->get_condition(), *this );
+    acceptAll( caseStmt->get_statements(), *this );
+}
+void Visitor::visit(BranchStmt *branchStmt) {
+}
+void Visitor::visit(ReturnStmt *returnStmt) {
+    maybeAccept( returnStmt->get_expr(), *this );
+}
+void Visitor::visit(TryStmt *tryStmt) {
+    maybeAccept( tryStmt->get_block(), *this );
+    acceptAll( tryStmt->get_catchers(), *this );
+}
+void Visitor::visit(CatchStmt *catchStmt) {
+    maybeAccept( catchStmt->get_decl(), *this );
+    maybeAccept( catchStmt->get_body(), *this );
+}
+void Visitor::visit(FinallyStmt *finalStmt) {
+    maybeAccept( finalStmt->get_block(), *this );
+}
+void Visitor::visit(NullStmt *nullStmt) {
+}
+void Visitor::visit(DeclStmt *declStmt) {
+    maybeAccept( declStmt->get_decl(), *this );
+}
+void Visitor::visit(ApplicationExpr *applicationExpr) {
+    acceptAll( applicationExpr->get_results(), *this );
+    maybeAccept( applicationExpr->get_function(), *this );
+    acceptAll( applicationExpr->get_args(), *this );
+}
+void Visitor::visit(UntypedExpr *untypedExpr) {
+    acceptAll( untypedExpr->get_results(), *this );
+    acceptAll( untypedExpr->get_args(), *this );
+}
+void Visitor::visit(NameExpr *nameExpr) {
+    acceptAll( nameExpr->get_results(), *this );
+}
+void Visitor::visit(AddressExpr *addressExpr) {
+    acceptAll( addressExpr->get_results(), *this );
+    maybeAccept( addressExpr->get_arg(), *this );
+}
+void Visitor::visit(LabelAddressExpr *labAddressExpr) {
+    acceptAll( labAddressExpr->get_results(), *this );
+    maybeAccept( labAddressExpr->get_arg(), *this );
+}
+void Visitor::visit(CastExpr *castExpr) {
+    acceptAll( castExpr->get_results(), *this );
+    maybeAccept( castExpr->get_arg(), *this );
+}
+void Visitor::visit(UntypedMemberExpr *memberExpr) {
+    acceptAll( memberExpr->get_results(), *this );
+    maybeAccept( memberExpr->get_aggregate(), *this );
+}
+void Visitor::visit(MemberExpr *memberExpr) {
+    acceptAll( memberExpr->get_results(), *this );
+    maybeAccept( memberExpr->get_aggregate(), *this );
+}
+void Visitor::visit(VariableExpr *variableExpr) {
+    acceptAll( variableExpr->get_results(), *this );
+}
+void Visitor::visit(ConstantExpr *constantExpr) {
+    acceptAll( constantExpr->get_results(), *this );
+    maybeAccept( constantExpr->get_constant(), *this );
+}
+void Visitor::visit(SizeofExpr *sizeofExpr) {
+    acceptAll( sizeofExpr->get_results(), *this );
+    if ( sizeofExpr->get_isType() ) {
+        maybeAccept( sizeofExpr->get_type(), *this );
+    } else {
+        maybeAccept( sizeofExpr->get_expr(), *this );
+    }
+}
+void Visitor::visit(AttrExpr *attrExpr) {
+    acceptAll( attrExpr->get_results(), *this );
+    if ( attrExpr->get_isType() ) {
+        maybeAccept( attrExpr->get_type(), *this );
+    } else {
+        maybeAccept( attrExpr->get_expr(), *this );
+    }
+}
+void Visitor::visit(LogicalExpr *logicalExpr) {
+    acceptAll( logicalExpr->get_results(), *this );
+    maybeAccept( logicalExpr->get_arg1(), *this );
+    maybeAccept( logicalExpr->get_arg2(), *this );
+}
+void Visitor::visit(ConditionalExpr *conditionalExpr) {
+    acceptAll( conditionalExpr->get_results(), *this );
+    maybeAccept( conditionalExpr->get_arg1(), *this );
+    maybeAccept( conditionalExpr->get_arg2(), *this );
+    maybeAccept( conditionalExpr->get_arg3(), *this );
+}
+void Visitor::visit(CommaExpr *commaExpr) {
+    acceptAll( commaExpr->get_results(), *this );
+    maybeAccept( commaExpr->get_arg1(), *this );
+    maybeAccept( commaExpr->get_arg2(), *this );
+}
+void Visitor::visit(TupleExpr *tupleExpr) {
+    acceptAll( tupleExpr->get_results(), *this );
+    acceptAll( tupleExpr->get_exprs(), *this );
+}
+void Visitor::visit(SolvedTupleExpr *tupleExpr) {
+    acceptAll( tupleExpr->get_results(), *this );
+    acceptAll( tupleExpr->get_exprs(), *this );
+}
+void Visitor::visit(TypeExpr *typeExpr) {
+    acceptAll( typeExpr->get_results(), *this );
+    maybeAccept( typeExpr->get_type(), *this );
+}
+void Visitor::visit(UntypedValofExpr *valofExpr) {
+    acceptAll( valofExpr->get_results(), *this );
+    maybeAccept( valofExpr->get_body(), *this );
+}
+void Visitor::visit(VoidType *voidType) {
+    acceptAll( voidType->get_forall(), *this );
+}
+void Visitor::visit(BasicType *basicType) {
+    acceptAll( basicType->get_forall(), *this );
+}
+void Visitor::visit(PointerType *pointerType) {
+    acceptAll( pointerType->get_forall(), *this );
+    maybeAccept( pointerType->get_base(), *this );
+}
+void Visitor::visit(ArrayType *arrayType) {
+    acceptAll( arrayType->get_forall(), *this );
+    maybeAccept( arrayType->get_dimension(), *this );
+    maybeAccept( arrayType->get_base(), *this );
+}
+void Visitor::visit(FunctionType *functionType) {
+    acceptAll( functionType->get_forall(), *this );
+    acceptAll( functionType->get_returnVals(), *this );
+    acceptAll( functionType->get_parameters(), *this );
+}
+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) {
+    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) {
+    acceptAll( tupleType->get_forall(), *this );
+    acceptAll( tupleType->get_types(), *this );
+}
+void Visitor::visit(TypeofType *typeofType) {
+    assert( typeofType->get_expr() );
+    typeofType->get_expr()->accept( *this );
+}
+void Visitor::visit(AttrType *attrType) {
+    if ( attrType->get_isType() ) {
+        assert( attrType->get_type() );
+        attrType->get_type()->accept( *this );
+    } else {
+        assert( attrType->get_expr() );
+        attrType->get_expr()->accept( *this );
+    }
+}
+void Visitor::visit(SingleInit *singleInit) {
+    singleInit->get_value()->accept( *this );
+}
+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( ObjectDecl *objectDecl ) {
+        maybeAccept( objectDecl->get_type(), *this );
+        maybeAccept( objectDecl->get_init(), *this );
+        maybeAccept( objectDecl->get_bitfieldWidth(), *this );
+}
+void Visitor::visit( FunctionDecl *functionDecl ) {
+        maybeAccept( functionDecl->get_functionType(), *this );
+        acceptAll( functionDecl->get_oldDecls(), *this );
+        maybeAccept( functionDecl->get_statements(), *this );
+}
+void Visitor::visit( AggregateDecl *aggregateDecl ) {
+        acceptAll( aggregateDecl->get_parameters(), *this );
+        acceptAll( aggregateDecl->get_members(), *this );
+}
+void Visitor::visit( StructDecl *aggregateDecl ) {
+        visit( static_cast< AggregateDecl* >( aggregateDecl ) );
+}
+void Visitor::visit( UnionDecl *aggregateDecl ) {
+        visit( static_cast< AggregateDecl* >( aggregateDecl ) );
+}
+void Visitor::visit( EnumDecl *aggregateDecl ) {
+        visit( static_cast< AggregateDecl* >( aggregateDecl ) );
+}
+void Visitor::visit( ContextDecl *aggregateDecl ) {
+        visit( static_cast< AggregateDecl* >( aggregateDecl ) );
+}
+void Visitor::visit( NamedTypeDecl *typeDecl ) {
+        acceptAll( typeDecl->get_parameters(), *this );
+        acceptAll( typeDecl->get_assertions(), *this );
+        maybeAccept( typeDecl->get_base(), *this );
+}
+void Visitor::visit( TypeDecl *typeDecl ) {
+        visit( static_cast< NamedTypeDecl* >( typeDecl ) );
+}
+void Visitor::visit( TypedefDecl *typeDecl ) {
+        visit( static_cast< NamedTypeDecl* >( typeDecl ) );
+}
+void Visitor::visit( CompoundStmt *compoundStmt ) {
+        acceptAll( compoundStmt->get_kids(), *this );
+}
+void Visitor::visit( ExprStmt *exprStmt ) {
+        maybeAccept( exprStmt->get_expr(), *this );
+}
+void Visitor::visit( IfStmt *ifStmt ) {
+        maybeAccept( ifStmt->get_condition(), *this );
+        maybeAccept( ifStmt->get_thenPart(), *this );
+        maybeAccept( ifStmt->get_elsePart(), *this );
+}
+void Visitor::visit( WhileStmt *whileStmt ) {
+        maybeAccept( whileStmt->get_condition(), *this );
+        maybeAccept( whileStmt->get_body(), *this );
+}
+void Visitor::visit( ForStmt *forStmt ) {
+        // ForStmt still needs to be fixed
+        maybeAccept( forStmt->get_initialization(), *this );
+        maybeAccept( forStmt->get_condition(), *this );
+        maybeAccept( forStmt->get_increment(), *this );
+        maybeAccept( forStmt->get_body(), *this );
+}
+void Visitor::visit( SwitchStmt *switchStmt ) {
+        maybeAccept( switchStmt->get_condition(), *this );
+        acceptAll( switchStmt->get_branches(), *this );
+}
+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 ) {
+        maybeAccept( caseStmt->get_condition(), *this );
+        acceptAll( caseStmt->get_statements(), *this );
+}
+void Visitor::visit( BranchStmt *branchStmt ) {
+}
+void Visitor::visit( ReturnStmt *returnStmt ) {
+        maybeAccept( returnStmt->get_expr(), *this );
+}
+void Visitor::visit( TryStmt *tryStmt ) {
+        maybeAccept( tryStmt->get_block(), *this );
+        acceptAll( tryStmt->get_catchers(), *this );
+}
+void Visitor::visit( CatchStmt *catchStmt ) {
+        maybeAccept( catchStmt->get_decl(), *this );
+        maybeAccept( catchStmt->get_body(), *this );
+}
+void Visitor::visit( FinallyStmt *finalStmt ) {
+        maybeAccept( finalStmt->get_block(), *this );
+}
+void Visitor::visit( NullStmt *nullStmt ) {
+}
+void Visitor::visit( DeclStmt *declStmt ) {
+        maybeAccept( declStmt->get_decl(), *this );
+}
+void Visitor::visit( ApplicationExpr *applicationExpr ) {
+        acceptAll( applicationExpr->get_results(), *this );
+        maybeAccept( applicationExpr->get_function(), *this );
+        acceptAll( applicationExpr->get_args(), *this );
+}
+void Visitor::visit( UntypedExpr *untypedExpr ) {
+        acceptAll( untypedExpr->get_results(), *this );
+        acceptAll( untypedExpr->get_args(), *this );
+}
+void Visitor::visit( NameExpr *nameExpr ) {
+        acceptAll( nameExpr->get_results(), *this );
+}
+void Visitor::visit( AddressExpr *addressExpr ) {
+        acceptAll( addressExpr->get_results(), *this );
+        maybeAccept( addressExpr->get_arg(), *this );
+}
+void Visitor::visit( LabelAddressExpr *labAddressExpr ) {
+        acceptAll( labAddressExpr->get_results(), *this );
+        maybeAccept( labAddressExpr->get_arg(), *this );
+}
+void Visitor::visit( CastExpr *castExpr ) {
+        acceptAll( castExpr->get_results(), *this );
+        maybeAccept( castExpr->get_arg(), *this );
+}
+void Visitor::visit( UntypedMemberExpr *memberExpr ) {
+        acceptAll( memberExpr->get_results(), *this );
+        maybeAccept( memberExpr->get_aggregate(), *this );
+}
+void Visitor::visit( MemberExpr *memberExpr ) {
+        acceptAll( memberExpr->get_results(), *this );
+        maybeAccept( memberExpr->get_aggregate(), *this );
+}
+void Visitor::visit( VariableExpr *variableExpr ) {
+        acceptAll( variableExpr->get_results(), *this );
+}
+void Visitor::visit( ConstantExpr *constantExpr ) {
+        acceptAll( constantExpr->get_results(), *this );
+        maybeAccept( constantExpr->get_constant(), *this );
+}
+void Visitor::visit( SizeofExpr *sizeofExpr ) {
+        acceptAll( sizeofExpr->get_results(), *this );
+        if ( sizeofExpr->get_isType() ) {
+                maybeAccept( sizeofExpr->get_type(), *this );
+        } else {
+                maybeAccept( sizeofExpr->get_expr(), *this );
+        }
+}
+void Visitor::visit( AttrExpr *attrExpr ) {
+        acceptAll( attrExpr->get_results(), *this );
+        if ( attrExpr->get_isType() ) {
+                maybeAccept( attrExpr->get_type(), *this );
+        } else {
+                maybeAccept( attrExpr->get_expr(), *this );
+        }
+}
+void Visitor::visit( LogicalExpr *logicalExpr ) {
+        acceptAll( logicalExpr->get_results(), *this );
+        maybeAccept( logicalExpr->get_arg1(), *this );
+        maybeAccept( logicalExpr->get_arg2(), *this );
+}
+void Visitor::visit( ConditionalExpr *conditionalExpr ) {
+        acceptAll( conditionalExpr->get_results(), *this );
+        maybeAccept( conditionalExpr->get_arg1(), *this );
+        maybeAccept( conditionalExpr->get_arg2(), *this );
+        maybeAccept( conditionalExpr->get_arg3(), *this );
+}
+void Visitor::visit( CommaExpr *commaExpr ) {
+        acceptAll( commaExpr->get_results(), *this );
+        maybeAccept( commaExpr->get_arg1(), *this );
+        maybeAccept( commaExpr->get_arg2(), *this );
+}
+void Visitor::visit( TupleExpr *tupleExpr ) {
+        acceptAll( tupleExpr->get_results(), *this );
+        acceptAll( tupleExpr->get_exprs(), *this );
+}
+void Visitor::visit( SolvedTupleExpr *tupleExpr ) {
+        acceptAll( tupleExpr->get_results(), *this );
+        acceptAll( tupleExpr->get_exprs(), *this );
+}
+void Visitor::visit( TypeExpr *typeExpr ) {
+        acceptAll( typeExpr->get_results(), *this );
+        maybeAccept( typeExpr->get_type(), *this );
+}
+void Visitor::visit( UntypedValofExpr *valofExpr ) {
+        acceptAll( valofExpr->get_results(), *this );
+        maybeAccept( valofExpr->get_body(), *this );
+}
+void Visitor::visit( VoidType *voidType ) {
+        acceptAll( voidType->get_forall(), *this );
+}
+void Visitor::visit( BasicType *basicType ) {
+        acceptAll( basicType->get_forall(), *this );
+}
+void Visitor::visit( PointerType *pointerType ) {
+        acceptAll( pointerType->get_forall(), *this );
+        maybeAccept( pointerType->get_base(), *this );
+}
+void Visitor::visit( ArrayType *arrayType ) {
+        acceptAll( arrayType->get_forall(), *this );
+        maybeAccept( arrayType->get_dimension(), *this );
+        maybeAccept( arrayType->get_base(), *this );
+}
+void Visitor::visit( FunctionType *functionType ) {
+        acceptAll( functionType->get_forall(), *this );
+        acceptAll( functionType->get_returnVals(), *this );
+        acceptAll( functionType->get_parameters(), *this );
+}
+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 ) {
+        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 ) {
+        acceptAll( tupleType->get_forall(), *this );
+        acceptAll( tupleType->get_types(), *this );
+}
+void Visitor::visit( TypeofType *typeofType ) {
+        assert( typeofType->get_expr() );
+        typeofType->get_expr()->accept( *this );
+}
+void Visitor::visit( AttrType *attrType ) {
+        if ( attrType->get_isType() ) {
+                assert( attrType->get_type() );
+                attrType->get_type()->accept( *this );
+        } else {
+                assert( attrType->get_expr() );
+                attrType->get_expr()->accept( *this );
+        } // if
+}
+void Visitor::visit( SingleInit *singleInit ) {
+        singleInit->get_value()->accept( *this );
+}
+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 ) {}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/Visitor.h

-              ra32b204
+              r0dd3a2f
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// Visitor.h --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:15:55 2015
+// Update Count     : 2
+//
 #ifndef VISITOR_H
 #define VISITOR_H
 …
 #include "CompilerError.h"
 class Visitor {
   protected:
     Visitor();
     virtual ~Visitor();
+        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 );
+        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( SingleInit *singleInit );
     virtual void visit( ListInit *listInit );
+        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 );
+        virtual void visit( Constant *constant );
   private:
     virtual void visit( AggregateDecl *aggregateDecl );
     virtual void visit( NamedTypeDecl *typeDecl );
     virtual void visit( ReferenceToType *aggregateUseType );
+        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 ) {
         tree->accept( visitor );
+    }
+        if ( tree ) {
+                tree->accept( visitor );
+        }
+}
 template< typename Container, typename VisitorType >
 inline void acceptAll( Container &container, VisitorType &visitor ) {
+    SemanticError errors;
+    for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+        try {
+            if ( *i ) {
+                (*i)->accept( visitor );
+            }
+        } catch( SemanticError &e ) {
+            errors.append( e );
+        SemanticError errors;
+        for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+                try {
+                        if ( *i ) {
+                                (*i)->accept( visitor );
+                        }
+                } catch( SemanticError &e ) {
+                        errors.append( e );
+                }
+        }
+    }
+    if ( ! errors.isEmpty() ) {
+        throw errors;
+    }
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        }
+}
 template< typename Container, typename VisitorType >
 void acceptAllFold( Container &container, VisitorType &visitor, VisitorType &around ) {
     SemanticError errors;
     for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
         try {
             if ( *i ) {
                 VisitorType *v = new VisitorType;
                 (*i)->accept( *v );
+        SemanticError errors;
+        for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
+                try {
+                        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;
+            }
         } catch( SemanticError &e ) {
             errors.append( e );
+        }
+    }
     if ( ! errors.isEmpty() ) {
         throw errors;
+    }
+                                delete v;
+                        } // if
+                } catch( SemanticError &e ) {
+                        errors.append( e );
+                } // try
+        } // for
+        if ( ! errors.isEmpty() ) {
+                throw errors;
+        } // if
+}
 #endif // VISITOR_H
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

translator/SynTree/VoidType.cc

-              ra32b204
+              r0dd3a2f
+/*
+ * This file is part of the Cforall project
+ *
+ * $Id: VoidType.cc,v 1.3 2005/08/29 20:59:27 rcbilson Exp $
+ *
+ */
+//
+// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// VoidType.cc --
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Mon May 18 11:16:42 2015
+// Update Count     : 1
+//
 #include "Type.h"
+VoidType::VoidType( const Type::Qualifiers &tq )
+    : Type( tq )
+{
+VoidType::VoidType( const Type::Qualifiers &tq ) : Type( tq ) {
+}
+void
+VoidType::print( std::ostream &os, int indent ) const
+{
+    Type::print( os, indent );
+    os << "void ";
+void VoidType::print( std::ostream &os, int indent ) const {
+        Type::print( os, indent );
+        os << "void ";
+}
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //

Context Navigation

Legend:

Download in other formats: