Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 3b5e3aa51253132ef5997e89adcb625c6e88b6ae)
+++ src/Parser/DeclarationNode.cc	(revision 7e1077328aef0bbffbe33b1a3ff3feea08603b66)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Sep 24 11:12:52 2016
-// Update Count     : 627
+// Last Modified On : Mon Sep 26 22:18:40 2016
+// Update Count     : 640
 //
 
@@ -92,6 +92,6 @@
 
 	newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
+	newnode->variable.tyClass = variable.tyClass;
 	newnode->variable.assertions = maybeClone( variable.assertions );
-	newnode->variable.tyClass = variable.tyClass;
 
 	newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
@@ -148,8 +148,7 @@
 }
 
-DeclarationNode * DeclarationNode::newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) {
+DeclarationNode * DeclarationNode::newFunction( string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->name = name;
-
 	newnode->type = new TypeData( TypeData::Function );
 	newnode->type->function.params = param;
@@ -222,8 +221,8 @@
 } // DeclarationNode::newLength
 
-DeclarationNode * DeclarationNode::newFromTypedef( std::string * name ) {
+DeclarationNode * DeclarationNode::newFromTypedef( string * name ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::SymbolicInst );
-	newnode->type->symbolic.name = name ? new string( *name ) : nullptr;
+	newnode->type->symbolic.name = name;
 	newnode->type->symbolic.isTypedef = true;
 	newnode->type->symbolic.params = nullptr;
@@ -231,10 +230,10 @@
 } // DeclarationNode::newFromTypedef
 
-DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
+DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Aggregate );
 	newnode->type->aggregate.kind = kind;
 	if ( name ) {
-		newnode->type->aggregate.name = new string( *name );
+		newnode->type->aggregate.name = name;
 	} else {											// anonymous aggregate ?
 		newnode->type->aggregate.name = new string( anonymous.newName() );
@@ -246,10 +245,9 @@
 } // DeclarationNode::newAggregate
 
-DeclarationNode * DeclarationNode::newEnum( std::string * name, DeclarationNode * constants ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->name = name;
+DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants ) {
+	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Enum );
 	if ( name ) {
-		newnode->type->enumeration.name = new string( *name );
+		newnode->type->enumeration.name = name;
 	} else {											// anonymous aggregate ?
 		newnode->type->enumeration.name = new string( anonymous.newName() );
@@ -259,5 +257,5 @@
 } // DeclarationNode::newEnum
 
-DeclarationNode * DeclarationNode::newEnumConstant( std::string * name, ExpressionNode * constant ) {
+DeclarationNode * DeclarationNode::newEnumConstant( string * name, ExpressionNode * constant ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->name = name;
@@ -267,5 +265,5 @@
 } // DeclarationNode::newEnumConstant
 
-DeclarationNode * DeclarationNode::newName( std::string * name ) {
+DeclarationNode * DeclarationNode::newName( string * name ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->name = name;
@@ -273,8 +271,8 @@
 } // DeclarationNode::newName
 
-DeclarationNode * DeclarationNode::newFromTypeGen( std::string * name, ExpressionNode * params ) {
+DeclarationNode * DeclarationNode::newFromTypeGen( string * name, ExpressionNode * params ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::SymbolicInst );
-	newnode->type->symbolic.name = name ? new string( *name ) : nullptr;
+	newnode->type->symbolic.name = name;
 	newnode->type->symbolic.isTypedef = false;
 	newnode->type->symbolic.actuals = params;
@@ -282,15 +280,13 @@
 } // DeclarationNode::newFromTypeGen
 
-DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, std::string * name ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->name = name;
-//	newnode->type = new TypeData( TypeData::Variable );
+DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, string * name ) {
+	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = nullptr;
 	newnode->variable.tyClass = tc;
-	newnode->variable.name = newnode->name ? new string( *newnode->name ) : nullptr;
+	newnode->variable.name = name;
 	return newnode;
 } // DeclarationNode::newTypeParam
 
-DeclarationNode * DeclarationNode::newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts ) {
+DeclarationNode * DeclarationNode::newTrait( const string * name, DeclarationNode * params, DeclarationNode * asserts ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Aggregate );
@@ -302,5 +298,5 @@
 } // DeclarationNode::newTrait
 
-DeclarationNode * DeclarationNode::newTraitUse( const std::string * name, ExpressionNode * params ) {
+DeclarationNode * DeclarationNode::newTraitUse( const string * name, ExpressionNode * params ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::AggregateInst );
@@ -312,11 +308,10 @@
 } // DeclarationNode::newTraitUse
 
-DeclarationNode * DeclarationNode::newTypeDecl( std::string * name, DeclarationNode * typeParams ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->name = name;
+DeclarationNode * DeclarationNode::newTypeDecl( string * name, DeclarationNode * typeParams ) {
+	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Symbolic );
 	newnode->type->symbolic.isTypedef = false;
 	newnode->type->symbolic.params = typeParams;
-	newnode->type->symbolic.name = newnode->name;
+	newnode->type->symbolic.name = name;
 	return newnode;
 } // DeclarationNode::newTypeDecl
@@ -377,7 +372,6 @@
 } // DeclarationNode::newBuiltinType
 
-DeclarationNode * DeclarationNode::newAttr( std::string * name, ExpressionNode * expr ) {
-	DeclarationNode * newnode = new DeclarationNode;
-//	newnode->type = new TypeData( TypeData::Attr );
+DeclarationNode * DeclarationNode::newAttr( string * name, ExpressionNode * expr ) {
+	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = nullptr;
 	newnode->attr.name = name;
@@ -386,7 +380,6 @@
 }
 
-DeclarationNode * DeclarationNode::newAttr( std::string * name, DeclarationNode * type ) {
-	DeclarationNode * newnode = new DeclarationNode;
-//	newnode->type = new TypeData( TypeData::Attr );
+DeclarationNode * DeclarationNode::newAttr( string * name, DeclarationNode * type ) {
+	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = nullptr;
 	newnode->attr.name = name;
@@ -520,15 +513,15 @@
 					dst->basictype = src->basictype;
 				} else if ( src->basictype != DeclarationNode::NoBasicType )
-					throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
+					throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
 
 				if ( dst->complextype == DeclarationNode::NoComplexType ) {
 					dst->complextype = src->complextype;
 				} else if ( src->complextype != DeclarationNode::NoComplexType )
-					throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
+					throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
 
 				if ( dst->signedness == DeclarationNode::NoSignedness ) {
 					dst->signedness = src->signedness;
 				} else if ( src->signedness != DeclarationNode::NoSignedness )
-					throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
+					throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
 
 				if ( dst->length == DeclarationNode::NoLength ) {
@@ -537,5 +530,5 @@
 					dst->length = DeclarationNode::LongLong;
 				} else if ( src->length != DeclarationNode::NoLength )
-					throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
+					throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
 			} // if
 			break;
@@ -643,5 +636,5 @@
 }
 
-DeclarationNode * DeclarationNode::addName( std::string * newname ) {
+DeclarationNode * DeclarationNode::addName( string * newname ) {
 	assert( ! name );
 	name = newname;