Index: src/Parser/StatementNode.cc
===================================================================
--- src/Parser/StatementNode.cc	(revision e82aa9df9f1dc1335a759e00a2d82ca558fe6b0e)
+++ src/Parser/StatementNode.cc	(revision b7ea418689026021dec0e39259e99d165731ed42)
@@ -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() ) );
 }
 
