Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/DeclarationNode.cc	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 15 14:30:25 2016
-// Update Count     : 172
+// Last Modified On : Mon Aug 15 20:48:55 2016
+// Update Count     : 178
 //
 
@@ -49,9 +49,8 @@
 	newnode->name = name;
 	newnode->storageClasses = storageClasses;
-//PAB	newnode->bitfieldWidth = maybeClone( bitfieldWidth );
 	newnode->bitfieldWidth = bitfieldWidth;
 	newnode->hasEllipsis = hasEllipsis;
 	newnode->initializer = initializer;
-	newnode->next = maybeClone( next );
+	newnode->set_next( maybeClone( get_next() ) );
 	newnode->linkage = linkage;
 	return newnode;
@@ -284,5 +283,5 @@
 	newnode->type->array->dimension = size;
 	newnode->type->array->isStatic = isStatic;
-	if ( newnode->type->array->dimension == 0 || dynamic_cast<ConstantExpr *>( newnode->type->array->dimension->build() ) ) {
+	if ( newnode->type->array->dimension == 0 || dynamic_cast< ConstantExpr * >( newnode->type->array->dimension->build() ) ) {
 		newnode->type->array->isVarLen = false;
 	} else {
@@ -776,5 +775,5 @@
 void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ) {
 	SemanticError errors;
-	std::back_insert_iterator< std::list< Declaration *> > out( outputList );
+	std::back_insert_iterator< std::list< Declaration * > > out( outputList );
 	const DeclarationNode *cur = firstNode;
 	while ( cur ) {
@@ -794,5 +793,5 @@
 			errors.append( e );
 		} // try
-		cur = dynamic_cast<DeclarationNode *>( cur->get_next() );
+		cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
 	} // while
 	if ( ! errors.isEmpty() ) {
@@ -801,7 +800,7 @@
 }
 
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList ) {
+void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList ) {
 	SemanticError errors;
-	std::back_insert_iterator< std::list< DeclarationWithType *> > out( outputList );
+	std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
 	const DeclarationNode *cur = firstNode;
 	while ( cur ) {
@@ -817,11 +816,11 @@
 			Declaration *decl = cur->build();
 			if ( decl ) {
-				if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType *>( decl ) ) {
+				if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
 					*out++ = dwt;
-				} else if ( StructDecl *agg = dynamic_cast< StructDecl *>( decl ) ) {
+				} else if ( StructDecl *agg = dynamic_cast< StructDecl * >( decl ) ) {
 					StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
 					*out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
 					delete agg;
-				} else if ( UnionDecl *agg = dynamic_cast< UnionDecl *>( decl ) ) {
+				} else if ( UnionDecl *agg = dynamic_cast< UnionDecl * >( decl ) ) {
 					UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
 					*out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
@@ -831,5 +830,5 @@
 			errors.append( e );
 		} // try
-		cur = dynamic_cast< DeclarationNode *>( cur->get_next() );
+		cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
 	} // while
 	if ( ! errors.isEmpty() ) {
@@ -838,7 +837,7 @@
 }
 
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type *> &outputList ) {
+void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ) {
 	SemanticError errors;
-	std::back_insert_iterator< std::list< Type *> > out( outputList );
+	std::back_insert_iterator< std::list< Type * > > out( outputList );
 	const DeclarationNode *cur = firstNode;
 	while ( cur ) {
@@ -848,5 +847,5 @@
 			errors.append( e );
 		} // try
-		cur = dynamic_cast< DeclarationNode *>( cur->get_next() );
+		cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
 	} // while
 	if ( ! errors.isEmpty() ) {
Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/ExpressionNode.cc	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 15 14:30:42 2016
-// Update Count     : 490
+// Last Modified On : Tue Aug 16 00:09:20 2016
+// Update Count     : 495
 //
 
@@ -32,5 +32,5 @@
 using namespace std;
 
-ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.name ), extension( other.extension ) {}
+ExpressionNode::ExpressionNode( const ExpressionNode &other ) : ParseNode( other.get_name() ), extension( other.extension ) {}
 
 //##############################################################################
@@ -166,11 +166,7 @@
 } // build_constantStr
 
-//##############################################################################
-
 NameExpr * build_varref( const string *name, bool labelp ) {
 	return new NameExpr( *name, nullptr );
 }
-
-//##############################################################################
 
 static const char *OperName[] = {
@@ -184,18 +180,16 @@
 };
 
-//##############################################################################
-
 Expression *build_cast( DeclarationNode *decl_node, ExpressionNode *expr_node ) {
 	Type *targetType = decl_node->buildType();
 	if ( dynamic_cast< VoidType * >( targetType ) ) {
 		delete targetType;
-		return new CastExpr( maybeBuild<Expression>(expr_node) );
+		return new CastExpr( maybeBuild< Expression >(expr_node) );
 	} else {
-		return new CastExpr( maybeBuild<Expression>(expr_node), targetType );
+		return new CastExpr( maybeBuild< Expression >(expr_node), targetType );
 	} // if
 }
 
 Expression *build_fieldSel( ExpressionNode *expr_node, NameExpr *member ) {
-	UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeBuild<Expression>(expr_node) );
+	UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), maybeBuild< Expression >(expr_node) );
 	delete member;
 	return ret;
@@ -204,5 +198,5 @@
 Expression *build_pfieldSel( ExpressionNode *expr_node, NameExpr *member ) {
 	UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-	deref->get_args().push_back( maybeBuild<Expression>(expr_node) );
+	deref->get_args().push_back( maybeBuild< Expression >(expr_node) );
 	UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
 	delete member;
@@ -211,8 +205,8 @@
 
 Expression *build_addressOf( ExpressionNode *expr_node ) {
-		return new AddressExpr( maybeBuild<Expression>(expr_node) );
+		return new AddressExpr( maybeBuild< Expression >(expr_node) );
 }
 Expression *build_sizeOfexpr( ExpressionNode *expr_node ) {
-	return new SizeofExpr( maybeBuild<Expression>(expr_node) );
+	return new SizeofExpr( maybeBuild< Expression >(expr_node) );
 }
 Expression *build_sizeOftype( DeclarationNode *decl_node ) {
@@ -220,5 +214,5 @@
 }
 Expression *build_alignOfexpr( ExpressionNode *expr_node ) {
-	return new AlignofExpr( maybeBuild<Expression>(expr_node) );
+	return new AlignofExpr( maybeBuild< Expression >(expr_node) );
 }
 Expression *build_alignOftype( DeclarationNode *decl_node ) {
@@ -230,40 +224,40 @@
 
 Expression *build_and_or( ExpressionNode *expr_node1, ExpressionNode *expr_node2, bool kind ) {
-	return new LogicalExpr( notZeroExpr( maybeBuild<Expression>(expr_node1) ), notZeroExpr( maybeBuild<Expression>(expr_node2) ), kind );
+	return new LogicalExpr( notZeroExpr( maybeBuild< Expression >(expr_node1) ), notZeroExpr( maybeBuild< Expression >(expr_node2) ), kind );
 }
 
 Expression *build_unary_val( OperKinds op, ExpressionNode *expr_node ) {
-	std::list<Expression *> args;
-	args.push_back( maybeBuild<Expression>(expr_node) );
+	std::list< Expression * > args;
+	args.push_back( maybeBuild< Expression >(expr_node) );
 	return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 Expression *build_unary_ptr( OperKinds op, ExpressionNode *expr_node ) {
-	std::list<Expression *> args;
-	args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node) ) );
+	std::list< Expression * > args;
+	args.push_back( new AddressExpr( maybeBuild< Expression >(expr_node) ) );
 	return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 Expression *build_binary_val( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
-	std::list<Expression *> args;
-	args.push_back( maybeBuild<Expression>(expr_node1) );
-	args.push_back( maybeBuild<Expression>(expr_node2) );
+	std::list< Expression * > args;
+	args.push_back( maybeBuild< Expression >(expr_node1) );
+	args.push_back( maybeBuild< Expression >(expr_node2) );
 	return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 Expression *build_binary_ptr( OperKinds op, ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
-	std::list<Expression *> args;
-	args.push_back( new AddressExpr( maybeBuild<Expression>(expr_node1) ) );
-	args.push_back( maybeBuild<Expression>(expr_node2) );
+	std::list< Expression * > args;
+	args.push_back( new AddressExpr( maybeBuild< Expression >(expr_node1) ) );
+	args.push_back( maybeBuild< Expression >(expr_node2) );
 	return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 }
 
 Expression *build_cond( ExpressionNode *expr_node1, ExpressionNode *expr_node2, ExpressionNode *expr_node3 ) {
-	return new ConditionalExpr( notZeroExpr( maybeBuild<Expression>(expr_node1) ), maybeBuild<Expression>(expr_node2), maybeBuild<Expression>(expr_node3) );
+	return new ConditionalExpr( notZeroExpr( maybeBuild< Expression >(expr_node1) ), maybeBuild< Expression >(expr_node2), maybeBuild< Expression >(expr_node3) );
 }
 
 Expression *build_comma( ExpressionNode *expr_node1, ExpressionNode *expr_node2 ) {
-	return new CommaExpr( maybeBuild<Expression>(expr_node1), maybeBuild<Expression>(expr_node2) );
+	return new CommaExpr( maybeBuild< Expression >(expr_node1), maybeBuild< Expression >(expr_node2) );
 }
 
 Expression *build_attrexpr( NameExpr *var, ExpressionNode * expr_node ) {
-	return new AttrExpr( var, maybeBuild<Expression>(expr_node) );
+	return new AttrExpr( var, maybeBuild< Expression >(expr_node) );
 }
 Expression *build_attrtype( NameExpr *var, DeclarationNode * decl_node ) {
@@ -278,53 +272,38 @@
 
 Expression *build_func( ExpressionNode * function, ExpressionNode * expr_node ) {
-	std::list<Expression *> args;
+	std::list< Expression * > args;
 
 	buildList( expr_node, args );
-	return new UntypedExpr( maybeBuild<Expression>(function), args, nullptr );
+	return new UntypedExpr( maybeBuild< Expression >(function), args, nullptr );
 }
 
 Expression *build_range( ExpressionNode * low, ExpressionNode *high ) {
-	Expression *low_cexpr = maybeBuild<Expression>( low );
-	Expression *high_cexpr = maybeBuild<Expression>( high );
+	Expression *low_cexpr = maybeBuild< Expression >( low );
+	Expression *high_cexpr = maybeBuild< Expression >( high );
 	return new RangeExpr( low_cexpr, high_cexpr );
 }
 
-//##############################################################################
-
 Expression *build_asmexpr( ExpressionNode *inout, ConstantExpr *constraint, ExpressionNode *operand ) {
-	return new AsmExpr( maybeBuild< Expression >( inout ), constraint, maybeBuild<Expression>(operand) );
-}
-
-//##############################################################################
-
-//void LabelNode::print( std::ostream &os, int indent ) const {}
-
-//void LabelNode::printOneLine( std::ostream &os, int indent ) const {}
-
-//##############################################################################
+	return new AsmExpr( maybeBuild< Expression >( inout ), constraint, maybeBuild< Expression >(operand) );
+}
 
 Expression *build_valexpr( StatementNode *s ) {
-	return new UntypedValofExpr( maybeBuild<Statement>(s), nullptr );
-}
-
-//##############################################################################
-
+	return new UntypedValofExpr( maybeBuild< Statement >(s), nullptr );
+}
 Expression *build_typevalue( DeclarationNode *decl ) {
 	return new TypeExpr( decl->buildType() );
 }
 
-//##############################################################################
-
 Expression *build_compoundLiteral( DeclarationNode *decl_node, InitializerNode *kids ) {
-	Declaration * newDecl = maybeBuild<Declaration>(decl_node); // compound literal type
+	Declaration * newDecl = maybeBuild< Declaration >(decl_node); // compound literal type
 	if ( DeclarationWithType * newDeclWithType = dynamic_cast< DeclarationWithType * >( newDecl ) ) { // non-sue compound-literal type
-		return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeBuild<Initializer>(kids) );
+		return new CompoundLiteralExpr( newDeclWithType->get_type(), maybeBuild< Initializer >(kids) );
 	// these types do not have associated type information
 	} else if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( newDecl )  ) {
-		return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeBuild<Initializer>(kids) );
+		return new CompoundLiteralExpr( new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() ), maybeBuild< Initializer >(kids) );
 	} else if ( UnionDecl * newDeclUnionDecl = dynamic_cast< UnionDecl * >( newDecl )  ) {
-		return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeBuild<Initializer>(kids) );
+		return new CompoundLiteralExpr( new UnionInstType( Type::Qualifiers(), newDeclUnionDecl->get_name() ), maybeBuild< Initializer >(kids) );
 	} else if ( EnumDecl * newDeclEnumDecl = dynamic_cast< EnumDecl * >( newDecl )  ) {
-		return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild<Initializer>(kids) );
+		return new CompoundLiteralExpr( new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() ), maybeBuild< Initializer >(kids) );
 	} else {
 		assert( false );
Index: src/Parser/InitializerNode.cc
===================================================================
--- src/Parser/InitializerNode.cc	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/InitializerNode.cc	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:20:24 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug 13 18:55:11 2016
-// Update Count     : 18
+// Last Modified On : Mon Aug 15 18:27:02 2016
+// Update Count     : 20
 //
 
@@ -25,5 +25,5 @@
 	: expr( _expr ), aggregate( aggrp ), designator( des ), kids( 0 ), maybeConstructed( true ) {
 	if ( aggrp )
-		kids = dynamic_cast< InitializerNode *>( get_next() );
+		kids = dynamic_cast< InitializerNode * >( get_next() );
 
 	if ( kids != 0 )
@@ -37,5 +37,5 @@
 
 	if ( aggrp )
-		kids = dynamic_cast< InitializerNode *>( get_next() );
+		kids = dynamic_cast< InitializerNode * >( get_next() );
 
 	if ( kids != 0 )
@@ -82,22 +82,22 @@
 		//assert( next_init() != 0 );
 
-		std::list< Initializer *> initlist;
-		buildList<Initializer, InitializerNode>( next_init(), initlist );
+		std::list< Initializer * > initlist;
+		buildList< Initializer, InitializerNode >( next_init(), initlist );
 
-		std::list< Expression *> designlist;
+		std::list< Expression * > designlist;
 
 		if ( designator != 0 ) {
-			buildList<Expression, ExpressionNode>( designator, designlist );
+			buildList< Expression, ExpressionNode >( designator, designlist );
 		} // if
 
 		return new ListInit( initlist, designlist, maybeConstructed );
 	} else {
-		std::list< Expression *> designators;
+		std::list< Expression * > designators;
 
 		if ( designator != 0 )
-			buildList<Expression, ExpressionNode>( designator, designators );
+			buildList< Expression, ExpressionNode >( designator, designators );
 
 		if ( get_expression() != 0)
-			return new SingleInit( maybeBuild<Expression>( get_expression() ), designators, maybeConstructed );
+			return new SingleInit( maybeBuild< Expression >( get_expression() ), designators, maybeConstructed );
 	} // if
 
Index: src/Parser/ParseNode.cc
===================================================================
--- src/Parser/ParseNode.cc	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/ParseNode.cc	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:26:29 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 15 14:49:06 2016
-// Update Count     : 99
+// Last Modified On : Tue Aug 16 08:42:29 2016
+// Update Count     : 107
 // 
 
@@ -17,10 +17,9 @@
 using namespace std;
 
-// Builder
 int ParseNode::indent_by = 4;
 
-ParseNode::ParseNode() : next( 0 ) {};
-ParseNode::ParseNode( const string *name ) : name( *name ), next( 0 ) { delete name; }
-ParseNode::ParseNode( const string &name ) : name( name ), next( 0 ) { }
+ParseNode::ParseNode() : next( nullptr ) {};
+ParseNode::ParseNode( const string *name ) : name( *name ), next( nullptr ) { delete name; }
+ParseNode::ParseNode( const string &name ) : name( name ), next( nullptr ) { }
 
 ParseNode::~ParseNode() {
@@ -41,7 +40,4 @@
 }
 
-void ParseNode::print( std::ostream &os, int indent ) const {}
-
-
 void ParseNode::printList( std::ostream &os, int indent ) const {
 	print( os, indent );
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/ParseNode.h	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 15 14:52:12 2016
-// Update Count     : 512
+// Last Modified On : Tue Aug 16 08:37:47 2016
+// Update Count     : 527
 //
 
@@ -22,12 +22,11 @@
 #include <memory>
 
-#include "Common/utility.h"
 #include "Parser/LinkageSpec.h"
 #include "SynTree/Type.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Statement.h"
-//#include "SynTree/Declaration.h"
+#include "SynTree/Label.h"
+#include "Common/utility.h"
 #include "Common/UniqueName.h"
-#include "SynTree/Label.h"
 
 class StatementNode;
@@ -37,5 +36,6 @@
 class InitializerNode;
 
-// Builder
+//##############################################################################
+
 class ParseNode {
   public:
@@ -44,4 +44,5 @@
 	ParseNode( const std::string & );					// for copy constructing subclasses
 	virtual ~ParseNode();
+	virtual ParseNode *clone() const { assert( false ); return nullptr; };
 
 	ParseNode *get_next() const { return next; }
@@ -50,18 +51,15 @@
 	ParseNode *set_last( ParseNode * );
 
-	virtual ParseNode *clone() const { return 0; };
-
 	const std::string &get_name() const { return name; }
 	void set_name( const std::string &newValue ) { name = newValue; }
 
-	virtual void print( std::ostream &os, int indent = 0 ) const;
+	virtual void print( std::ostream &os, int indent = 0 ) const {}
 	virtual void printList( std::ostream &os, int indent = 0 ) const;
-
-	ParseNode &operator,( ParseNode & );
-  protected:
+  private:
+	static int indent_by;
+
+	ParseNode *next;
 	std::string name;
-	static int indent_by;
-	ParseNode *next;
-};
+}; // ParseNode
 
 //##############################################################################
@@ -104,5 +102,5 @@
 	virtual ~ExpressionNode() {}
 
-	virtual ExpressionNode *clone() const { return 0; }
+	virtual ExpressionNode *clone() const { assert( false ); return nullptr; }
 
 	bool get_extension() const { return extension; }
@@ -119,5 +117,5 @@
 
 template< typename T >
-struct maybeBuild_t<Expression, T> {
+struct maybeBuild_t< Expression, T > {
 	static inline Expression * doit( const T *orig ) {
 		if ( orig ) {
@@ -126,5 +124,5 @@
 			return p;
 		} else {
-			return 0;
+			return nullptr;
 		} // if
 	}
@@ -228,4 +226,8 @@
 	static DeclarationNode *newBuiltinType( BuiltinType );
 
+	DeclarationNode();
+	~DeclarationNode();
+	DeclarationNode *clone() const;
+
 	DeclarationNode *addQualifiers( DeclarationNode *);
 	DeclarationNode *copyStorageClasses( DeclarationNode *);
@@ -254,5 +256,4 @@
 	DeclarationNode *appendList( DeclarationNode * );
 
-	DeclarationNode *clone() const;
 	void print( std::ostream &os, int indent = 0 ) const;
 	void printList( std::ostream &os, int indent = 0 ) const;
@@ -269,7 +270,4 @@
 	bool get_extension() const { return extension; }
 	DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
-
-	DeclarationNode();
-	~DeclarationNode();
   private:
 	StorageClass buildStorageClass() const;
@@ -351,11 +349,11 @@
 void buildList( const NodeType *firstNode, std::list< SynTreeType * > &outputList ) {
 	SemanticError errors;
-	std::back_insert_iterator< std::list< SynTreeType *> > out( outputList );
+	std::back_insert_iterator< std::list< SynTreeType * > > out( outputList );
 	const NodeType *cur = firstNode;
 
 	while ( cur ) {
 		try {
-//			SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild<typename std::result_of<decltype(&NodeType::build)(NodeType)>::type>( cur ) );
-			SynTreeType *result = dynamic_cast< SynTreeType *>( maybeBuild<typename std::pointer_traits<decltype(cur->build())>::element_type>( cur ) );
+//			SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::result_of< decltype(&NodeType::build)(NodeType)>::type >( cur ) );
+			SynTreeType *result = dynamic_cast< SynTreeType * >( maybeBuild< typename std::pointer_traits< decltype(cur->build())>::element_type >( cur ) );
 			if ( result ) {
 				*out++ = result;
@@ -365,5 +363,5 @@
 			errors.append( e );
 		} // try
-		cur = dynamic_cast< NodeType *>( cur->get_next() );
+		cur = dynamic_cast< NodeType * >( cur->get_next() );
 	} // while
 	if ( ! errors.isEmpty() ) {
@@ -374,5 +372,5 @@
 // in DeclarationNode.cc
 void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList );
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList );
+void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList );
 void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList );
 
Index: src/Parser/Parser.cc
===================================================================
--- src/Parser/Parser.cc	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/Parser.cc	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 14:54:28 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Mar 21 18:04:47 2016
-// Update Count     : 5
+// Last Modified On : Mon Aug 15 17:44:22 2016
+// Update Count     : 7
 // 
 
Index: src/Parser/Parser.h
===================================================================
--- src/Parser/Parser.h	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/Parser.h	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 14:56:50 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat May 16 14:58:56 2015
-// Update Count     : 2
+// Last Modified On : Mon Aug 15 16:33:22 2016
+// Update Count     : 3
 //
 
Index: src/Parser/StatementNode.cc
===================================================================
--- src/Parser/StatementNode.cc	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/StatementNode.cc	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 15 14:40:05 2016
-// Update Count     : 317
+// Last Modified On : Mon Aug 15 20:47:11 2016
+// Update Count     : 322
 //
 
@@ -32,17 +32,17 @@
 		if ( agg ) {
 			StatementNode *nextStmt = new StatementNode( new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) ) );
-			next = nextStmt;
+			set_next( nextStmt );
 			if ( decl->get_next() ) {
-				next->set_next( new StatementNode( dynamic_cast<DeclarationNode *>(decl->get_next()) ) );
+				get_next()->set_next( new StatementNode( dynamic_cast< DeclarationNode * >(decl->get_next()) ) );
 				decl->set_next( 0 );
 			} // if
 		} else {
 			if ( decl->get_next() ) {
-				next = new StatementNode( dynamic_cast<DeclarationNode *>( decl->get_next() ) );
+				set_next(new StatementNode( dynamic_cast< DeclarationNode * >( decl->get_next() ) ) );
 				decl->set_next( 0 );
 			} // if
 			agg = decl;
 		} // if
-		stmt = new DeclStmt( noLabels, maybeBuild<Declaration>(agg) );
+		stmt = new DeclStmt( noLabels, maybeBuild< Declaration >(agg) );
 	} else {
 		assert( false );
@@ -54,15 +54,15 @@
 	// find end of list and maintain previous pointer
 	for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
-		StatementNode *node = dynamic_cast<StatementNode *>(curr);
+		StatementNode *node = dynamic_cast< StatementNode * >(curr);
 		assert( node );
-		assert( dynamic_cast<CaseStmt *>(node->stmt) );
+		assert( dynamic_cast< CaseStmt * >(node->stmt) );
 		prev = curr;
 	} // for
 	// convert from StatementNode list to Statement list
-	StatementNode *node = dynamic_cast<StatementNode *>(prev);
-	std::list<Statement *> stmts;
+	StatementNode *node = dynamic_cast< StatementNode * >(prev);
+	std::list< Statement * > stmts;
 	buildList( stmt, stmts );
 	// splice any new Statements to end of current Statements
-	CaseStmt * caseStmt = dynamic_cast<CaseStmt *>(node->stmt);
+	CaseStmt * caseStmt = dynamic_cast< CaseStmt * >(node->stmt);
 	caseStmt->get_statements().splice( caseStmt->get_statements().end(), stmts );
 	return this;
@@ -80,46 +80,46 @@
 Statement *build_if( ExpressionNode *ctl, StatementNode *then_stmt, StatementNode *else_stmt ) {
 	Statement *thenb, *elseb = 0;
-	std::list<Statement *> branches;
-	buildList<Statement, StatementNode>( then_stmt, branches );
+	std::list< Statement * > branches;
+	buildList< Statement, StatementNode >( then_stmt, branches );
 	assert( branches.size() == 1 );
 	thenb = branches.front();
 
 	if ( else_stmt ) {
-		std::list<Statement *> branches;
-		buildList<Statement, StatementNode>( else_stmt, branches );
+		std::list< Statement * > branches;
+		buildList< Statement, StatementNode >( else_stmt, branches );
 		assert( branches.size() == 1 );
 		elseb = branches.front();
 	} // if
-	return new IfStmt( noLabels, notZeroExpr( maybeBuild<Expression>(ctl) ), thenb, elseb );
+	return new IfStmt( noLabels, notZeroExpr( maybeBuild< Expression >(ctl) ), thenb, elseb );
 }
 
 Statement *build_switch( ExpressionNode *ctl, StatementNode *stmt ) {
-	std::list<Statement *> branches;
-	buildList<Statement, StatementNode>( stmt, branches );
+	std::list< Statement * > branches;
+	buildList< Statement, StatementNode >( stmt, branches );
 	assert( branches.size() >= 0 );						// size == 0 for switch (...) {}, i.e., no declaration or statements
-	return new SwitchStmt( noLabels, maybeBuild<Expression>(ctl), branches );
+	return new SwitchStmt( noLabels, maybeBuild< Expression >(ctl), branches );
 }
 Statement *build_case( ExpressionNode *ctl ) {
-	std::list<Statement *> branches;
-	return new CaseStmt( noLabels, maybeBuild<Expression>(ctl), branches );
+	std::list< Statement * > branches;
+	return new CaseStmt( noLabels, maybeBuild< Expression >(ctl), branches );
 }
 Statement *build_default() {
-	std::list<Statement *> branches;
+	std::list< Statement * > branches;
 	return new CaseStmt( noLabels, nullptr, branches, true );
 }
 
 Statement *build_while( ExpressionNode *ctl, StatementNode *stmt, bool kind ) {
-	std::list<Statement *> branches;
-	buildList<Statement, StatementNode>( stmt, branches );
+	std::list< Statement * > branches;
+	buildList< Statement, StatementNode >( stmt, branches );
 	assert( branches.size() == 1 );
-	return new WhileStmt( noLabels, notZeroExpr( maybeBuild<Expression>(ctl) ), branches.front(), kind );
+	return new WhileStmt( noLabels, notZeroExpr( maybeBuild< Expression >(ctl) ), branches.front(), kind );
 }
 
 Statement *build_for( ForCtl *forctl, StatementNode *stmt ) {
-	std::list<Statement *> branches;
-	buildList<Statement, StatementNode>( stmt, branches );
+	std::list< Statement * > branches;
+	buildList< Statement, StatementNode >( stmt, branches );
 	assert( branches.size() == 1 );
 
-	std::list<Statement *> init;
+	std::list< Statement * > init;
 	if ( forctl->init != 0 ) {
 		buildList( forctl->init, init );
@@ -128,9 +128,9 @@
 	Expression *cond = 0;
 	if ( forctl->condition != 0 )
-		cond = notZeroExpr( maybeBuild<Expression>(forctl->condition) );
+		cond = notZeroExpr( maybeBuild< Expression >(forctl->condition) );
 
 	Expression *incr = 0;
 	if ( forctl->change != 0 )
-		incr = maybeBuild<Expression>(forctl->change);
+		incr = maybeBuild< Expression >(forctl->change);
 
 	delete forctl;
@@ -142,14 +142,14 @@
 }
 Statement *build_computedgoto( ExpressionNode *ctl ) {
-	return new BranchStmt( noLabels, maybeBuild<Expression>(ctl), BranchStmt::Goto );
+	return new BranchStmt( noLabels, maybeBuild< Expression >(ctl), BranchStmt::Goto );
 }
 
 Statement *build_return( ExpressionNode *ctl ) {
-	std::list<Expression *> exps;
+	std::list< Expression * > exps;
 	buildList( ctl, exps );
 	return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr );
 }
 Statement *build_throw( ExpressionNode *ctl ) {
-	std::list<Expression *> exps;
+	std::list< Expression * > exps;
 	buildList( ctl, exps );
 	return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr, true );
@@ -157,22 +157,22 @@
 
 Statement *build_try( StatementNode *try_stmt, StatementNode *catch_stmt, StatementNode *finally_stmt ) {
-	std::list<Statement *> branches;
-	buildList<Statement, StatementNode>( catch_stmt, branches );
-	CompoundStmt *tryBlock = dynamic_cast<CompoundStmt *>(maybeBuild<Statement>(try_stmt));
+	std::list< Statement * > branches;
+	buildList< Statement, StatementNode >( catch_stmt, branches );
+	CompoundStmt *tryBlock = dynamic_cast< CompoundStmt * >(maybeBuild< Statement >(try_stmt));
 	assert( tryBlock );
-	FinallyStmt *finallyBlock = dynamic_cast<FinallyStmt *>(maybeBuild<Statement>(finally_stmt) );
+	FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeBuild< Statement >(finally_stmt) );
 	return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
 }
 Statement *build_catch( DeclarationNode *decl, StatementNode *stmt, bool catchAny ) {
-	std::list<Statement *> branches;
-	buildList<Statement, StatementNode>( stmt, branches );
+	std::list< Statement * > branches;
+	buildList< Statement, StatementNode >( stmt, branches );
 	assert( branches.size() == 1 );
-	return new CatchStmt( noLabels, maybeBuild<Declaration>(decl), branches.front(), catchAny );
+	return new CatchStmt( noLabels, maybeBuild< Declaration >(decl), branches.front(), catchAny );
 }
 Statement *build_finally( StatementNode *stmt ) {
-	std::list<Statement *> branches;
-	buildList<Statement, StatementNode>( stmt, branches );
+	std::list< Statement * > branches;
+	buildList< Statement, StatementNode >( stmt, branches );
 	assert( branches.size() == 1 );
-	return new FinallyStmt( noLabels, dynamic_cast<CompoundStmt *>( branches.front() ) );
+	return new FinallyStmt( noLabels, dynamic_cast< CompoundStmt * >( branches.front() ) );
 }
 
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/TypeData.cc	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug 13 18:38:41 2016
-// Update Count     : 59
+// Last Modified On : Mon Aug 15 20:48:52 2016
+// Update Count     : 62
 //
 
@@ -182,5 +182,4 @@
 		break;
 	  case Array:
-//PAB		newtype->array->dimension = maybeClone( array->dimension );
 		newtype->array->dimension = array->dimension;
 		newtype->array->isVarLen = array->isVarLen;
@@ -489,6 +488,6 @@
 				decl = new FunctionDecl( name, sc, linkage, buildFunction(), body, isInline, isNoreturn );
 			} else {
-				// std::list<Label> ls;
-				decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list<Label>() ), isInline, isNoreturn );
+				// std::list< Label > ls;
+				decl = new FunctionDecl( name, sc, linkage, buildFunction(), new CompoundStmt( std::list< Label >() ), isInline, isNoreturn );
 			} // if
 		} else {
@@ -909,7 +908,7 @@
 	buildList( enumeration->constants, ret->get_members() );
 	std::list< Declaration * >::iterator members = ret->get_members().begin();
-	for ( const DeclarationNode *cur = enumeration->constants; cur != NULL; cur = dynamic_cast<DeclarationNode *>( cur->get_next() ), ++members ) {
+	for ( const DeclarationNode *cur = enumeration->constants; cur != NULL; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
 		if ( cur->get_enumeratorValue() != NULL ) {
-			ObjectDecl *member = dynamic_cast<ObjectDecl *>(*members);
+			ObjectDecl *member = dynamic_cast< ObjectDecl * >(*members);
 			member->set_init( new SingleInit( maybeBuild< Expression >( cur->get_enumeratorValue() ), std::list< Expression * >() ) );
 		} // if
Index: src/Parser/TypedefTable.cc
===================================================================
--- src/Parser/TypedefTable.cc	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/TypedefTable.cc	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr 13 16:57:30 2016
-// Update Count     : 24
+// Last Modified On : Mon Aug 15 18:24:42 2016
+// Update Count     : 25
 //
 
@@ -64,9 +64,9 @@
 		tableType::iterator curPos = table.find( identifier );
 		if ( curPos == table.end()) {
-			list<Entry> newList;
+			list< Entry > newList;
 			newList.push_front( newEntry );
 			table[identifier] = newList;
 		} else {
-			list<Entry>::iterator listPos = (*curPos ).second.begin();
+			list< Entry >::iterator listPos = (*curPos ).second.begin();
 			while ( listPos != (*curPos ).second.end() && listPos->scope > scope ) {
 				listPos++;
@@ -127,5 +127,5 @@
 	debugPrint( "Leaving scope " << currentScope << endl );
 	for ( tableType::iterator i = table.begin(); i != table.end(); ) {
-		list<Entry> &declList = (*i).second;
+		list< Entry > &declList = (*i).second;
 		while ( ! declList.empty() && declList.front().scope == currentScope ) {
 			declList.pop_front();
@@ -157,6 +157,6 @@
 	for ( tableType::const_iterator i = table.begin(); i != table.end(); i++) {
 		debugPrint( (*i ).first << ": " );
-		list<Entry> declList = (*i).second;
-		for ( list<Entry>::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
+		list< Entry > declList = (*i).second;
+		for ( list< Entry >::const_iterator j = declList.begin(); j != declList.end(); j++ ) {
 			debugPrint( "(" << (*j).scope << " " << (*j).kind << ") " );
 		}
Index: src/Parser/TypedefTable.h
===================================================================
--- src/Parser/TypedefTable.h	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/Parser/TypedefTable.h	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:24:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Apr 13 16:59:56 2016
-// Update Count     : 27
+// Last Modified On : Mon Aug 15 18:25:04 2016
+// Update Count     : 28
 //
 
@@ -39,5 +39,5 @@
 	};
 
-	typedef std::map<std::string, std::list<Entry> > tableType;
+	typedef std::map< std::string, std::list< Entry > > tableType;
 	tableType table;
 
Index: src/main.cc
===================================================================
--- src/main.cc	(revision b1848a0d95cbc3cc0a9b494f8765c86ce58bafb6)
+++ src/main.cc	(revision 78805792ebc7b90598f2af4cb9070002b1ba3cf8)
@@ -10,16 +10,12 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug  6 16:17:41 2016
-// Update Count     : 210
+// Last Modified On : Mon Aug 15 17:58:57 2016
+// Update Count     : 220
 //
 
 #include <iostream>
 #include <fstream>
-#include <cstdlib>
-#include <cstdio>
 #include <getopt.h>
 #include "Parser/Parser.h"
-#include "Parser/ParseNode.h"
-#include "Parser/LinkageSpec.h"
 #include "SynTree/Declaration.h"
 #include "SynTree/Visitor.h"
@@ -43,6 +39,4 @@
 #include "InitTweak/GenInit.h"
 #include "InitTweak/FixInit.h"
-//#include "Explain/GenProlog.h"
-//#include "Try/Visit.h"
 
 #include "Common/SemanticError.h"
@@ -384,6 +378,5 @@
 	std::list< Declaration * > decls;
 	if ( noprotop ) {
-		filter( translationUnit.begin(), translationUnit.end(),
-				std::back_inserter( decls ), notPrelude );
+		filter( translationUnit.begin(), translationUnit.end(), std::back_inserter( decls ), notPrelude );
 	} else {
 		decls = translationUnit;