Index: translator/Parser/DeclarationNode.cc
===================================================================
--- translator/Parser/DeclarationNode.cc	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/DeclarationNode.cc	(revision bdd516a5257cb93cc0c5b4a4c343cc112252022a)
@@ -5,18 +5,12 @@
 #include <cassert>
 
-#include "ParseNode.h"
 #include "TypeData.h"
-#include "utility.h"
-#include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
-#include "SynTree/Initializer.h"
-#include "SemanticError.h"
-#include "UniqueName.h"
-#include "LinkageSpec.h"
+
 
 using namespace std;
 
-/* these must remain in the same order as the corresponding DeclarationNode enumerations */
-const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue" };
+// These must remain in the same order as the corresponding DeclarationNode enumerations.
+const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" };
 const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary" };
 const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" };
@@ -67,7 +61,7 @@
     os << string(indent, ' ' );
     if ( name == "" ) {
-///     os << "An unnamed ";
+	os << "unnamed: ";
     } else {
-	os << name << ": a ";
+	os << name << ": ";
     }
 
@@ -862,16 +856,13 @@
 	      ret = new StructInstType( type->buildQualifiers(), type->aggregate->name );
 	      break;
-
 	    case DeclarationNode::Union:
 	      ret = new UnionInstType( type->buildQualifiers(), type->aggregate->name );
 	      break;
-
 	    case DeclarationNode::Context:
 	      ret = new ContextInstType( type->buildQualifiers(), type->aggregate->name );
 	      break;
-
 	    default:
 	      assert( false );
-	  }
+	  } // switch
 	  buildList( type->aggregate->actuals, ret->get_parameters() );
 	  return ret;
@@ -884,5 +875,5 @@
       default:
 	return type->build();
-    }
+    } // switch
 }
 
Index: translator/Parser/ExpressionNode.cc
===================================================================
--- translator/Parser/ExpressionNode.cc	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/ExpressionNode.cc	(revision bdd516a5257cb93cc0c5b4a4c343cc112252022a)
@@ -16,5 +16,5 @@
 ExpressionNode::ExpressionNode() : ParseNode(), argName( 0 ) {}
 
-ExpressionNode::ExpressionNode(string *name_) : ParseNode( *name_ ), argName( 0 ) {
+ExpressionNode::ExpressionNode( string *name_) : ParseNode( *name_ ), argName( 0 ) {
     delete name_;
 }
@@ -25,9 +25,9 @@
     } else {
 	argName = 0;
-    }
+    } // if
 }
 
 ExpressionNode * ExpressionNode::set_asArgName( std::string *aName ) {
-    argName = new VarRefNode(aName);
+    argName = new VarRefNode( aName );
     return this;
 }
@@ -40,8 +40,8 @@
 void ExpressionNode::printDesignation( std::ostream &os, int indent ) const {
     if ( argName ) {
-	os << string(' ', indent) << "(designated by:  ";
-	argName->printOneLine(os, indent );
+	os << string(' ', indent ) << "(designated by:  ";
+	argName->printOneLine( os, indent );
 	os << ")" << std::endl;
-    }
+    } // if
 }
 
@@ -52,11 +52,11 @@
 }
 
-void NullExprNode::print(std::ostream & os, int indent) const {
-    printDesignation(os);
+void NullExprNode::print( std::ostream & os, int indent ) const {
+    printDesignation( os );
     os << "null expression";
 }
 
-void NullExprNode::printOneLine(std::ostream & os, int indent) const {
-    printDesignation(os);
+void NullExprNode::printOneLine( std::ostream & os, int indent ) const {
+    printDesignation( os );
     os << "null";
 }
@@ -66,15 +66,15 @@
 }
 
-CommaExprNode *ExpressionNode::add_to_list(ExpressionNode *exp){
-    return new CommaExprNode(this, exp );
+CommaExprNode *ExpressionNode::add_to_list( ExpressionNode *exp ){
+    return new CommaExprNode( this, exp );
 }
 
 //  enum ConstantNode::Type =  { Integer, Float, Character, String, Range }
 
-ConstantNode::ConstantNode(void) : ExpressionNode(), sign(true), longs(0), size(0) {}
-
-ConstantNode::ConstantNode(string *name_) : ExpressionNode(name_), sign(true), longs(0), size(0) {}
-
-ConstantNode::ConstantNode(Type t, string *inVal) : type(t), sign(true), longs(0), size(0) {
+ConstantNode::ConstantNode( void ) : ExpressionNode(), sign( true ), longs(0), size(0) {}
+
+ConstantNode::ConstantNode( string *name_) : ExpressionNode( name_), sign( true ), longs(0), size(0) {}
+
+ConstantNode::ConstantNode( Type t, string *inVal ) : type( t ), sign( true ), longs(0), size(0) {
     if ( inVal ) {
 	value = *inVal;
@@ -82,7 +82,7 @@
     } else {
 	value = "";
-    }
-
-    classify(value);
+    } // if
+
+    classify( value );
 }
 
@@ -96,6 +96,6 @@
 }
 
-void ConstantNode::classify(std::string &str){
-    switch (type){
+void ConstantNode::classify( std::string &str ){
+    switch ( type ){
       case Integer:
       case Float:
@@ -105,5 +105,5 @@
 	    int i = str.length() - 1;
 
-	    while ( i >= 0 && !isxdigit(c = str.at(i--)) )
+	    while ( i >= 0 && !isxdigit( c = str.at( i--)) )
 		sfx += c;
 
@@ -111,15 +111,15 @@
 
 	    // get rid of underscores
-	    value.erase(remove(value.begin(), value.end(), '_'), value.end());
-
-	    std::transform(sfx.begin(), sfx.end(), sfx.begin(), tolower_hack);
+	    value.erase( remove( value.begin(), value.end(), '_'), value.end());
+
+	    std::transform( sfx.begin(), sfx.end(), sfx.begin(), tolower_hack );
 
 	    if ( sfx.find("ll") != string::npos ){
 		longs = 2;
-	    } else if (sfx.find("l") != string::npos ){
+	    } else if ( sfx.find("l") != string::npos ){
 		longs = 1;
-	    }
-
-	    assert((longs >= 0) && (longs <= 2));
+	    } // if
+
+	    assert(( longs >= 0) && ( longs <= 2));
 
 	    if ( sfx.find("u") != string::npos )
@@ -131,6 +131,6 @@
 	{
 	    // remove underscores from hex and oct escapes
-	    if (str.substr(1,2) == "\\x")
-		value.erase(remove(value.begin(), value.end(), '_'), value.end());
+	    if ( str.substr(1,2) == "\\x")
+		value.erase( remove( value.begin(), value.end(), '_'), value.end());
 
 	    break;
@@ -142,5 +142,5 @@
 }
 
-ConstantNode::Type ConstantNode::get_type(void) const {
+ConstantNode::Type ConstantNode::get_type( void ) const {
     return type;
 }
@@ -148,5 +148,5 @@
 ConstantNode *ConstantNode::append( std::string *newValue ) {
     if ( newValue ) {
-	if (type == String){
+	if ( type == String ){
 	    std::string temp = *newValue;
 	    value.resize( value.size() - 1 );
@@ -156,11 +156,11 @@
 
 	delete newValue;
-    }
+    } // if
     return this;
 }
 
-void ConstantNode::printOneLine(std::ostream &os, int indent ) const {
-    os << string(indent, ' ');
-    printDesignation(os);
+void ConstantNode::printOneLine( std::ostream &os, int indent ) const {
+    os << string( indent, ' ');
+    printDesignation( os );
 
     switch ( type ) {
@@ -185,5 +185,5 @@
 }
 
-void ConstantNode::print(std::ostream &os, int indent ) const {
+void ConstantNode::print( std::ostream &os, int indent ) const {
     printOneLine( os, indent );
     os << endl;
@@ -194,15 +194,15 @@
     BasicType *bt;
 
-    switch (get_type()){
+    switch ( get_type()){
       case Integer:
 	/* Cfr. standard 6.4.4.1 */
-	//bt.set_kind(BasicType::SignedInt);
-	bt = new BasicType(q, BasicType::SignedInt);
+	//bt.set_kind( BasicType::SignedInt );
+	bt = new BasicType( q, BasicType::SignedInt );
 	break;
       case Float:
-	bt = new BasicType(q, BasicType::Float);
+	bt = new BasicType( q, BasicType::Float );
 	break;
       case Character:
-	bt = new BasicType(q, BasicType::Char);
+	bt = new BasicType( q, BasicType::Char );
 	break;
       case String:
@@ -210,16 +210,16 @@
 	ArrayType *at;
 	std::string value = get_value();
-	at = new ArrayType(q, new BasicType(q, BasicType::Char),
-			   new ConstantExpr( Constant( new BasicType(q, BasicType::SignedInt),
+	at = new ArrayType( q, new BasicType( q, BasicType::Char ),
+			   new ConstantExpr( Constant( new BasicType( q, BasicType::SignedInt ),
 						       toString( value.size() - 1 ) ) ),  // account for '\0'
 			   false, false );
-	return new ConstantExpr( Constant(at, value), maybeBuild< Expression >( get_argName() ) );
+	return new ConstantExpr( Constant( at, value ), maybeBuild< Expression >( get_argName() ) );
     }
-    return new ConstantExpr(  Constant(bt, get_value()),  maybeBuild< Expression >( get_argName() ) );
-}
-
-VarRefNode::VarRefNode() : isLabel(false) {}
-
-VarRefNode::VarRefNode(string *name_, bool labelp) : ExpressionNode(name_), isLabel(labelp) {}
+    return new ConstantExpr(  Constant( bt, get_value()),  maybeBuild< Expression >( get_argName() ) );
+}
+
+VarRefNode::VarRefNode() : isLabel( false ) {}
+
+VarRefNode::VarRefNode( string *name_, bool labelp ) : ExpressionNode( name_), isLabel( labelp ) {}
 
 VarRefNode::VarRefNode( const VarRefNode &other ) : ExpressionNode( other ), isLabel( other.isLabel ) {
@@ -230,17 +230,17 @@
 }
 
-void VarRefNode::printOneLine(std::ostream &os, int indent ) const {
-    printDesignation(os);
+void VarRefNode::printOneLine( std::ostream &os, int indent ) const {
+    printDesignation( os );
     os << get_name() << ' ';
 }
 
-void VarRefNode::print(std::ostream &os, int indent ) const {
-    printDesignation(os);
-    os << '\r' << string(indent, ' ') << "Referencing: ";
+void VarRefNode::print( std::ostream &os, int indent ) const {
+    printDesignation( os );
+    os << '\r' << string( indent, ' ') << "Referencing: ";
     os << "Variable: " << get_name();
     os << endl;
 }
 
-OperatorNode::OperatorNode(Type t) : type(t) {}
+OperatorNode::OperatorNode( Type t ) : type( t ) {}
 
 OperatorNode::OperatorNode( const OperatorNode &other ) : ExpressionNode( other ), type( other.type ) {
@@ -249,21 +249,21 @@
 OperatorNode::~OperatorNode() {}
 
-OperatorNode::Type OperatorNode::get_type(void) const{
+OperatorNode::Type OperatorNode::get_type( void ) const{
     return type;
 }
 
 void OperatorNode::printOneLine( std::ostream &os, int indent ) const {
-    printDesignation(os);
+    printDesignation( os );
     os << OpName[ type ] << ' ';
 }
 
 void OperatorNode::print( std::ostream &os, int indent ) const{
-    printDesignation(os);
-    os << '\r' << string(indent, ' ') << "Operator: " << OpName[type] << endl;
+    printDesignation( os );
+    os << '\r' << string( indent, ' ') << "Operator: " << OpName[type] << endl;
     return;
 }
 
-std::string OperatorNode::get_typename(void) const{
-    return string(OpName[ type ]);
+std::string OperatorNode::get_typename( void ) const{
+    return string( OpName[ type ]);
 }
 
@@ -282,17 +282,17 @@
 };
 
-CompositeExprNode::CompositeExprNode(void) : ExpressionNode(), function( 0 ), arguments( 0 ) {
-}
-
-CompositeExprNode::CompositeExprNode(string *name_) : ExpressionNode(name_), function( 0 ), arguments( 0 ) {
-}
-
-CompositeExprNode::CompositeExprNode(ExpressionNode *f, ExpressionNode *args):
-    function(f), arguments(args) {
-}
-
-CompositeExprNode::CompositeExprNode(ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
-    function(f), arguments(arg1) {
-    arguments->set_link(arg2);
+CompositeExprNode::CompositeExprNode( void ) : ExpressionNode(), function( 0 ), arguments( 0 ) {
+}
+
+CompositeExprNode::CompositeExprNode( string *name_) : ExpressionNode( name_), function( 0 ), arguments( 0 ) {
+}
+
+CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *args ):
+    function( f ), arguments( args ) {
+}
+
+CompositeExprNode::CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2):
+    function( f ), arguments( arg1) {
+    arguments->set_link( arg2);
 }
 
@@ -303,6 +303,6 @@
 	    arguments->set_link( cur->clone() );
 	} else {
-	    arguments = (ExpressionNode*)cur->clone();
-	}
+	    arguments = ( ExpressionNode*)cur->clone();
+	} // if
 	cur = cur->get_link();
     }
@@ -333,11 +333,11 @@
     std::list<Expression *> args;
 
-    buildList(get_args(), args);
-
-    if ( ! ( op = dynamic_cast<OperatorNode *>(function)) ) {
+    buildList( get_args(), args );
+
+    if ( ! ( op = dynamic_cast<OperatorNode *>( function )) ) {
 	// a function as opposed to an operator
-	return new UntypedExpr(function->build(), args, maybeBuild< Expression >( get_argName() ));
+	return new UntypedExpr( function->build(), args, maybeBuild< Expression >( get_argName() ));
     } else {
-	switch (op->get_type()){
+	switch ( op->get_type()){
 	  case OperatorNode::Incr:
 	  case OperatorNode::Decr:
@@ -412,9 +412,9 @@
 	  case OperatorNode::Cast:
 	    {
-		TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args());
+		TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args());
 		assert( arg );
 
 		DeclarationNode *decl_node = arg->get_decl();
-		ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>(arg->get_link());
+		ExpressionNode *expr_node = dynamic_cast<ExpressionNode *>( arg->get_link());
 
 		Type *targetType = decl_node->buildType();
@@ -423,6 +423,6 @@
 		    return new CastExpr( expr_node->build(), maybeBuild< Expression >( get_argName() ) );
 		} else {
-		    return new CastExpr(expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
-		}
+		    return new CastExpr( expr_node->build(),targetType, maybeBuild< Expression >( get_argName() ) );
+		} // if
 	    }
 	  case OperatorNode::FieldSel:
@@ -430,20 +430,18 @@
 		assert( args.size() == 2 );
 
-		NameExpr *member = dynamic_cast<NameExpr *>(args.back());
-		// TupleExpr *memberTup = dynamic_cast<TupleExpr *>(args.back());
-
-		if ( member != 0 )
-		    {
-			UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), args.front());
-			delete member;
-			return ret;
-		    }
+		NameExpr *member = dynamic_cast<NameExpr *>( args.back());
+		// TupleExpr *memberTup = dynamic_cast<TupleExpr *>( args.back());
+
+		if ( member != 0 ) {
+		    UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), args.front());
+		    delete member;
+		    return ret;
 		/* else if ( memberTup != 0 )
 		   {
-		   UntypedMemberExpr *ret = new UntypedMemberExpr(memberTup->get_name(), args.front());
+		   UntypedMemberExpr *ret = new UntypedMemberExpr( memberTup->get_name(), args.front());
 		   delete member;
 		   return ret;
 		   } */
-		else
+		} else
 		    assert( false );
 	    }
@@ -452,5 +450,5 @@
 		assert( args.size() == 2 );
 
-		NameExpr *member = dynamic_cast<NameExpr *>(args.back());  // modify for Tuples   xxx
+		NameExpr *member = dynamic_cast<NameExpr *>( args.back());  // modify for Tuples   xxx
 		assert( member != 0 );
 
@@ -458,5 +456,5 @@
 		deref->get_args().push_back( args.front() );
 
-		UntypedMemberExpr *ret = new UntypedMemberExpr(member->get_name(), deref);
+		UntypedMemberExpr *ret = new UntypedMemberExpr( member->get_name(), deref );
 		delete member;
 		return ret;
@@ -465,23 +463,23 @@
 	  case OperatorNode::SizeOf:
 	    {
-/// 	bool isSizeOf = (op->get_type() == OperatorNode::SizeOf);
-
-		if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args()) ) {
-		    return new SizeofExpr(arg->get_decl()->buildType());
+/// 	bool isSizeOf = ( op->get_type() == OperatorNode::SizeOf );
+
+		if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()) ) {
+		    return new SizeofExpr( arg->get_decl()->buildType());
 		} else {
-		    return new SizeofExpr(args.front());
-		}
+		    return new SizeofExpr( args.front());
+		} // if
 	    }
 	  case OperatorNode::Attr:
 	    {
-		VarRefNode *var = dynamic_cast<VarRefNode *>(get_args());
+		VarRefNode *var = dynamic_cast<VarRefNode *>( get_args());
 		assert( var );
 		if ( !get_args()->get_link() ) {
-		    return new AttrExpr(var->build(), (Expression*)0);
-		} else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>(get_args()->get_link()) ) {
-		    return new AttrExpr(var->build(), arg->get_decl()->buildType());
+		    return new AttrExpr( var->build(), ( Expression*)0);
+		} else if ( TypeValueNode * arg = dynamic_cast<TypeValueNode *>( get_args()->get_link()) ) {
+		    return new AttrExpr( var->build(), arg->get_decl()->buildType());
 		} else {
-		    return new AttrExpr(var->build(), args.back());
-		}
+		    return new AttrExpr( var->build(), args.back());
+		} // if
 	    }
 	  case OperatorNode::CompLit:
@@ -490,9 +488,9 @@
 	  case OperatorNode::Or:
 	  case OperatorNode::And:
-	    assert(args.size() == 2);
-	    return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), (op->get_type() == OperatorNode::And) );
+	    assert( args.size() == 2);
+	    return new LogicalExpr( notZeroExpr( args.front() ), notZeroExpr( args.back() ), ( op->get_type() == OperatorNode::And ) );
 	  case OperatorNode::Cond:
 	    {
-		assert(args.size() == 3);
+		assert( args.size() == 3);
 		std::list< Expression* >::const_iterator i = args.begin();
 		Expression *arg1 = notZeroExpr( *i++ );
@@ -505,5 +503,5 @@
 	  case OperatorNode::Comma:
 	    {
-		assert(args.size() == 2);
+		assert( args.size() == 2);
 		std::list< Expression* >::const_iterator i = args.begin();
 		Expression *ret = *i++;
@@ -527,9 +525,9 @@
 }
 
-void CompositeExprNode::printOneLine(std::ostream &os, int indent) const {
-    printDesignation(os);
+void CompositeExprNode::printOneLine( std::ostream &os, int indent ) const {
+    printDesignation( os );
     os << "( ";
     function->printOneLine( os, indent );
-    for( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
+    for ( ExpressionNode *cur = arguments; cur != 0; cur = dynamic_cast< ExpressionNode* >( cur->get_link() ) ) {
 	cur->printOneLine( os, indent );
     }
@@ -537,50 +535,50 @@
 }
 
-void CompositeExprNode::print(std::ostream &os, int indent) const {
-    printDesignation(os);
-    os << '\r' << string(indent, ' ') << "Application of: " << endl;
+void CompositeExprNode::print( std::ostream &os, int indent ) const {
+    printDesignation( os );
+    os << '\r' << string( indent, ' ') << "Application of: " << endl;
     function->print( os, indent + ParseNode::indent_by );
 
-    os << '\r' << string(indent, ' ') ;
+    os << '\r' << string( indent, ' ') ;
     if ( arguments ) {
 	os << "... on arguments: " << endl;
-	arguments->printList(os, indent + ParseNode::indent_by);
+	arguments->printList( os, indent + ParseNode::indent_by );
     } else
 	os << "... on no arguments: " << endl;
 }
 
-void CompositeExprNode::set_function(ExpressionNode *f){
+void CompositeExprNode::set_function( ExpressionNode *f ){
     function = f;
 }
 
-void CompositeExprNode::set_args(ExpressionNode *args){
+void CompositeExprNode::set_args( ExpressionNode *args ){
     arguments = args;
 }
 
-ExpressionNode *CompositeExprNode::get_function(void) const {
+ExpressionNode *CompositeExprNode::get_function( void ) const {
     return function;
 }
 
-ExpressionNode *CompositeExprNode::get_args(void) const {
+ExpressionNode *CompositeExprNode::get_args( void ) const {
     return arguments;
 }
 
-void CompositeExprNode::add_arg(ExpressionNode *arg){
-    if (arguments)
-	arguments->set_link(arg);
+void CompositeExprNode::add_arg( ExpressionNode *arg ){
+    if ( arguments )
+	arguments->set_link( arg );
     else
-	set_args(arg);
-}
-
-CommaExprNode::CommaExprNode(): CompositeExprNode(new OperatorNode(OperatorNode::Comma)) {}
-
-CommaExprNode::CommaExprNode(ExpressionNode *exp) : CompositeExprNode( new OperatorNode(OperatorNode::Comma), exp ) {
-}
-
-CommaExprNode::CommaExprNode(ExpressionNode *exp1, ExpressionNode *exp2) : CompositeExprNode(new OperatorNode(OperatorNode::Comma), exp1, exp2) {
-}
-
-CommaExprNode *CommaExprNode::add_to_list(ExpressionNode *exp){
-    add_arg(exp);
+	set_args( arg );
+}
+
+CommaExprNode::CommaExprNode(): CompositeExprNode( new OperatorNode( OperatorNode::Comma )) {}
+
+CommaExprNode::CommaExprNode( ExpressionNode *exp ) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp ) {
+}
+
+CommaExprNode::CommaExprNode( ExpressionNode *exp1, ExpressionNode *exp2) : CompositeExprNode( new OperatorNode( OperatorNode::Comma ), exp1, exp2) {
+}
+
+CommaExprNode *CommaExprNode::add_to_list( ExpressionNode *exp ){
+    add_arg( exp );
 
     return this;
@@ -590,5 +588,5 @@
 }
 
-ValofExprNode::ValofExprNode(StatementNode *s): body(s) {}
+ValofExprNode::ValofExprNode( StatementNode *s ): body( s ) {}
 
 ValofExprNode::ValofExprNode( const ValofExprNode &other ) : ExpressionNode( other ), body( maybeClone( body ) ) {
@@ -600,7 +598,7 @@
 
 void ValofExprNode::print( std::ostream &os, int indent ) const {
-    printDesignation(os);
-    os << string(indent, ' ') << "Valof Expression:" << std::endl;
-    get_body()->print(os, indent + 4);
+    printDesignation( os );
+    os << string( indent, ' ') << "Valof Expression:" << std::endl;
+    get_body()->print( os, indent + 4);
 }
 
@@ -613,5 +611,5 @@
 }
 
-ForCtlExprNode::ForCtlExprNode(ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr) throw (SemanticError) : condition(cond), change(incr) {
+ForCtlExprNode::ForCtlExprNode( ParseNode *init_, ExpressionNode *cond, ExpressionNode *incr ) throw ( SemanticError ) : condition( cond ), change( incr ) {
     if ( init_ == 0 )
 	init = 0;
@@ -620,8 +618,8 @@
 	ExpressionNode *exp;
 
-	if ((decl = dynamic_cast<DeclarationNode *>(init_)) != 0)
-	    init = new StatementNode(decl);
-	else if ((exp = dynamic_cast<ExpressionNode *>(init_)) != 0)
-	    init = new StatementNode(StatementNode::Exp, exp);
+	if (( decl = dynamic_cast<DeclarationNode *>( init_)) != 0)
+	    init = new StatementNode( decl );
+	else if (( exp = dynamic_cast<ExpressionNode *>( init_)) != 0)
+	    init = new StatementNode( StatementNode::Exp, exp );
 	else
 	    throw SemanticError("Error in for control expression");
@@ -646,16 +644,16 @@
 
 void ForCtlExprNode::print( std::ostream &os, int indent ) const{
-    os << string(indent,' ') << "For Control Expression -- : " << endl;
-
-    os << "\r" << string(indent + 2,' ') << "initialization: ";
-    if (init != 0)
-	init->print(os, indent + 4);
-
-    os << "\n\r" << string(indent + 2,' ') << "condition: ";
-    if (condition != 0)
-	condition->print(os, indent + 4);
-    os << "\n\r" << string(indent + 2,' ') << "increment: ";
-    if (change != 0)
-	change->print(os, indent + 4);
+    os << string( indent,' ') << "For Control Expression -- : " << endl;
+
+    os << "\r" << string( indent + 2,' ') << "initialization: ";
+    if ( init != 0)
+	init->print( os, indent + 4);
+
+    os << "\n\r" << string( indent + 2,' ') << "condition: ";
+    if ( condition != 0)
+	condition->print( os, indent + 4);
+    os << "\n\r" << string( indent + 2,' ') << "increment: ";
+    if ( change != 0)
+	change->print( os, indent + 4);
 }
 
@@ -664,5 +662,5 @@
 }
 
-TypeValueNode::TypeValueNode(DeclarationNode *decl)
+TypeValueNode::TypeValueNode( DeclarationNode *decl )
     : decl( decl ) {
 }
@@ -676,12 +674,12 @@
 }
 
-void TypeValueNode::print(std::ostream &os, int indent) const {
+void TypeValueNode::print( std::ostream &os, int indent ) const {
     os << std::string( indent, ' ' ) << "Type:";
-    get_decl()->print(os, indent + 2);
-}
-
-void TypeValueNode::printOneLine(std::ostream &os, int indent) const {
+    get_decl()->print( os, indent + 2);
+}
+
+void TypeValueNode::printOneLine( std::ostream &os, int indent ) const {
     os << "Type:";
-    get_decl()->print(os, indent + 2);
+    get_decl()->print( os, indent + 2);
 }
 
@@ -690,5 +688,5 @@
 	{
 	    OperatorNode *op;
-	    if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::Comma) )
+	    if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::Comma ) )
 		{
 		    if ( ExpressionNode *next = dynamic_cast< ExpressionNode * >( list->get_link() ) )
@@ -707,5 +705,5 @@
     if ( CompositeExprNode *composite = dynamic_cast< CompositeExprNode * >( tuple ) ) {
 	OperatorNode *op = 0;
-	if ( (op = dynamic_cast< OperatorNode * >( composite->get_function() )) && (op->get_type() == OperatorNode::TupleC) )
+	if ( ( op = dynamic_cast< OperatorNode * >( composite->get_function() )) && ( op->get_type() == OperatorNode::TupleC ) )
 	    return composite->get_args();
     }
Index: translator/Parser/InitializerNode.cc
===================================================================
--- translator/Parser/InitializerNode.cc	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/InitializerNode.cc	(revision bdd516a5257cb93cc0c5b4a4c343cc112252022a)
@@ -1,12 +1,9 @@
+#include <cassert>
+#include <iostream>
+using namespace std;
+
 #include "ParseNode.h"
 #include "SynTree/Expression.h"
 #include "SynTree/Initializer.h"
-#include "utility.h"
-#include "SemanticError.h"
-// #include <cstdlib> // for strtol
-#include <cassert>
-
-#include <iostream>
-using namespace std;
 
 InitializerNode::InitializerNode( ExpressionNode *_expr, bool aggrp, ExpressionNode *des )
Index: translator/Parser/ParseNode.cc
===================================================================
--- translator/Parser/ParseNode.cc	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/ParseNode.cc	(revision bdd516a5257cb93cc0c5b4a4c343cc112252022a)
@@ -73,9 +73,9 @@
 }
 
-ParseNode *mkList(ParseNode &pn){
+ParseNode *mkList( ParseNode &pn ) {
     /* it just relies on `operator,' to take care of the "arguments" and provides
        a nice interface to an awful-looking address-of, rendering, for example
        (StatementNode *)(&(*$5 + *$7)) into (StatementNode *)mkList(($5, $7))
-       (although "nice"  is probably not the word)
+       (although "nice" is probably not the word)
     */
     return &pn;
Index: translator/Parser/ParseNode.h
===================================================================
--- translator/Parser/ParseNode.h	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/ParseNode.h	(revision bdd516a5257cb93cc0c5b4a4c343cc112252022a)
@@ -2,5 +2,4 @@
 #define PARSENODE_H
 
-#include <iostream>
 #include <string>
 #include <list>
@@ -8,7 +7,5 @@
 
 #include "utility.h"
-#include "SynTree/SynTree.h"
 #include "SynTree/Declaration.h"
-#include "SemanticError.h"
 #include "UniqueName.h"
 
@@ -23,452 +20,440 @@
 // Builder
 class ParseNode {
-public:
-  ParseNode(void);
-  ParseNode (std::string);
-  virtual ~ParseNode(void);
-
-  ParseNode *set_name (std::string) ;
-  ParseNode *set_name (std::string *) ;
-
-  std::string get_name(void);
-
-  ParseNode *get_link(void) const;
-  ParseNode *get_last(void);
-  ParseNode *set_link(ParseNode *);
-  void set_next( ParseNode *newlink ) { next = newlink; }
-
-  virtual ParseNode *clone() const { return 0; };
-
-  const std::string get_name(void) const;
-  virtual void print( std::ostream &, int indent = 0 ) const;
-  virtual void printList( std::ostream &, int indent = 0 ) const;
-
-  ParseNode &operator,(ParseNode &);
-
-protected:
-  std::string name;
-  ParseNode *next;
-  static int indent_by;
-};
-
-ParseNode *mkList(ParseNode &);
+  public:
+    ParseNode( void );
+    ParseNode ( std::string );
+    virtual ~ParseNode( void );
+
+    ParseNode *set_name ( std::string ) ;
+    ParseNode *set_name ( std::string * ) ;
+
+    std::string get_name( void );
+
+    ParseNode *get_link( void ) const;
+    ParseNode *get_last( void );
+    ParseNode *set_link( ParseNode * );
+    void set_next( ParseNode *newlink ) { next = newlink; }
+
+    virtual ParseNode *clone() const { return 0; };
+
+    const std::string get_name( void ) const;
+    virtual void print( std::ostream &, int indent = 0 ) const;
+    virtual void printList( std::ostream &, int indent = 0 ) const;
+
+    ParseNode &operator,( ParseNode &);
+  protected:
+    std::string name;
+    ParseNode *next;
+    static int indent_by;
+};
+
+ParseNode *mkList( ParseNode & );
 
 class ExpressionNode : public ParseNode {
-public:
-  ExpressionNode();
-  ExpressionNode(std::string *);
-  ExpressionNode( const ExpressionNode &other );
-  virtual ~ExpressionNode() { /* can't delete asArgName because it might be referenced elsewhere */ };
-
-  virtual ExpressionNode *clone() const = 0;
-
-  virtual CommaExprNode *add_to_list(ExpressionNode *);
-
-  ExpressionNode *get_argName() const { return argName; }
-  ExpressionNode *set_asArgName( std::string *aName );
-  ExpressionNode *set_asArgName( ExpressionNode *aDesignator );
-
-  virtual void print(std::ostream &, int indent = 0) const = 0;
-  virtual void printOneLine(std::ostream &, int indent = 0) const = 0;
-
-  virtual Expression *build() const = 0;
-protected:
-  void printDesignation (std::ostream &, int indent = 0) const;
-
-private:
-  ExpressionNode *argName;
-};
-
-// NullExprNode is used in tuples as a place-holder where a tuple component is omitted
-// e.g., [ 2, , 3 ]
-class NullExprNode : public ExpressionNode
-{
-public:
-  NullExprNode();
-
-  virtual NullExprNode *clone() const;
-
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-
-  virtual Expression *build() const;
+  public:
+    ExpressionNode();
+    ExpressionNode( std::string * );
+    ExpressionNode( const ExpressionNode &other );
+    virtual ~ExpressionNode() { /* can't delete asArgName because it might be referenced elsewhere */ };
+
+    virtual ExpressionNode *clone() const = 0;
+
+    virtual CommaExprNode *add_to_list( ExpressionNode * );
+
+    ExpressionNode *get_argName() const { return argName; }
+    ExpressionNode *set_asArgName( std::string *aName );
+    ExpressionNode *set_asArgName( ExpressionNode *aDesignator );
+
+    virtual void print( std::ostream &, int indent = 0) const = 0;
+    virtual void printOneLine( std::ostream &, int indent = 0) const = 0;
+
+    virtual Expression *build() const = 0;
+  protected:
+    void printDesignation ( std::ostream &, int indent = 0) const;
+  private:
+    ExpressionNode *argName;
+};
+
+// NullExprNode is used in tuples as a place-holder where a tuple component is omitted e.g., [ 2, , 3 ]
+class NullExprNode : public ExpressionNode {
+  public:
+    NullExprNode();
+
+    virtual NullExprNode *clone() const;
+
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+
+    virtual Expression *build() const;
 };
 
 class ConstantNode : public ExpressionNode {
-public:
-  enum Type {
-    Integer, Float, Character, String /* , Range, EnumConstant  */
-  };
-
-  ConstantNode(void);
-  ConstantNode(std::string *);
-  ConstantNode(Type, std::string *);
-  ConstantNode( const ConstantNode &other );
-
-  virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
-
-  Type get_type(void) const ;
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-
-  std::string get_value() const { return value; }
-  ConstantNode *append( std::string *newValue );
-
-  Expression *build() const;
-
-private:
-  void classify(std::string &);
-  Type type;
-  std::string value;
-  bool sign;
-  short base;
-  int longs, size;
+  public:
+    enum Type {
+	Integer, Float, Character, String /* , Range, EnumConstant  */
+    };
+
+    ConstantNode( void );
+    ConstantNode( std::string * );
+    ConstantNode( Type, std::string * );
+    ConstantNode( const ConstantNode &other );
+
+    virtual ConstantNode *clone() const { return new ConstantNode( *this ); }
+
+    Type get_type( void ) const ;
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+
+    std::string get_value() const { return value; }
+    ConstantNode *append( std::string *newValue );
+
+    Expression *build() const;
+  private:
+    void classify( std::string &);
+    Type type;
+    std::string value;
+    bool sign;
+    short base;
+    int longs, size;
 };
 
 class VarRefNode : public ExpressionNode {
-public:
-  VarRefNode();
-  VarRefNode(std::string *, bool isLabel = false );
-  VarRefNode( const VarRefNode &other );
-
-  virtual Expression *build() const ;
-
-  virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
-
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-private:
-  bool isLabel;
-};
-
-class TypeValueNode : public ExpressionNode
-{
-public:
-  TypeValueNode(DeclarationNode *);
-  TypeValueNode( const TypeValueNode &other );
-
-  DeclarationNode *get_decl() const { return decl; }
-
-  virtual Expression *build() const ;
-
-  virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }
-
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-private:
-  DeclarationNode *decl;
+  public:
+    VarRefNode();
+    VarRefNode( std::string *, bool isLabel = false );
+    VarRefNode( const VarRefNode &other );
+
+    virtual Expression *build() const ;
+
+    virtual VarRefNode *clone() const { return new VarRefNode( *this ); }
+
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+  private:
+    bool isLabel;
+};
+
+class TypeValueNode : public ExpressionNode {
+  public:
+    TypeValueNode( DeclarationNode * );
+    TypeValueNode( const TypeValueNode &other );
+
+    DeclarationNode *get_decl() const { return decl; }
+
+    virtual Expression *build() const ;
+
+    virtual TypeValueNode *clone() const { return new TypeValueNode( *this ); }
+
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+  private:
+    DeclarationNode *decl;
 };
 
 class OperatorNode : public ExpressionNode {
-public:
-  enum Type { TupleC, Comma, TupleFieldSel,
-              Cond, NCond, 
-	      SizeOf, AlignOf, Attr, CompLit, Plus, Minus, Mul, Div, Mod, Or, And, 
+  public:
+    enum Type { TupleC, Comma, TupleFieldSel,
+		Cond, NCond, 
+		SizeOf, AlignOf, Attr, CompLit, Plus, Minus, Mul, Div, Mod, Or, And, 
 	        BitOr, BitAnd, Xor, Cast, LShift, RShift, LThan, GThan, LEThan, GEThan, Eq, Neq, 
 	        Assign, MulAssn, DivAssn, ModAssn, PlusAssn, MinusAssn, LSAssn, RSAssn, AndAssn, 
 	        ERAssn, OrAssn, Index, FieldSel, PFieldSel, Range,
-              UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress
-            };
-
-  OperatorNode(Type t);
-  OperatorNode( const OperatorNode &other );
-  virtual ~OperatorNode();
-
-  virtual OperatorNode *clone() const { return new OperatorNode( *this ); }
-
-  Type get_type(void) const;
-  std::string get_typename(void) const;
-
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-
-  virtual Expression *build() const { return 0; }
+		UnPlus, UnMinus, AddressOf, PointTo, Neg, BitNeg, Incr, IncrPost, Decr, DecrPost, LabelAddress
+    };
+
+    OperatorNode( Type t );
+    OperatorNode( const OperatorNode &other );
+    virtual ~OperatorNode();
+
+    virtual OperatorNode *clone() const { return new OperatorNode( *this ); }
+
+    Type get_type( void ) const;
+    std::string get_typename( void ) const;
+
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+
+    virtual Expression *build() const { return 0; }
+  private:
+    Type type;
+    static const char *OpName[];
+};
+
+
+class CompositeExprNode : public ExpressionNode {
+  public:
+    CompositeExprNode( void );
+    CompositeExprNode( std::string * );
+    CompositeExprNode( ExpressionNode *f, ExpressionNode *args = 0 );
+    CompositeExprNode( ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2 );
+    CompositeExprNode( const CompositeExprNode &other );
+    virtual ~CompositeExprNode();
+
+    virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
+    virtual Expression *build() const;
+
+    virtual void print( std::ostream &, int indent = 0) const;
+    virtual void printOneLine( std::ostream &, int indent = 0) const;
+
+    void set_function( ExpressionNode * );
+    void set_args( ExpressionNode * );
+
+    void add_arg( ExpressionNode * );
+
+    ExpressionNode *get_function() const;
+    ExpressionNode *get_args() const;
+  private:
+    ExpressionNode *function;
+    ExpressionNode *arguments;
+};
+
+class CommaExprNode : public CompositeExprNode {
+  public:
+    CommaExprNode();
+    CommaExprNode( ExpressionNode * );
+    CommaExprNode( ExpressionNode *, ExpressionNode * );
+    CommaExprNode( const CommaExprNode &other );
+
+    virtual CommaExprNode *add_to_list( ExpressionNode * );
+    virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); }
+};
+
+class ForCtlExprNode : public ExpressionNode {
+  public:
+    ForCtlExprNode( ParseNode *, ExpressionNode *, ExpressionNode * ) throw ( SemanticError );
+    ForCtlExprNode( const ForCtlExprNode &other );
+    ~ForCtlExprNode();
+
+    StatementNode *get_init() const { return init; }
+    ExpressionNode *get_condition() const { return condition; }
+    ExpressionNode *get_change() const { return change; }
+
+    virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); }
+    virtual Expression *build() const;
+
+    virtual void print( std::ostream &, int indent = 0 ) const;
+    virtual void printOneLine( std::ostream &, int indent = 0 ) const;
+  private:
+    StatementNode *init;
+    ExpressionNode *condition;
+    ExpressionNode *change;
+};
+
+class ValofExprNode : public ExpressionNode {
+  public:
+    ValofExprNode();
+    ValofExprNode( StatementNode *s = 0 );
+    ValofExprNode( const ValofExprNode &other );
+    ~ValofExprNode();
   
-private:
-  Type type;
-  static const char *OpName[];
-};
-
-
-class CompositeExprNode : public ExpressionNode {
-public:
-  CompositeExprNode(void);
-  CompositeExprNode(std::string *);
-  CompositeExprNode(ExpressionNode *f, ExpressionNode *args = 0);
-  CompositeExprNode(ExpressionNode *f, ExpressionNode *arg1, ExpressionNode *arg2);
-  CompositeExprNode( const CompositeExprNode &other );
-  virtual ~CompositeExprNode();
-
-  virtual CompositeExprNode *clone() const { return new CompositeExprNode( *this ); }
-  virtual Expression *build() const;
-
-  virtual void print(std::ostream &, int indent = 0) const;
-  virtual void printOneLine(std::ostream &, int indent = 0) const;
-
-  void set_function(ExpressionNode *);
-  void set_args(ExpressionNode *);
-
-  void add_arg(ExpressionNode *);
-
-  ExpressionNode *get_function() const;
-  ExpressionNode *get_args() const;
-
-private:
-  ExpressionNode *function;
-  ExpressionNode *arguments;
-};
-
-class CommaExprNode : public CompositeExprNode {
-public:
-  CommaExprNode();
-  CommaExprNode(ExpressionNode *);
-  CommaExprNode(ExpressionNode *, ExpressionNode *);
-  CommaExprNode( const CommaExprNode &other );
-
-  virtual CommaExprNode *add_to_list(ExpressionNode *);
-  virtual CommaExprNode *clone() const { return new CommaExprNode( *this ); }
-};
-
-class ForCtlExprNode : public ExpressionNode {
-public:
-  ForCtlExprNode(ParseNode *, ExpressionNode *, ExpressionNode *) throw (SemanticError);
-  ForCtlExprNode( const ForCtlExprNode &other );
-  ~ForCtlExprNode();
-
-  StatementNode *get_init() const { return init; }
-  ExpressionNode *get_condition() const { return condition; }
-  ExpressionNode *get_change() const { return change; }
-
-  virtual ForCtlExprNode *clone() const { return new ForCtlExprNode( *this ); }
-  virtual Expression *build() const;
-
-  virtual void print( std::ostream &, int indent = 0 ) const;
-  virtual void printOneLine( std::ostream &, int indent = 0 ) const;
-private:
-  StatementNode *init;
-  ExpressionNode *condition;
-  ExpressionNode *change;
-};
-
-class ValofExprNode : public ExpressionNode {
-public:
-  ValofExprNode();
-  ValofExprNode( StatementNode *s = 0 );
-  ValofExprNode( const ValofExprNode &other );
-  ~ValofExprNode();
-  
-  virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
-
-  StatementNode *get_body() const { return body; }
-  void print( std::ostream &, int indent = 0 ) const;
-  void printOneLine( std::ostream &, int indent = 0 ) const;
-  Expression *build() const;
-
-private:
-  StatementNode *body;
+    virtual ValofExprNode *clone() const { return new ValofExprNode( *this ); }
+
+    StatementNode *get_body() const { return body; }
+    void print( std::ostream &, int indent = 0 ) const;
+    void printOneLine( std::ostream &, int indent = 0 ) const;
+    Expression *build() const;
+
+  private:
+    StatementNode *body;
 };
 
 class TypeData;
 
-class DeclarationNode : public ParseNode
-{
-public:
-  enum Qualifier { Const, Restrict, Volatile, Lvalue };
-  enum StorageClass { Static, Auto, Extern, Register, Inline, Fortran };
-  enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
-  enum Modifier { Signed, Unsigned, Short, Long };
-  enum TyCon { Struct, Union, Context };
-  enum TypeClass { Type, Dtype, Ftype };
-
-  static const char *qualifierName[];
-  static const char *basicTypeName[];
-  static const char *modifierName[];
-  static const char *tyConName[];
-  static const char *typeClassName[];
-
-  static DeclarationNode *newFunction( std::string* name, DeclarationNode *ret, DeclarationNode *param,
-				       StatementNode *body, bool newStyle = false );
-  static DeclarationNode *newQualifier( Qualifier );
-  static DeclarationNode *newStorageClass( StorageClass );
-  static DeclarationNode *newBasicType( BasicType );
-  static DeclarationNode *newModifier( Modifier );
-  static DeclarationNode *newForall( DeclarationNode* );
-  static DeclarationNode *newFromTypedef( std::string* );
-  static DeclarationNode *newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields );
-  static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
-  static DeclarationNode *newEnumConstant( std::string* name, ExpressionNode *constant );
-  static DeclarationNode *newName( std::string* );
-  static DeclarationNode *newFromTypeGen( std::string*, ExpressionNode *params );
-  static DeclarationNode *newTypeParam( TypeClass, std::string* );
-  static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
-  static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params );
-  static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
-  static DeclarationNode *newPointer( DeclarationNode *qualifiers );
-  static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
-  static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
-  static DeclarationNode *newBitfield( ExpressionNode *size );
-  static DeclarationNode *newTuple( DeclarationNode *members );
-  static DeclarationNode *newTypeof( ExpressionNode *expr );
-  static DeclarationNode *newAttr( std::string*, ExpressionNode *expr );
-  static DeclarationNode *newAttr( std::string*, DeclarationNode *type );
-
-  DeclarationNode *addQualifiers( DeclarationNode* );
-  DeclarationNode *copyStorageClasses( DeclarationNode* );
-  DeclarationNode *addType( DeclarationNode* );
-  DeclarationNode *addTypedef();
-  DeclarationNode *addAssertions( DeclarationNode* );
-  DeclarationNode *addName( std::string* );
-  DeclarationNode *addBitfield( ExpressionNode *size );
-  DeclarationNode *addVarArgs();
-  DeclarationNode *addFunctionBody( StatementNode *body );
-  DeclarationNode *addOldDeclList( DeclarationNode *list );
-  DeclarationNode *addPointer( DeclarationNode *qualifiers );
-  DeclarationNode *addArray( DeclarationNode *array );
-  DeclarationNode *addNewPointer( DeclarationNode *pointer );
-  DeclarationNode *addNewArray( DeclarationNode *array );
-  DeclarationNode *addParamList( DeclarationNode *list );
-  DeclarationNode *addIdList( DeclarationNode *list );       // old-style functions
-  DeclarationNode *addInitializer( InitializerNode *init );
-
-  DeclarationNode *cloneType( std::string *newName );
-  DeclarationNode *cloneType( DeclarationNode *existing );
-  DeclarationNode *cloneType( int ) { return cloneType( (std::string*)0 ); }
-  DeclarationNode *cloneBaseType( std::string *newName );
-  DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
-
-  DeclarationNode *appendList( DeclarationNode * );
-
-  DeclarationNode *clone() const;
-  void print( std::ostream &, int indent = 0 ) const;
-  void printList( std::ostream &, int indent = 0 ) const;
-
-  Declaration *build() const;
-  ::Type *buildType() const;
-
-  bool get_hasEllipsis() const;
-  std::string get_name() const { return name; }
-  LinkageSpec::Type get_linkage() const { return linkage; }
-  DeclarationNode *extractAggregate() const;
-
-  DeclarationNode();
-  ~DeclarationNode();
-private:
-  Declaration::StorageClass buildStorageClass() const;
-  bool buildInline() const;
-
-  TypeData *type;
-  std::string name;
-  std::list< StorageClass > storageClasses;
-  ExpressionNode *bitfieldWidth;
-  InitializerNode *initializer;
-  bool hasEllipsis;
-  LinkageSpec::Type linkage;
-
-  static UniqueName anonymous;
+class DeclarationNode : public ParseNode {
+  public:
+    enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic };
+    enum StorageClass { Static, Auto, Extern, Register, Inline, Fortran };
+    enum BasicType { Char, Int, Float, Double, Void, Bool, Complex, Imaginary };
+    enum Modifier { Signed, Unsigned, Short, Long };
+    enum TyCon { Struct, Union, Context };
+    enum TypeClass { Type, Dtype, Ftype };
+
+    static const char *qualifierName[];
+    static const char *basicTypeName[];
+    static const char *modifierName[];
+    static const char *tyConName[];
+    static const char *typeClassName[];
+
+    static DeclarationNode *newFunction( std::string *name, DeclarationNode *ret, DeclarationNode *param,
+					 StatementNode *body, bool newStyle = false );
+    static DeclarationNode *newQualifier( Qualifier );
+    static DeclarationNode *newStorageClass( StorageClass );
+    static DeclarationNode *newBasicType( BasicType );
+    static DeclarationNode *newModifier( Modifier );
+    static DeclarationNode *newForall( DeclarationNode *);
+    static DeclarationNode *newFromTypedef( std::string *);
+    static DeclarationNode *newAggregate( TyCon kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields );
+    static DeclarationNode *newEnum( std::string *name, DeclarationNode *constants );
+    static DeclarationNode *newEnumConstant( std::string *name, ExpressionNode *constant );
+    static DeclarationNode *newName( std::string *);
+    static DeclarationNode *newFromTypeGen( std::string*, ExpressionNode *params );
+    static DeclarationNode *newTypeParam( TypeClass, std::string *);
+    static DeclarationNode *newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts );
+    static DeclarationNode *newContextUse( std::string *name, ExpressionNode *params );
+    static DeclarationNode *newTypeDecl( std::string *name, DeclarationNode *typeParams );
+    static DeclarationNode *newPointer( DeclarationNode *qualifiers );
+    static DeclarationNode *newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic );
+    static DeclarationNode *newVarArray( DeclarationNode *qualifiers );
+    static DeclarationNode *newBitfield( ExpressionNode *size );
+    static DeclarationNode *newTuple( DeclarationNode *members );
+    static DeclarationNode *newTypeof( ExpressionNode *expr );
+    static DeclarationNode *newAttr( std::string*, ExpressionNode *expr );
+    static DeclarationNode *newAttr( std::string*, DeclarationNode *type );
+
+    DeclarationNode *addQualifiers( DeclarationNode *);
+    DeclarationNode *copyStorageClasses( DeclarationNode *);
+    DeclarationNode *addType( DeclarationNode *);
+    DeclarationNode *addTypedef();
+    DeclarationNode *addAssertions( DeclarationNode *);
+    DeclarationNode *addName( std::string *);
+    DeclarationNode *addBitfield( ExpressionNode *size );
+    DeclarationNode *addVarArgs();
+    DeclarationNode *addFunctionBody( StatementNode *body );
+    DeclarationNode *addOldDeclList( DeclarationNode *list );
+    DeclarationNode *addPointer( DeclarationNode *qualifiers );
+    DeclarationNode *addArray( DeclarationNode *array );
+    DeclarationNode *addNewPointer( DeclarationNode *pointer );
+    DeclarationNode *addNewArray( DeclarationNode *array );
+    DeclarationNode *addParamList( DeclarationNode *list );
+    DeclarationNode *addIdList( DeclarationNode *list );       // old-style functions
+    DeclarationNode *addInitializer( InitializerNode *init );
+
+    DeclarationNode *cloneType( std::string *newName );
+    DeclarationNode *cloneType( DeclarationNode *existing );
+    DeclarationNode *cloneType( int ) { return cloneType( ( std::string *)0 ); }
+    DeclarationNode *cloneBaseType( std::string *newName );
+    DeclarationNode *cloneBaseType( DeclarationNode *newdecl );
+
+    DeclarationNode *appendList( DeclarationNode  *);
+
+    DeclarationNode *clone() const;
+    void print( std::ostream &, int indent = 0 ) const;
+    void printList( std::ostream &, int indent = 0 ) const;
+
+    Declaration *build() const;
+    ::Type *buildType() const;
+
+    bool get_hasEllipsis() const;
+    std::string get_name() const { return name; }
+    LinkageSpec::Type get_linkage() const { return linkage; }
+    DeclarationNode *extractAggregate() const;
+
+    DeclarationNode();
+    ~DeclarationNode();
+  private:
+    Declaration::StorageClass buildStorageClass() const;
+    bool buildInline() const;
+
+    TypeData *type;
+    std::string name;
+    std::list< StorageClass > storageClasses;
+    ExpressionNode *bitfieldWidth;
+    InitializerNode *initializer;
+    bool hasEllipsis;
+    LinkageSpec::Type linkage;
+
+    static UniqueName anonymous;
 };
 
 class StatementNode : public ParseNode {
-public:
-  enum Type { Exp,   If,        Switch,  Case,    Default,  Choose,   Fallthru, 
-              While, Do,        For,
-              Goto,  Continue,  Break,   Return,  Throw,
-              Try,   Catch,     Finally, Asm,
-	      Decl
-            };
-
-  StatementNode( void );
-  StatementNode( std::string );
-  StatementNode( Type, ExpressionNode *e = 0, StatementNode *s = 0 );
-  StatementNode( Type, std::string *target );
-  StatementNode( DeclarationNode *decl );
-
-
-  ~StatementNode(void);
-
-  static StatementNode * newCatchStmt(DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
-
-  void set_control(ExpressionNode *);
-  StatementNode * set_block(StatementNode *);
-
-  ExpressionNode *get_control() const ;
-  StatementNode *get_block() const;
-  StatementNode::Type get_type(void) const;
-
-  StatementNode *add_label(std::string *);
-  std::list<std::string> *get_labels() const;
-
-  void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
-  void setCatchRest( bool newVal ) { isCatchRest = newVal; }
-
-  std::string get_target() const;
-
-  StatementNode *add_controlexp(ExpressionNode *);
-  StatementNode *append_block(StatementNode *);
-  StatementNode *append_last_case(StatementNode *);
-
-  void print( std::ostream &, int indent = 0) const;
-
-  virtual StatementNode *clone() const;
-
-  virtual Statement *build() const;
-
-private:
-  static const char *StType[];
-  Type type;
-  ExpressionNode *control;
-  StatementNode *block;
-  std::list<std::string> *labels;
-  std::string *target; // target label for jump statements
-  DeclarationNode *decl;
-
-  bool isCatchRest;
+  public:
+    enum Type { Exp,   If,        Switch,  Case,    Default,  Choose,   Fallthru, 
+		While, Do,        For,
+		Goto,  Continue,  Break,   Return,  Throw,
+		Try,   Catch,     Finally, Asm,
+		Decl
+    };
+
+    StatementNode( void );
+    StatementNode( std::string );
+    StatementNode( Type, ExpressionNode *e = 0, StatementNode *s = 0 );
+    StatementNode( Type, std::string *target );
+    StatementNode( DeclarationNode *decl );
+
+
+    ~StatementNode( void );
+
+    static StatementNode  *newCatchStmt( DeclarationNode *d = 0, StatementNode *s = 0, bool catchRestP = false );
+
+    void set_control( ExpressionNode * );
+    StatementNode * set_block( StatementNode * );
+
+    ExpressionNode *get_control() const ;
+    StatementNode *get_block() const;
+    StatementNode::Type get_type( void ) const;
+
+    StatementNode *add_label( std::string * );
+    std::list<std::string> *get_labels() const;
+
+    void addDeclaration( DeclarationNode *newDecl ) { decl = newDecl; }
+    void setCatchRest( bool newVal ) { isCatchRest = newVal; }
+
+    std::string get_target() const;
+
+    StatementNode *add_controlexp( ExpressionNode * );
+    StatementNode *append_block( StatementNode * );
+    StatementNode *append_last_case( StatementNode * );
+
+    void print( std::ostream &, int indent = 0) const;
+
+    virtual StatementNode *clone() const;
+
+    virtual Statement *build() const;
+  private:
+    static const char *StType[];
+    Type type;
+    ExpressionNode *control;
+    StatementNode *block;
+    std::list<std::string> *labels;
+    std::string *target;				// target label for jump statements
+    DeclarationNode *decl;
+
+    bool isCatchRest;
 };
 
 class CompoundStmtNode : public StatementNode {
-public:
-  CompoundStmtNode(void);
-  CompoundStmtNode(std::string *);
-  CompoundStmtNode(StatementNode *);
-  ~CompoundStmtNode();
-
-  void add_statement(StatementNode *);
-
-  void print( std::ostream &, int indent = 0 ) const;
-
-  virtual Statement *build() const;
-
-private:
-  StatementNode *first, *last;
+  public:
+    CompoundStmtNode( void );
+    CompoundStmtNode( std::string * );
+    CompoundStmtNode( StatementNode * );
+    ~CompoundStmtNode();
+
+    void add_statement( StatementNode * );
+
+    void print( std::ostream &, int indent = 0 ) const;
+
+    virtual Statement *build() const;
+  private:
+    StatementNode *first, *last;
 };
 
 class NullStmtNode : public CompoundStmtNode {
-public:
-  Statement *build() const;
-  void print(std::ostream &, int indent = 0) const;
+  public:
+    Statement *build() const;
+    void print( std::ostream &, int indent = 0) const;
 };
 
 class InitializerNode : public ParseNode {
-public:
-  InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
-  InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
-  ~InitializerNode();
-
-  ExpressionNode *get_expression() const { return expr; }
-
-  InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
-  ExpressionNode *get_designators() const { return designator; }
-
-  InitializerNode *next_init() const { return kids; }
-
-  void print( std::ostream &, int indent = 0 ) const;
-  void printOneLine( std::ostream & ) const;
-
-  virtual Initializer *build() const;
-
-private:
-  ExpressionNode *expr;
-  bool aggregate;
-  ExpressionNode *designator; // may be list
-  InitializerNode *kids;
+  public:
+    InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode *des = 0 );
+    InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode *des = 0 );
+    ~InitializerNode();
+
+    ExpressionNode *get_expression() const { return expr; }
+
+    InitializerNode *set_designators( ExpressionNode *des ) { designator = des; return this; }
+    ExpressionNode *get_designators() const { return designator; }
+
+    InitializerNode *next_init() const { return kids; }
+
+    void print( std::ostream &, int indent = 0 ) const;
+    void printOneLine( std::ostream & ) const;
+
+    virtual Initializer *build() const;
+  private:
+    ExpressionNode *expr;
+    bool aggregate;
+    ExpressionNode *designator; // may be list
+    InitializerNode *kids;
 };
 
@@ -477,31 +462,31 @@
 template< typename SynTreeType, typename NodeType >
 void
-buildList( const NodeType *firstNode, std::list< SynTreeType* > &outputList )
+buildList( const NodeType *firstNode, std::list< SynTreeType *> &outputList )
 {
-  SemanticError errors;
-  std::back_insert_iterator< std::list< SynTreeType* > > out( outputList );
-  const NodeType *cur = firstNode;
-
-  while( cur ) {
-    try {
-      SynTreeType *result = dynamic_cast< SynTreeType* >( cur->build() );
-      if( result ) {
-        *out++ = result;
-      } else {
-      }
-    } catch( SemanticError &e ) {
-      errors.append( e );
-    }
-    cur = dynamic_cast< NodeType* >( cur->get_link() );
-  }
-  if( !errors.isEmpty() ) {
-    throw errors;
-  }
+    SemanticError errors;
+    std::back_insert_iterator< std::list< SynTreeType *> > out( outputList );
+    const NodeType *cur = firstNode;
+
+    while ( cur ) {
+	try {
+	    SynTreeType *result = dynamic_cast< SynTreeType *>( cur->build() );
+	    if ( result ) {
+		*out++ = result;
+	    } else {
+	    } // if
+	} catch( SemanticError &e ) {
+	    errors.append( e );
+	} // try
+	cur = dynamic_cast< NodeType *>( cur->get_link() );
+    } // while
+    if ( !errors.isEmpty() ) {
+	throw errors;
+    } // if
 }
 
 // in DeclarationNode.cc
-void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList );
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList );
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList );
+void buildList( const DeclarationNode *firstNode, std::list< Declaration *> &outputList );
+void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList );
+void buildTypeList( const DeclarationNode *firstNode, std::list< Type *> &outputList );
 
 // in ExpressionNode.cc
@@ -509,5 +494,5 @@
 ExpressionNode *tupleContents( ExpressionNode *tuple );
 
-#endif /* #ifndef PARSENODE_H */
+#endif // PARSENODE_H
 
 // Local Variables: //
Index: translator/Parser/TypeData.cc
===================================================================
--- translator/Parser/TypeData.cc	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/TypeData.cc	(revision bdd516a5257cb93cc0c5b4a4c343cc112252022a)
@@ -541,4 +541,7 @@
 	  case DeclarationNode::Lvalue:
 	    q.isLvalue = true;
+	    break;
+	  case DeclarationNode::Atomic:
+	    q.isAtomic = true;
 	    break;
 	}
Index: translator/Parser/TypeData.h
===================================================================
--- translator/Parser/TypeData.h	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/TypeData.h	(revision bdd516a5257cb93cc0c5b4a4c343cc112252022a)
@@ -3,10 +3,7 @@
 
 #include <list>
+
 #include "ParseNode.h"
-#include "SynTree/SynTree.h"
 #include "SynTree/Type.h"
-#include "SynTree/Declaration.h"
-#include "SemanticError.h"
-#include "LinkageSpec.h"
 
 struct TypeData {
Index: translator/Parser/cfa.y
===================================================================
--- translator/Parser/cfa.y	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/cfa.y	(revision bdd516a5257cb93cc0c5b4a4c343cc112252022a)
@@ -10,6 +10,6 @@
  * Created On       : Sat Sep  1 20:22:55 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Sat Jan 17 09:23:45 2015
- * Update Count     : 908
+ * Last Modified On : Wed Apr 15 15:11:16 2015
+ * Update Count     : 913
  */
 
@@ -1144,5 +1144,5 @@
 	declaration_specifier declarator asm_name_opt initializer_opt
 		{
-			typedefTable.addToEnclosingScope( TypedefTable::ID);
+			typedefTable.addToEnclosingScope( TypedefTable::ID );
 			$$ = ($2->addType( $1 ))->addInitializer($4);
 		}
@@ -1201,4 +1201,6 @@
 	| LVALUE					/* CFA */
 		{ $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
+	| ATOMIC
+		{ $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
 	| FORALL '(' 
 		{
Index: translator/Parser/parseutility.cc
===================================================================
--- translator/Parser/parseutility.cc	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/parseutility.cc	(revision bdd516a5257cb93cc0c5b4a4c343cc112252022a)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: parseutility.cc,v 1.2 2005/08/29 20:14:15 rcbilson Exp $
- *
- */
-
 #include "parseutility.h"
 #include "SynTree/Type.h"
@@ -11,7 +4,5 @@
 
 
-Expression *
-notZeroExpr( Expression *orig )
-{
+Expression *notZeroExpr( Expression *orig ) {
       UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) );
       comparison->get_args().push_back( orig );
Index: translator/Parser/parseutility.h
===================================================================
--- translator/Parser/parseutility.h	(revision 2c2242c773dd4781ea54f277dace24b26fca305e)
+++ translator/Parser/parseutility.h	(revision bdd516a5257cb93cc0c5b4a4c343cc112252022a)
@@ -1,9 +1,2 @@
-/*
- * This file is part of the Cforall project
- *
- * $Id: parseutility.h,v 1.2 2005/08/29 20:14:15 rcbilson Exp $
- *
- */
-
 #ifndef PARSER_PARSEUTILITY_H
 #define PARSER_PARSEUTILITY_H
@@ -13,3 +6,3 @@
 Expression *notZeroExpr( Expression *orig );
 
-#endif /* #ifndef PARSER_PARSEUTILITY_H */
+#endif // PARSER_PARSEUTILITY_H