Index: src/SynTree/AddressExpr.cc
===================================================================
--- src/SynTree/AddressExpr.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/AddressExpr.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,44 @@
+//
+// 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 : Tue May 19 16:52:51 2015
+// Update Count     : 6
+//
+
+#include "Expression.h"
+#include "Type.h"
+#include "utility.h"
+
+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() ) );
+	} // for
+}
+
+AddressExpr::AddressExpr( const AddressExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+}
+
+AddressExpr::~AddressExpr() {
+	delete arg;
+}
+
+void AddressExpr::print( std::ostream &os, int indent ) const {
+	os << std::string( indent, ' ' ) << "Address of:" << std::endl;
+	if ( arg ) {
+		arg->print( os, indent+2 );
+	} // if
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/AggregateDecl.cc
===================================================================
--- src/SynTree/AggregateDecl.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/AggregateDecl.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,72 @@
+//
+// 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 : Tue May 19 16:52:08 2015
+// Update Count     : 5
+//
+
+#include "Declaration.h"
+#include "Type.h"
+#include "utility.h"
+
+
+AggregateDecl::AggregateDecl( const std::string &name ) : Parent( name, Declaration::NoStorageClass, LinkageSpec::Cforall ) {
+}
+
+AggregateDecl::AggregateDecl( const AggregateDecl &other ) : Parent( other ) {
+	cloneAll( other.members, members );
+	cloneAll( other.parameters, parameters );
+}
+
+AggregateDecl::~AggregateDecl() {
+	deleteAll( members );
+	deleteAll( parameters );
+}
+
+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 );
+	} // if
+	if ( ! members.empty() ) {
+		os << endl << string( indent+2, ' ' ) << "with members" << endl;
+		printAll( members, os, indent+4 );
+	} // if
+}
+
+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 );
+	} // if
+}
+
+std::string StructDecl::typeString() const { return "struct"; }
+
+std::string UnionDecl::typeString() const { return "union"; }
+
+std::string EnumDecl::typeString() const { return "enum"; }
+
+std::string ContextDecl::typeString() const { return "context"; }
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/ApplicationExpr.cc
===================================================================
--- src/SynTree/ApplicationExpr.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/ApplicationExpr.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,87 @@
+//
+// 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>
+
+#include "Expression.h"
+#include "Declaration.h"
+#include "Type.h"
+#include "TypeSubstitution.h"
+#include "utility.h"
+
+
+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() {
+	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() );
+	} // for
+}
+
+ApplicationExpr::ApplicationExpr( const ApplicationExpr &other ) :
+		Expression( other ), function( maybeClone( other.function ) ), inferParams( other.inferParams ) {
+	cloneAll( other.args, 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
+	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: //
Index: src/SynTree/ArrayType.cc
===================================================================
--- src/SynTree/ArrayType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/ArrayType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,58 @@
+//
+// 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"
+#include "Expression.h"
+#include "utility.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 );
+}
+
+ArrayType::ArrayType( const ArrayType &other )
+	: Type( other ), base( maybeClone( other.base ) ), dimension( maybeClone( other.dimension ) ),
+	  isVarLen( other.isVarLen ), isStatic( other.isStatic ) {
+}
+
+ArrayType::~ArrayType() {
+	delete base;
+	delete dimension;
+}
+
+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: //
Index: src/SynTree/AttrType.cc
===================================================================
--- src/SynTree/AttrType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/AttrType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,55 @@
+//
+// 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.
+//
+// AttrType.cc.cc -- 
+//
+// Author           : Richard C. Bilson
+// Created On       : Mon May 18 07:44:20 2015
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue May 19 16:41:51 2015
+// Update Count     : 2
+//
+
+#include "Type.h"
+#include "Expression.h"
+#include "utility.h"
+
+
+AttrType::AttrType( const Type::Qualifiers &tq, const std::string &name, Expression *expr )
+	: 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 ) {
+}
+
+AttrType::AttrType( const AttrType &other )
+	: Type( other ), name( other.name ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
+}
+
+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
+	if ( type ) {
+		os << "type ";
+		type->print( os, indent );
+	} // if
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/BasicType.cc
===================================================================
--- src/SynTree/BasicType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/BasicType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,70 @@
+//
+// 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"
+	};
+
+	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:
+		return false;
+	  case NUMBER_OF_BASIC_TYPES:
+		assert( false );
+	} // switch
+	assert( false );
+	return false;
+}
+
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/CodeGenVisitor.cc
===================================================================
--- src/SynTree/CodeGenVisitor.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/CodeGenVisitor.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,59 @@
+//
+// 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>
+
+#include "Statement.h"
+#include "Expression.h"
+#include "CodeGenVisitor.h"
+using namespace std;
+
+void CodeGenVisitor::visit( Type *type ) { }
+void CodeGenVisitor::visit( BasicType *basicType ) { }
+
+void CodeGenVisitor::visit( Constant *constant ) { 
+	cout << constant->get_value() << endl;
+}
+
+void CodeGenVisitor::visit( Expression *expr ) { }
+
+void CodeGenVisitor::visit( ConstantExpr *cnst ) {
+	if ( cnst != 0 )
+		visit(cnst->get_constant());
+}
+
+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( 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;	
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/CodeGenVisitor.h
===================================================================
--- src/SynTree/CodeGenVisitor.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/CodeGenVisitor.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,45 @@
+//
+// 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 <typeinfo>
+
+#include "SynTree.h"
+#include "Visitor.h"
+
+class CodeGenVisitor : public Visitor {
+  public:
+	virtual void visit( Type * );
+	virtual void visit( BasicType * );
+
+	virtual void visit( Constant * );
+
+	virtual void visit( Expression * );
+	virtual void visit( ConstantExpr * );
+
+	virtual void visit( Statement * );
+	virtual void visit( ExprStmt * );
+	virtual void visit( SwitchStmt * );
+};
+
+#endif // CODEGENV_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/CommaExpr.cc
===================================================================
--- src/SynTree/CommaExpr.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/CommaExpr.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,46 @@
+//
+// 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 "Type.h"
+#include "utility.h"
+
+CommaExpr::CommaExpr( Expression *arg1, Expression *arg2, Expression *_aname )
+		: 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 ) ) {
+}
+
+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 );
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/CompoundStmt.cc
===================================================================
--- src/SynTree/CompoundStmt.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/CompoundStmt.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,44 @@
+//
+// 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"
+#include "utility.h"
+#include <algorithm>
+#include <functional>
+
+using std::string;
+using std::endl;
+
+CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
+}
+
+CompoundStmt::CompoundStmt( const CompoundStmt &other ) : Statement( other ) {
+	cloneAll( other.kids, kids );
+}
+
+CompoundStmt::~CompoundStmt() {
+	deleteAll( kids );
+}
+
+void CompoundStmt::print( std::ostream &os, int indent ) {
+	os << "\r" << string(indent, ' ') << "CompoundStmt" << endl ;
+	printAll( kids, os, indent+2 );
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Constant.cc
===================================================================
--- src/SynTree/Constant.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Constant.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,41 @@
+//
+// 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 "Constant.h"
+#include "Type.h"
+
+Constant::Constant( Type *_type, std::string _value ) : type(_type), value(_value) {}
+
+Constant::~Constant() {}
+
+Constant *Constant::clone() const { return 0; }
+
+void Constant::print( std::ostream &os ) const {
+	os << value;
+	if ( type ) {
+		os << " (type: ";
+		type->print( os );
+		os << ")";
+	} // if
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Constant.h
===================================================================
--- src/SynTree/Constant.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Constant.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,48 @@
+//
+// 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
+#define CONSTANT_H
+
+#include "SynTree.h"
+#include "Visitor.h"
+#include "Mutator.h"
+
+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; }
+
+	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
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/DeclStmt.cc
===================================================================
--- src/SynTree/DeclStmt.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/DeclStmt.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,41 @@
+//
+// 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 "Declaration.h"
+#include "utility.h"
+
+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() {
+	delete decl;
+}
+
+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: //
Index: src/SynTree/Declaration.cc
===================================================================
--- src/SynTree/Declaration.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Declaration.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,69 @@
+//
+// 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 <map>
+#include "Declaration.h"
+#include "Expression.h"
+#include "Initializer.h"
+#include "Type.h"
+#include "utility.h"
+
+const char* Declaration::storageClassName[] = { "", "auto", "static", "extern", "register" };  
+
+static UniqueId lastUniqueId = 0;
+typedef std::map< UniqueId, Declaration* > IdMapType;
+static IdMapType idMap;
+
+Declaration::Declaration( const std::string &name, StorageClass sc, LinkageSpec::Type linkage )
+	: 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 ) {
+}
+
+Declaration::~Declaration() {
+}
+
+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;
+	} // 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;
+	} // for
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Declaration.h
===================================================================
--- src/SynTree/Declaration.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Declaration.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,276 @@
+//
+// 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 "SynTree.h"
+#include "Visitor.h"
+#include "Mutator.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;
+};
+
+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;
+};
+
+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;
+};
+
+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; }
+//    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;
+};
+
+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;
+  protected:
+	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;
+};
+
+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;
+};
+
+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;
+  protected:
+	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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+#endif // DECLARATION_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/DeclarationWithType.cc
===================================================================
--- src/SynTree/DeclarationWithType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/DeclarationWithType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,35 @@
+//
+// 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 "Type.h"
+#include "utility.h"
+
+DeclarationWithType::DeclarationWithType( const std::string &name, StorageClass sc, LinkageSpec::Type linkage )
+		: Declaration( name, sc, linkage ) {
+}
+
+DeclarationWithType::DeclarationWithType( const DeclarationWithType &other )
+		: Declaration( other ), mangleName( other.mangleName ) {
+}
+
+DeclarationWithType::~DeclarationWithType() {
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Expression.cc
===================================================================
--- src/SynTree/Expression.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Expression.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,345 @@
+//
+// 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>
+#include <list>
+#include <algorithm>
+
+#include <iterator>
+
+#include "Type.h"
+#include "Expression.h"
+#include "Declaration.h"
+#include "Statement.h"
+#include "TypeSubstitution.h"
+#include "utility.h"
+
+
+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);
+	} // 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
+
+	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( 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 ) );
+}
+
+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;
+}
+
+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::AttrExpr( Expression *attr, Expression *expr_, Expression *_aname ) :
+		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;
+}
+
+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);
+	} // 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( Expression *arg_, Expression *_aname ) : Expression( _aname ), arg(arg_) {
+}
+
+CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+}
+
+CastExpr::~CastExpr() {
+	delete arg;
+}
+
+// CastExpr *CastExpr::clone() const { return 0; }
+
+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);
+	} // 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 ) ) {
+}
+
+UntypedMemberExpr::~UntypedMemberExpr() {
+	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::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 );
+	} // for
+}
+
+MemberExpr::MemberExpr( const MemberExpr &other ) :
+		Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
+}
+
+MemberExpr::~MemberExpr() {
+	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::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( Expression *_function, std::list<Expression *> &_args, Expression *_aname ) :
+		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::NameExpr( std::string _name, Expression *_aname ) : Expression( _aname ), name(_name) {}
+
+NameExpr::NameExpr( const NameExpr &other ) : Expression( other ), name( other.name ) {
+}
+
+NameExpr::~NameExpr() {}
+
+void NameExpr::print( std::ostream &os, int indent ) const {
+	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 ) {
+}
+
+LogicalExpr::~LogicalExpr() {
+	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::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 ) ) {
+}
+
+ConditionalExpr::~ConditionalExpr() {
+	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 );
+}
+
+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: //
Index: src/SynTree/Expression.h
===================================================================
--- src/SynTree/Expression.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Expression.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,471 @@
+//
+// 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
+#define EXPRESSION_H
+
+#include <map>
+#include "SynTree.h"
+#include "Visitor.h"
+#include "Mutator.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
+};
+
+// 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;
+};
+
+typedef std::map< UniqueId, ParamEntry > InferredParams;
+
+// 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;
+};
+
+// UntypedExpr represents the application of a function to a set of parameters, but where the
+// 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;
+};
+
+// 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;
+};
+
+// The following classes are used to represent expression types that cannot be converted into
+// function-call format.
+
+// 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;
+};
+
+// 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;
+};
+
+// 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;
+};
+
+// 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;
+};
+
+// 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;
+};
+
+// 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;
+};
+
+// 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;
+};
+
+// 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;
+};
+
+// 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;
+};
+
+// 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;
+};
+
+// 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;
+};
+
+// 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;
+};
+
+// 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 // EXPRESSION_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/FunctionDecl.cc
===================================================================
--- src/SynTree/FunctionDecl.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/FunctionDecl.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,112 @@
+//
+// 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 : Thu May 21 21:31:16 2015
+// Update Count     : 11
+//
+
+#include <cassert>
+
+#include "Declaration.h"
+#include "Statement.h"
+#include "Type.h"
+#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 );
+	} // if
+}
+
+FunctionDecl::FunctionDecl( const FunctionDecl &other )
+		: Parent( other ), type( maybeClone( other.type ) ), statements( maybeClone( other.statements ) ), isInline( other.isInline ) {
+}
+
+FunctionDecl::~FunctionDecl() {
+	delete type;
+	delete statements;
+}
+
+Type * FunctionDecl::get_type() const {
+	return type;
+}
+
+void FunctionDecl::set_type( Type *t ) {
+	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
+	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
+	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: //
Index: src/SynTree/FunctionType.cc
===================================================================
--- src/SynTree/FunctionType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/FunctionType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,63 @@
+//
+// 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 "Type.h"
+#include "Declaration.h"
+#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 );
+}
+
+FunctionType::~FunctionType() {
+	deleteAll( returnVals );
+	deleteAll( parameters );
+}
+
+void FunctionType::print( std::ostream &os, int indent ) const {
+	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;
+		} // 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: //
Index: src/SynTree/Initializer.cc
===================================================================
--- src/SynTree/Initializer.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Initializer.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,84 @@
+//
+// 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() {}
+
+Initializer::~Initializer() {}
+
+std::string Initializer::designator_name( Expression *des ) {
+	if ( NameExpr *n = dynamic_cast<NameExpr *>(des) )
+		return n->get_name();
+	else
+		throw 0;
+}
+
+void Initializer::print( std::ostream &os, int indent ) {}
+
+SingleInit::SingleInit( Expression *v, std::list< Expression *> &_designators ) : value ( v ), designators( _designators ) { 
+}
+
+SingleInit::SingleInit( const SingleInit &other ) : value ( other.value ) {
+	cloneAll(other.designators, designators );
+}
+
+SingleInit::~SingleInit() {}
+
+SingleInit *SingleInit::clone() const { return new SingleInit( *this); }
+
+void SingleInit::print( std::ostream &os, int indent ) {
+	os << std::endl << std::string(indent, ' ' ) << "Simple Initializer: ";
+	value->print( os, indent+2 );
+
+	if ( ! designators.empty() ) {
+		os << std::endl << std::string(indent + 2, ' ' ) << "designated by: "  ;
+		for ( std::list < Expression * >::iterator i = designators.begin(); i != designators.end(); i++ )
+			( *i )->print(os, indent + 4 );
+	} // if
+}
+
+ListInit::ListInit( std::list<Initializer*> &_initializers, std::list<Expression *> &_designators )
+	: initializers( _initializers ), designators( _designators ) {
+}
+
+ListInit::~ListInit() {}
+
+ListInit *ListInit::clone() const {
+	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 ); 
+		} // for
+	
+		os << std::string(indent + 2, ' ' ) << "]";
+	} // if
+
+	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: //
Index: src/SynTree/Initializer.h
===================================================================
--- src/SynTree/Initializer.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Initializer.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,108 @@
+//
+// 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 "SynTree.h"
+#include "Visitor.h"
+#include "Mutator.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();
+
+	static std::string designator_name( Expression *designator );
+
+	//	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
+	}
+
+	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;
+};
+
+// SingleInit represents an initializer for a common object (e.g., int x = 4)
+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; }
+
+	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 );
+  private:
+	//Constant *value;
+	Expression *value;	// has to be a compile-time constant
+	std::list< Expression * > designators;
+};
+
+// ListInit represents an initializer that is composed recursively of a list of initializers; this is used to initialize
+// an array or aggregate
+class ListInit : public Initializer {
+  public:
+	ListInit( std::list<Initializer*> &, 
+			  std::list<Expression *> &designators = *(new std::list<Expression *>()) );
+	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; }
+
+	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 );
+  private:
+	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: //
Index: src/SynTree/Makefile
===================================================================
--- src/SynTree/Makefile	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Makefile	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,22 @@
+CXX=g++
+CXXFLAGS=-g -Wall #-Wno-unused
+
+SRCS:=Type.cc Constant.cc Expression.cc Statement.cc CodeGenVisitor.cc
+OBJECTS:=$(SRCS:.cc=.o)
+DEPS:=$(SRCS:.cc=.d)
+
+# libSynTree.a:  $(OBJECTS)
+# 	ar -rs $@ $(OBJECTS)
+#	$(CXX) $(CXXFLAGS) $(OBJS) -o $@ $(EXTRALIBS)
+
+%.d: %.cc
+	g++ -M $(CXXFLAGS) $< | sed -e '1s/^\(.*\)\.o/\1.d \1.o/' > $@
+
+all: $(OBJECTS)
+
+ifneq ($(MAKECMDGOALS),clean)
+include $(DEPS)
+endif
+
+clean:
+	rm -f cfa $(OBJECTS) $(DEPS) core
Index: src/SynTree/Mutator.cc
===================================================================
--- src/SynTree/Mutator.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Mutator.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,408 @@
+//
+// 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"
+#include "Initializer.h"
+#include "Statement.h"
+#include "Type.h"
+#include "Declaration.h"
+#include "Expression.h"
+#include "Constant.h"
+#include "utility.h"
+
+Mutator::Mutator() {}
+
+Mutator::~Mutator() {}
+
+ObjectDecl *Mutator::mutate( ObjectDecl *objectDecl ) {
+	objectDecl->set_type( maybeMutate( objectDecl->get_type(), *this ) );
+	objectDecl->set_init( maybeMutate( objectDecl->get_init(), *this ) );
+	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;
+}
+
+Declaration *Mutator::handleAggregateDecl( AggregateDecl *aggregateDecl ) {
+	mutateAll( aggregateDecl->get_parameters(), *this );
+	mutateAll( aggregateDecl->get_members(), *this );
+	return aggregateDecl;
+}
+
+Declaration *Mutator::mutate( StructDecl *aggregateDecl ) {
+	handleAggregateDecl( aggregateDecl );
+	return aggregateDecl;
+}
+
+Declaration *Mutator::mutate( UnionDecl *aggregateDecl ) {
+	handleAggregateDecl( aggregateDecl );
+	return aggregateDecl;
+}
+
+Declaration *Mutator::mutate( EnumDecl *aggregateDecl ) {
+	handleAggregateDecl( aggregateDecl );
+	return aggregateDecl;
+}
+
+Declaration *Mutator::mutate( ContextDecl *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;
+}
+
+TypeDecl *Mutator::mutate( TypeDecl *typeDecl ) {
+	handleNamedTypeDecl( typeDecl );
+	return typeDecl;
+}
+
+Declaration *Mutator::mutate( TypedefDecl *typeDecl ) {
+	handleNamedTypeDecl( typeDecl );
+	return typeDecl;
+}
+
+CompoundStmt *Mutator::mutate( CompoundStmt *compoundStmt ) {
+	mutateAll( compoundStmt->get_kids(), *this );
+	return compoundStmt;
+}
+
+Statement *Mutator::mutate( ExprStmt *exprStmt ) {
+	exprStmt->set_expr( maybeMutate( exprStmt->get_expr(), *this ) );
+	return exprStmt;
+}
+
+Statement *Mutator::mutate( IfStmt *ifStmt ) {
+	ifStmt->set_condition( maybeMutate( ifStmt->get_condition(), *this ) );
+	ifStmt->set_thenPart( maybeMutate( ifStmt->get_thenPart(), *this ) );
+	ifStmt->set_elsePart( maybeMutate( ifStmt->get_elsePart(), *this ) );
+	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;
+}
+
+Statement *Mutator::mutate( ForStmt *forStmt ) {
+	forStmt->set_initialization( maybeMutate( forStmt->get_initialization(), *this ) );
+	forStmt->set_condition( maybeMutate( forStmt->get_condition(), *this ) );
+	forStmt->set_increment( maybeMutate( forStmt->get_increment(), *this ) );
+	forStmt->set_body( maybeMutate( forStmt->get_body(), *this ) );
+	return forStmt;
+}
+
+Statement *Mutator::mutate( SwitchStmt *switchStmt ) {
+	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;
+}
+
+Statement *Mutator::mutate( FallthruStmt *fallthruStmt ) {
+	return fallthruStmt;
+}
+
+Statement *Mutator::mutate( CaseStmt *caseStmt ) {
+	caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
+	mutateAll (caseStmt->get_statements(), *this );
+
+	return caseStmt;
+}
+
+Statement *Mutator::mutate( BranchStmt *branchStmt ) {
+	return branchStmt;
+}
+
+Statement *Mutator::mutate( ReturnStmt *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;
+}
+
+Statement *Mutator::mutate( CatchStmt *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;
+}
+
+NullStmt *Mutator::mutate( NullStmt *nullStmt ) {
+	return nullStmt;
+}
+
+Statement *Mutator::mutate( DeclStmt *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;
+}
+
+Expression *Mutator::mutate( UntypedExpr *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;
+}
+
+Expression *Mutator::mutate( AddressExpr *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;
+}
+
+Expression *Mutator::mutate( CastExpr *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;
+}
+
+Expression *Mutator::mutate( MemberExpr *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;
+}
+
+Expression *Mutator::mutate( ConstantExpr *constantExpr ) {
+	mutateAll( constantExpr->get_results(), *this );
+//  maybeMutate( constantExpr->get_constant(), *this )
+	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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+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;
+}
+
+Expression *Mutator::mutate( TupleExpr *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;
+}
+
+Expression *Mutator::mutate( TypeExpr *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;
+}
+
+Type *Mutator::mutate( VoidType *voidType ) {
+	mutateAll( voidType->get_forall(), *this );
+	return voidType;
+}
+
+Type *Mutator::mutate( BasicType *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;
+}
+
+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;
+}
+
+Type *Mutator::mutate( FunctionType *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;
+}
+
+Type *Mutator::mutate( StructInstType *aggregateUseType ) {
+	handleReferenceToType( aggregateUseType );
+	return aggregateUseType;
+}
+
+Type *Mutator::mutate( UnionInstType *aggregateUseType ) {
+	handleReferenceToType( aggregateUseType );
+	return aggregateUseType;
+}
+
+Type *Mutator::mutate( EnumInstType *aggregateUseType ) {
+	handleReferenceToType( aggregateUseType );
+	return aggregateUseType;
+}
+
+Type *Mutator::mutate( ContextInstType *aggregateUseType ) {
+	handleReferenceToType( aggregateUseType );
+	mutateAll( aggregateUseType->get_members(), *this );
+	return aggregateUseType;
+}
+
+Type *Mutator::mutate( TypeInstType *aggregateUseType ) {
+	handleReferenceToType( aggregateUseType );
+	return aggregateUseType;
+}
+
+Type *Mutator::mutate( TupleType *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;
+}
+
+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;
+}
+
+Initializer *Mutator::mutate( SingleInit *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;
+}
+
+Subrange *Mutator::mutate( Subrange *subrange ) {
+	return subrange;
+}
+
+Constant *Mutator::mutate( Constant *constant ) {
+	return constant;
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Mutator.h
===================================================================
--- src/SynTree/Mutator.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Mutator.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,137 @@
+//
+// 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 "SynTree.h"
+#include "SemanticError.h"
+
+#ifndef MUTATOR_H
+#define MUTATOR_H
+
+class Mutator {
+  protected:
+	Mutator();
+	virtual ~Mutator();
+  public:
+	virtual ObjectDecl* mutate( ObjectDecl *objectDecl );
+	virtual DeclarationWithType* mutate( FunctionDecl *functionDecl );
+	virtual Declaration* mutate( StructDecl *aggregateDecl );
+	virtual Declaration* mutate( UnionDecl *aggregateDecl );
+	virtual Declaration* mutate( EnumDecl *aggregateDecl );
+	virtual Declaration* mutate( ContextDecl *aggregateDecl );
+	virtual TypeDecl* mutate( TypeDecl *typeDecl );
+	virtual Declaration* mutate( TypedefDecl *typeDecl );
+
+	virtual CompoundStmt* mutate( CompoundStmt *compoundStmt );
+	virtual Statement* mutate( ExprStmt *exprStmt );
+	virtual Statement* mutate( IfStmt *ifStmt );
+	virtual Statement* mutate( WhileStmt *whileStmt );
+	virtual Statement* mutate( ForStmt *forStmt );
+	virtual Statement* mutate( SwitchStmt *switchStmt );
+	virtual Statement* mutate( ChooseStmt *chooseStmt );
+	virtual Statement* mutate( FallthruStmt *fallthruStmt );
+	virtual Statement* mutate( CaseStmt *caseStmt );
+	virtual Statement* mutate( BranchStmt *branchStmt );
+	virtual Statement* mutate( ReturnStmt *returnStmt );
+	virtual Statement* mutate( TryStmt *returnStmt );
+	virtual Statement* mutate( CatchStmt *catchStmt );
+	virtual Statement* mutate( FinallyStmt *catchStmt );
+	virtual NullStmt* mutate( NullStmt *nullStmt );
+	virtual Statement* mutate( DeclStmt *declStmt );
+
+	virtual Expression* mutate( ApplicationExpr *applicationExpr );
+	virtual Expression* mutate( UntypedExpr *untypedExpr );
+	virtual Expression* mutate( NameExpr *nameExpr );
+	virtual Expression* mutate( AddressExpr *castExpr );
+	virtual Expression* mutate( LabelAddressExpr *labAddressExpr );
+	virtual Expression* mutate( CastExpr *castExpr );
+	virtual Expression* mutate( UntypedMemberExpr *memberExpr );
+	virtual Expression* mutate( MemberExpr *memberExpr );
+	virtual Expression* mutate( VariableExpr *variableExpr );
+	virtual Expression* mutate( ConstantExpr *constantExpr ); 
+	virtual Expression* mutate( SizeofExpr *sizeofExpr );
+	virtual Expression* mutate( AttrExpr *attrExpr );
+	virtual Expression* mutate( LogicalExpr *logicalExpr );
+	virtual Expression* mutate( ConditionalExpr *conditionalExpr );
+	virtual Expression* mutate( CommaExpr *commaExpr );
+	virtual Expression* mutate( TupleExpr *tupleExpr );
+	virtual Expression* mutate( SolvedTupleExpr *tupleExpr );
+	virtual Expression* mutate( TypeExpr *typeExpr );
+	virtual Expression* mutate( UntypedValofExpr *valofExpr );
+
+	virtual Type* mutate( VoidType *basicType );
+	virtual Type* mutate( BasicType *basicType );
+	virtual Type* mutate( PointerType *pointerType );
+	virtual Type* mutate( ArrayType *arrayType );
+	virtual Type* mutate( FunctionType *functionType );
+	virtual Type* mutate( StructInstType *aggregateUseType );
+	virtual Type* mutate( UnionInstType *aggregateUseType );
+	virtual Type* mutate( EnumInstType *aggregateUseType );
+	virtual Type* mutate( ContextInstType *aggregateUseType );
+	virtual Type* mutate( TypeInstType *aggregateUseType );
+	virtual Type* mutate( TupleType *tupleType );
+	virtual Type* mutate( TypeofType *typeofType );
+	virtual Type* mutate( AttrType *attrType );
+
+	virtual Initializer* mutate( SingleInit *singleInit );
+	virtual Initializer* mutate( ListInit *listInit );
+
+	virtual Subrange *mutate( Subrange *subrange );
+
+	virtual Constant *mutate( Constant *constant );
+  private:
+	virtual Declaration* handleAggregateDecl(AggregateDecl *aggregateDecl );
+	virtual Declaration* handleNamedTypeDecl(NamedTypeDecl *typeDecl );
+	virtual Type* handleReferenceToType(ReferenceToType *aggregateUseType );
+};
+
+template< typename TreeType, typename MutatorType >
+inline TreeType *maybeMutate( TreeType *tree, MutatorType &mutator ) {
+	if ( tree ) {
+		TreeType *newnode = dynamic_cast< TreeType* >( tree->acceptMutator( mutator ) );
+		assert( newnode );
+		return newnode;
+///	    return tree->acceptMutator( mutator );
+	} else {
+		return 0;
+	} // 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 ) {
+///		    *i = (*i)->acceptMutator( mutator );
+				*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 // MUTATOR_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/NamedTypeDecl.cc
===================================================================
--- src/SynTree/NamedTypeDecl.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/NamedTypeDecl.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,85 @@
+//
+// 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 ) {}
+
+NamedTypeDecl::NamedTypeDecl( const TypeDecl &other )
+	: Parent( other ), base( maybeClone( other.base ) ) {
+	cloneAll( other.parameters, parameters );
+	cloneAll( other.assertions, assertions );
+}
+
+NamedTypeDecl::~NamedTypeDecl() {
+	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
+}
+
+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
+}
+
+std::string TypedefDecl::typeString() const { return "typedef"; }
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/ObjectDecl.cc
===================================================================
--- src/SynTree/ObjectDecl.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/ObjectDecl.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,91 @@
+//
+// 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 "Initializer.h"
+#include "Expression.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 ) {
+}
+
+ObjectDecl::ObjectDecl( const ObjectDecl &other )
+	: Parent( other ), type( maybeClone( other.type ) ), init( maybeClone( other.init ) ), bitfieldWidth( maybeClone( other.bitfieldWidth ) ) {
+}
+
+ObjectDecl::~ObjectDecl() {
+	delete type;
+	delete init;
+	delete bitfieldWidth;
+}
+
+void ObjectDecl::print( std::ostream &os, int indent ) const {
+	if ( get_name() != "" ) {
+		os << get_name() << ": a ";
+	} // if
+
+	if ( get_linkage() != LinkageSpec::Cforall ) {
+		os << LinkageSpec::toString( get_linkage() ) << " ";
+	} // if
+
+	if ( get_storageClass() != NoStorageClass ) {
+		os << storageClassName[ get_storageClass() ] << ' ';
+	} // if
+
+	if ( get_type() ) {
+		get_type()->print( os, indent );
+	} else {
+		os << "untyped entity ";
+	} // if
+
+	if ( init ) {
+		os << "with initializer ";
+		init->print( os, indent );
+	} // if
+
+	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
+
+	if ( get_storageClass() != NoStorageClass ) {
+		os << storageClassName[ get_storageClass() ] << ' ';
+	} // if
+
+	if ( get_type() ) {
+		get_type()->print( os, indent );
+	} else {
+		os << "untyped entity ";
+	} // if
+
+	if ( bitfieldWidth ) {
+		os << "with bitfield width ";
+		bitfieldWidth->print( os );
+	} // if
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/PointerType.cc
===================================================================
--- src/SynTree/PointerType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/PointerType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,61 @@
+//
+// 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 "Expression.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 );
+}
+
+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 );
+}
+
+PointerType::PointerType( const PointerType &other )
+	: Type( other ), base( maybeClone( other.base ) ), dimension( maybeClone( other.dimension ) ),
+	  isVarLen( other.isVarLen ), isStatic( other.isStatic ) {
+}
+
+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
+	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: //
Index: src/SynTree/ReferenceToType.cc
===================================================================
--- src/SynTree/ReferenceToType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/ReferenceToType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,114 @@
+//
+// 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 : Tue May 19 16:52:40 2015
+// Update Count     : 3
+//
+
+#include <string>
+#include <cassert>
+
+#include "Type.h"
+#include "Declaration.h"
+#include "Expression.h"
+#include "TypeSubstitution.h"
+#include "utility.h"
+
+ReferenceToType::ReferenceToType( const Type::Qualifiers &tq, const std::string &name ) : Type( tq ), name( name ) {
+}
+
+ReferenceToType::ReferenceToType( const ReferenceToType &other ) : Type( other ), name( other.name ) {
+	cloneAll( other.parameters, parameters );
+}
+
+ReferenceToType::~ReferenceToType() {
+	deleteAll( parameters );
+}
+
+void ReferenceToType::print( std::ostream &os, int indent ) const {
+	using std::endl;
+	
+	Type::print( os, indent );
+	os << "instance of " << typeString() << " " << name << " ";
+	if ( ! parameters.empty() ) {
+		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 );
+			} // if
+		} // for
+		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 {
+	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 {
+	assert( baseUnion );
+	doLookup( baseUnion->get_members(), baseUnion->get_parameters(), parameters, name, foundDecls );
+}
+
+std::string EnumInstType::typeString() const { return "enum"; }
+
+std::string ContextInstType::typeString() const { return "context"; }
+
+ContextInstType::ContextInstType( const ContextInstType &other ) : Parent( other ) {
+	cloneAll( other.members, members );
+}
+
+ContextInstType::~ContextInstType() {
+	deleteAll( members );
+}
+
+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 ) {
+}
+
+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 {
+	using std::endl;
+	
+	Type::print( os, indent );
+	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 );
+	} // if
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Statement.cc
===================================================================
--- src/SynTree/Statement.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Statement.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,304 @@
+//
+// 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>
+#include <iostream>
+#include <list>
+#include <cassert>
+
+#include "Statement.h"
+#include "Expression.h"
+#include "Declaration.h"
+#include "Common/SemanticError.h"
+
+using std::string;
+using std::endl;
+
+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() {}
+
+void ExprStmt::print( std::ostream &os, int indent ) {
+	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");
+}
+
+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 ) {}
+
+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;
+}
+
+IfStmt::IfStmt( std::list<Label> _labels, Expression *_condition, Statement *_thenPart, Statement *_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 );
+	} // 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");
+}
+
+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 );
+	} // 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() {
+	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;
+}
+
+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_ ) {
+}
+
+ForStmt::~ForStmt() {
+	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;
+}
+
+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;
+}
+
+TryStmt::~TryStmt() {
+	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 );
+	} // if
+}
+
+CatchStmt::CatchStmt( std::list<Label> labels, Declaration *_decl, Statement *_body, bool isCatchRest ) :
+	Statement( labels ), decl ( _decl ), body( _body ), catchRest ( isCatchRest ) {
+}
+
+CatchStmt::~CatchStmt() {
+	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;
+}
+
+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 );
+}
+
+NullStmt::NullStmt( std::list<Label> labels ) : CompoundStmt( labels ) {}
+NullStmt::NullStmt() : CompoundStmt( std::list<Label>() ) {}
+NullStmt::~NullStmt() {}
+
+void NullStmt::print( std::ostream &os, int indent ) {
+	os << "\r" << string( indent, ' ') << "Null Statement" << endl ;
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Statement.h
===================================================================
--- src/SynTree/Statement.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Statement.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,368 @@
+//
+// 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 "SynTree.h"
+#include "Visitor.h"
+#include "Mutator.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 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;
+}; 
+
+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 // STATEMENT_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/SynTree.h
===================================================================
--- src/SynTree/SynTree.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/SynTree.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,115 @@
+//
+// 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
+#define SYNTREE_H
+
+#include <string>
+#include <list>
+#include <map>
+#include <iostream>
+
+class Declaration;
+class DeclarationWithType;
+class ObjectDecl;
+class FunctionDecl;
+class AggregateDecl;
+class StructDecl;
+class UnionDecl;
+class EnumDecl;
+class ContextDecl;
+class NamedTypeDecl;
+class TypeDecl;
+class FtypeDecl;
+class DtypeDecl;
+class TypedefDecl;
+
+class Statement;
+class CompoundStmt;
+class ExprStmt;
+class IfStmt;
+class WhileStmt;
+class ForStmt;
+class SwitchStmt;
+class ChooseStmt;
+class FallthruStmt;
+class CaseStmt;
+class BranchStmt;
+class ReturnStmt;
+class TryStmt;
+class CatchStmt;
+class FinallyStmt;
+class NullStmt;
+class DeclStmt;
+class NullStmt;
+
+class Expression;
+class ApplicationExpr;
+class UntypedExpr;
+class NameExpr;
+class AddressExpr;
+class LabelAddressExpr;
+class CastExpr;
+class MemberExpr;
+class UntypedMemberExpr;
+class VariableExpr;
+class ConstantExpr;
+class SizeofExpr;
+class AttrExpr;
+class LogicalExpr;
+class ConditionalExpr;
+class CommaExpr;
+class TupleExpr;
+class SolvedTupleExpr;
+class TypeExpr;
+class UntypedValofExpr;
+
+class Type;
+class VoidType;
+class BasicType;
+class PointerType;
+class ArrayType;
+class FunctionType;
+class ReferenceToType;
+class StructInstType;
+class UnionInstType;
+class EnumInstType;
+class ContextInstType;
+class TypeInstType;
+class TupleType;
+class TypeofType;
+class AttrType;
+
+class Initializer;
+class SingleInit;
+class ListInit;
+
+class Subrange;
+
+//template <class T>	// emulate a union with templates?
+class Constant;
+
+typedef std::string Label;
+typedef unsigned int UniqueId;
+
+class TypeSubstitution;
+
+#endif // SYNTREE_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/TupleExpr.cc
===================================================================
--- src/SynTree/TupleExpr.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/TupleExpr.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,54 @@
+//
+// 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( const TupleExpr &other ) : Expression( other ) {
+	cloneAll( other.exprs, 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 );
+}
+
+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 );
+}
+
+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: //
Index: src/SynTree/TupleType.cc
===================================================================
--- src/SynTree/TupleType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/TupleType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,40 @@
+//
+// 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 TupleType& other ) : Type( other ) {
+	cloneAll( other.types, 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 );
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Type.cc
===================================================================
--- src/SynTree/Type.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Type.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,83 @@
+//
+// 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 : Tue May 19 16:52:27 2015
+// Update Count     : 2
+//
+
+#include "SynTree.h"
+#include "Visitor.h"
+#include "Type.h"
+#include "Declaration.h"
+#include "utility.h"
+
+const char *BasicType::typeNames[BasicType::NUMBER_OF_BASIC_TYPES] = {
+	"_Bool",
+	"char",
+	"char",
+	"unsigned char",
+	"short",
+	"short unsigned",
+	"int",
+	"unsigned int",
+	"long int",
+	"long unsigned int",
+	"long long int",
+	"long long unsigned int",
+	"float",
+	"double",
+	"long double",
+	"float _Complex",
+	"double _Complex",
+	"long double _Complex",
+	"float _Imaginary",
+	"double _Imaginary",
+	"long double _Imaginary",
+};
+
+Type::Type( const Qualifiers &tq ) : tq( tq ) {}
+
+Type::Type( const Type &other ) : tq( other.tq ) {
+	cloneAll( other.forall, forall );
+}
+
+Type::~Type() {
+	deleteAll( forall );
+}
+
+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, ' ' );
+	} // if
+	if ( tq.isConst ) {
+		os << "const ";
+	} // if
+	if ( tq.isVolatile ) {
+		os << "volatile ";
+	} // if
+	if ( tq.isRestrict ) {
+		os << "restrict ";
+	} // if
+	if ( tq.isLvalue ) {
+		os << "lvalue ";
+	} // if
+	if ( tq.isAtomic ) {
+		os << "_Atomic ";
+	} // if
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Type.h
===================================================================
--- src/SynTree/Type.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Type.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,463 @@
+//
+// 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 "SynTree.h"
+#include "Visitor.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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+  protected:
+	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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+};
+
+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;
+}
+
+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;
+}
+
+inline Type::Qualifiers Type::Qualifiers::operator+( const Type::Qualifiers &other ) {
+	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
+//	&& isLvalue == other.isLvalue
+		&& isAtomic == other.isAtomic;
+}
+
+inline bool Type::Qualifiers::operator!=( const Qualifiers &other ) {
+	return isConst != other.isConst
+		|| isVolatile != other.isVolatile
+		|| isRestrict != other.isRestrict
+//	|| isLvalue != other.isLvalue
+		|| isAtomic != other.isAtomic;
+}
+
+inline bool Type::Qualifiers::operator<=( const Type::Qualifiers &other ) {
+	return isConst <= other.isConst
+		&& isVolatile <= other.isVolatile
+		&& isRestrict <= other.isRestrict
+//	&& isLvalue >= other.isLvalue
+		&& isAtomic == other.isAtomic;
+}
+
+inline bool Type::Qualifiers::operator>=( const Type::Qualifiers &other ) {
+	return isConst >= other.isConst
+		&& isVolatile >= other.isVolatile
+		&& isRestrict >= other.isRestrict
+//	&& isLvalue <= other.isLvalue
+		&& isAtomic == other.isAtomic;
+}
+
+inline bool Type::Qualifiers::operator<( const Type::Qualifiers &other ) {
+	return operator!=( other ) && operator<=( other );
+}
+
+inline bool Type::Qualifiers::operator>( const Type::Qualifiers &other ) {
+	return operator!=( other ) && operator>=( other );
+}
+
+#endif // TYPE_H
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/TypeDecl.cc
===================================================================
--- src/SynTree/TypeDecl.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/TypeDecl.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,35 @@
+//
+// 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 TypeDecl &other ) : Parent( other ), kind( other.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: //
Index: src/SynTree/TypeExpr.cc
===================================================================
--- src/SynTree/TypeExpr.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/TypeExpr.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,39 @@
+//
+// 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 "Type.h"
+#include "utility.h"
+
+TypeExpr::TypeExpr( Type *type ) : type( type ) {
+}
+
+TypeExpr::TypeExpr( const TypeExpr &other ) : type( maybeClone( other.type ) ) {
+}
+
+TypeExpr::~TypeExpr() {
+	delete type;
+}
+
+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: //
Index: src/SynTree/TypeSubstitution.cc
===================================================================
--- src/SynTree/TypeSubstitution.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/TypeSubstitution.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,197 @@
+//
+// 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( 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::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::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;
+	} // 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 );
+	} // 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;
+	} // if
+}
+
+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 );
+}
+
+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;
+	} // 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();
+	} // 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() );
+		} // for
+	} // if
+	Type *ret = Mutator::mutate( type );
+	boundVars = oldBoundVars;
+	return ret;
+}
+
+Type * TypeSubstitution::mutate( VoidType *basicType ) {
+	return handleType( basicType );
+}
+
+Type * TypeSubstitution::mutate( BasicType *basicType ) {
+	return handleType( basicType );
+}
+
+Type * TypeSubstitution::mutate( PointerType *pointerType ) {
+	return handleType( pointerType );
+}
+
+Type * TypeSubstitution::mutate( ArrayType *arrayType ) {
+	return handleType( arrayType );
+}
+
+Type * TypeSubstitution::mutate( FunctionType *functionType ) {
+	return handleType( functionType );
+}
+
+Type * TypeSubstitution::mutate( StructInstType *aggregateUseType ) {
+	return handleType( aggregateUseType );
+}
+
+Type * TypeSubstitution::mutate( UnionInstType *aggregateUseType ) {
+	return handleType( aggregateUseType );
+}
+
+Type * TypeSubstitution::mutate( EnumInstType *aggregateUseType ) {
+	return handleType( aggregateUseType );
+}
+
+Type * TypeSubstitution::mutate( ContextInstType *aggregateUseType ) {
+	return handleType( aggregateUseType );
+}
+
+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;
+	} // 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: //
Index: src/SynTree/TypeSubstitution.h
===================================================================
--- src/SynTree/TypeSubstitution.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/TypeSubstitution.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,179 @@
+//
+// 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 TYPESUBSTITUTION_H
+#define TYPESUBSTITUTION_H
+
+#include <map>
+#include <set>
+#include <cassert>
+
+#include "SynTree/Mutator.h"
+#include "SynTree/Declaration.h"
+#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();
+
+	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;
+};
+
+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;
+					} // 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
+}
+
+template< typename FormalIterator, typename ActualIterator >
+TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator 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 );
+///	std::cout << "substitution result is: ";
+///	newType->print( std::cout );
+///	std::cout << std::endl;
+	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 );
+///	std::cout << "substitution result is: ";
+///	newType->print( std::cout );
+///	std::cout << std::endl;
+	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 );
+		} // 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
+
+	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
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/TypeofType.cc
===================================================================
--- src/SynTree/TypeofType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/TypeofType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,42 @@
+//
+// 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 "Expression.h"
+#include "utility.h"
+
+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() {
+	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 );
+	}
+}
+
+// Local Variables: //
+// tab-width: 4 //
+// mode: c++ //
+// compile-command: "make install" //
+// End: //
Index: src/SynTree/Visitor.cc
===================================================================
--- src/SynTree/Visitor.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Visitor.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,341 @@
+//
+// 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 "Initializer.h"
+#include "Statement.h"
+#include "Type.h"
+#include "Declaration.h"
+#include "Expression.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 );
+	} // 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: //
Index: src/SynTree/Visitor.h
===================================================================
--- src/SynTree/Visitor.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/Visitor.h	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,156 @@
+//
+// 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 "SynTree.h"
+#include "SemanticError.h"
+#include "CompilerError.h"
+
+class Visitor {
+  protected:
+	Visitor();
+	virtual ~Visitor();
+  public:
+	virtual void visit( ObjectDecl *objectDecl );
+	virtual void visit( FunctionDecl *functionDecl );
+	virtual void visit( StructDecl *aggregateDecl );
+	virtual void visit( UnionDecl *aggregateDecl );
+	virtual void visit( EnumDecl *aggregateDecl );
+	virtual void visit( ContextDecl *aggregateDecl );
+	virtual void visit( TypeDecl *typeDecl );
+	virtual void visit( TypedefDecl *typeDecl );
+
+	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( 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( Subrange *subrange );
+
+	virtual void visit( Constant *constant );
+  private:
+	virtual void visit( AggregateDecl *aggregateDecl );
+	virtual void visit( NamedTypeDecl *typeDecl );
+	virtual void visit( ReferenceToType *aggregateUseType );
+};
+
+template< typename TreeType, typename VisitorType >
+inline void maybeAccept( TreeType *tree, VisitorType &visitor ) {
+	if ( tree ) {
+		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 );
+		}
+	}
+	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 );
+
+				typename Container::iterator nxt = i; nxt++; // forward_iterator
+				if ( nxt == container.end() )
+					visitor += *v;
+				else
+					visitor += *v + around;
+
+				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: //
Index: src/SynTree/VoidType.cc
===================================================================
--- src/SynTree/VoidType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/VoidType.cc	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,30 @@
+//
+// 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 ) {
+}
+
+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: //
Index: src/SynTree/module.mk
===================================================================
--- src/SynTree/module.mk	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
+++ src/SynTree/module.mk	(revision 843054c23fcb725d2486e5e42e91b3741bc523b8)
@@ -0,0 +1,34 @@
+SRC += SynTree/Type.cc \
+       SynTree/VoidType.cc \
+       SynTree/BasicType.cc \
+       SynTree/PointerType.cc \
+       SynTree/ArrayType.cc \
+       SynTree/FunctionType.cc \
+       SynTree/ReferenceToType.cc \
+       SynTree/TupleType.cc \
+       SynTree/TypeofType.cc \
+       SynTree/AttrType.cc \
+       SynTree/Constant.cc \
+       SynTree/Expression.cc \
+       SynTree/TupleExpr.cc \
+       SynTree/CommaExpr.cc \
+       SynTree/TypeExpr.cc \
+       SynTree/ApplicationExpr.cc \
+       SynTree/AddressExpr.cc \
+       SynTree/Statement.cc \
+       SynTree/CompoundStmt.cc \
+       SynTree/DeclStmt.cc \
+       SynTree/Declaration.cc \
+       SynTree/DeclarationWithType.cc \
+       SynTree/ObjectDecl.cc \
+       SynTree/FunctionDecl.cc \
+       SynTree/AggregateDecl.cc \
+       SynTree/NamedTypeDecl.cc \
+       SynTree/TypeDecl.cc \
+       SynTree/Initializer.cc \
+       SynTree/Visitor.cc \
+       SynTree/Mutator.cc \
+       SynTree/CodeGenVisitor.cc \
+       SynTree/TypeSubstitution.cc \
+	$(NULL)
+