Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 1b7727498168639c89eefe42fd1a1772a41b30d1)
+++ src/Parser/DeclarationNode.cc	(revision 2298f728513aa541b29ac43ced6409a7bde8e38c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep 16 18:17:16 2016
-// Update Count     : 527
+// Last Modified On : Sat Sep 24 11:12:52 2016
+// Update Count     : 627
 //
 
@@ -46,16 +46,19 @@
 
 DeclarationNode::DeclarationNode() :
-		type( 0 ),
+		type( nullptr ),
 		storageClass( NoStorageClass ),
 		isInline( false ),
 		isNoreturn( false ),
-		bitfieldWidth( 0 ),
-		initializer( 0 ),
+		bitfieldWidth( nullptr ),
+		initializer( nullptr ),
 		hasEllipsis( false ),
 		linkage( ::linkage ),
 		extension( false ) {
+
+	variable.name = nullptr;
 	variable.tyClass = DeclarationNode::Otype;
 	variable.assertions = nullptr;
 
+	attr.name = nullptr;
 	attr.expr = nullptr;
 	attr.type = nullptr;
@@ -63,6 +66,11 @@
 
 DeclarationNode::~DeclarationNode() {
+	delete attr.name;
 	delete attr.expr;
 	delete attr.type;
+
+	delete variable.name;
+	delete variable.assertions;
+
 	delete type;
 	delete bitfieldWidth;
@@ -73,5 +81,5 @@
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = maybeClone( type );
-	newnode->name = name;
+	newnode->name = name ? new string( *name ) : nullptr;
 	newnode->storageClass = storageClass;
 	newnode->isInline = isInline;
@@ -83,8 +91,9 @@
 	newnode->linkage = linkage;
 
+	newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
 	newnode->variable.assertions = maybeClone( variable.assertions );
-	newnode->variable.name = variable.name;
 	newnode->variable.tyClass = variable.tyClass;
 
+	newnode->attr.name = attr.name ? new string( *attr.name ) : nullptr;
 	newnode->attr.expr = maybeClone( attr.expr );
 	newnode->attr.type = maybeClone( attr.type );
@@ -98,8 +107,8 @@
 void DeclarationNode::print( std::ostream &os, int indent ) const {
 	os << string( indent, ' ' );
-	if ( name == "" ) {
+	if ( name ) {
+		os << *name << ": ";
+	} else {
 		os << "unnamed: ";
-	} else {
-		os << name << ": ";
 	} // if
 
@@ -122,5 +131,5 @@
 	} // if
 
-	if ( initializer != 0 ) {
+	if ( initializer ) {
 		os << endl << string( indent + 2, ' ' ) << "with initializer ";
 		initializer->printOneLine( os );
@@ -141,5 +150,5 @@
 DeclarationNode * DeclarationNode::newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle ) {
 	DeclarationNode * newnode = new DeclarationNode;
-	newnode->name = assign_strptr( name );
+	newnode->name = name;
 
 	newnode->type = new TypeData( TypeData::Function );
@@ -147,5 +156,8 @@
 	newnode->type->function.newStyle = newStyle;
 	newnode->type->function.body = body;
-	typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
+	// ignore unnamed routine declarations: void p( int (*)(int) );
+	if ( newnode->name ) {
+		typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
+	} // if
 
 	if ( body ) {
@@ -155,5 +167,5 @@
 	if ( ret ) {
 		newnode->type->base = ret->type;
-		ret->type = 0;
+		ret->type = nullptr;
 		delete ret;
 	} // if
@@ -213,7 +225,7 @@
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::SymbolicInst );
-	newnode->type->symbolic.name = assign_strptr( name );
+	newnode->type->symbolic.name = name ? new string( *name ) : nullptr;
 	newnode->type->symbolic.isTypedef = true;
-	newnode->type->symbolic.params = 0;
+	newnode->type->symbolic.params = nullptr;
 	return newnode;
 } // DeclarationNode::newFromTypedef
@@ -223,7 +235,8 @@
 	newnode->type = new TypeData( TypeData::Aggregate );
 	newnode->type->aggregate.kind = kind;
-	newnode->type->aggregate.name = assign_strptr( name );
-	if ( newnode->type->aggregate.name == "" ) {		// anonymous aggregate ?
-		newnode->type->aggregate.name = anonymous.newName();
+	if ( name ) {
+		newnode->type->aggregate.name = new string( *name );
+	} else {											// anonymous aggregate ?
+		newnode->type->aggregate.name = new string( anonymous.newName() );
 	} // if
 	newnode->type->aggregate.actuals = actuals;
@@ -235,9 +248,10 @@
 DeclarationNode * DeclarationNode::newEnum( std::string * name, DeclarationNode * constants ) {
 	DeclarationNode * newnode = new DeclarationNode;
-	newnode->name = assign_strptr( name );
+	newnode->name = name;
 	newnode->type = new TypeData( TypeData::Enum );
-	newnode->type->enumeration.name = newnode->name;
-	if ( newnode->type->enumeration.name == "" ) {		// anonymous enumeration ?
-		newnode->type->enumeration.name = DeclarationNode::anonymous.newName();
+	if ( name ) {
+		newnode->type->enumeration.name = new string( *name );
+	} else {											// anonymous aggregate ?
+		newnode->type->enumeration.name = new string( anonymous.newName() );
 	} // if
 	newnode->type->enumeration.constants = constants;
@@ -247,7 +261,7 @@
 DeclarationNode * DeclarationNode::newEnumConstant( std::string * name, ExpressionNode * constant ) {
 	DeclarationNode * newnode = new DeclarationNode;
-	newnode->name = assign_strptr( name );
+	newnode->name = name;
 	newnode->enumeratorValue.reset( constant );
-	typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
+	typedefTable.addToEnclosingScope( *newnode->name, TypedefTable::ID );
 	return newnode;
 } // DeclarationNode::newEnumConstant
@@ -255,5 +269,5 @@
 DeclarationNode * DeclarationNode::newName( std::string * name ) {
 	DeclarationNode * newnode = new DeclarationNode;
-	newnode->name = assign_strptr( name );
+	newnode->name = name;
 	return newnode;
 } // DeclarationNode::newName
@@ -262,5 +276,5 @@
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::SymbolicInst );
-	newnode->type->symbolic.name = assign_strptr( name );
+	newnode->type->symbolic.name = name ? new string( *name ) : nullptr;
 	newnode->type->symbolic.isTypedef = false;
 	newnode->type->symbolic.actuals = params;
@@ -270,28 +284,28 @@
 DeclarationNode * DeclarationNode::newTypeParam( TypeClass tc, std::string * name ) {
 	DeclarationNode * newnode = new DeclarationNode;
-	newnode->name = assign_strptr( name );
-	newnode->type = new TypeData( TypeData::Variable );
-//	newnode->type = nullptr;
+	newnode->name = name;
+//	newnode->type = new TypeData( TypeData::Variable );
+	newnode->type = nullptr;
 	newnode->variable.tyClass = tc;
-	newnode->variable.name = newnode->name;
+	newnode->variable.name = newnode->name ? new string( *newnode->name ) : nullptr;
 	return newnode;
 } // DeclarationNode::newTypeParam
 
-DeclarationNode * DeclarationNode::newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts ) {
+DeclarationNode * DeclarationNode::newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Aggregate );
+	newnode->type->aggregate.name = name;
 	newnode->type->aggregate.kind = Trait;
 	newnode->type->aggregate.params = params;
 	newnode->type->aggregate.fields = asserts;
-	newnode->type->aggregate.name = assign_strptr( name );
 	return newnode;
 } // DeclarationNode::newTrait
 
-DeclarationNode * DeclarationNode::newTraitUse( std::string * name, ExpressionNode * params ) {
+DeclarationNode * DeclarationNode::newTraitUse( const std::string * name, ExpressionNode * params ) {
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::AggregateInst );
 	newnode->type->aggInst.aggregate = new TypeData( TypeData::Aggregate );
 	newnode->type->aggInst.aggregate->aggregate.kind = Trait;
-	newnode->type->aggInst.aggregate->aggregate.name = assign_strptr( name );
+	newnode->type->aggInst.aggregate->aggregate.name = name;
 	newnode->type->aggInst.params = params;
 	return newnode;
@@ -300,5 +314,5 @@
 DeclarationNode * DeclarationNode::newTypeDecl( std::string * name, DeclarationNode * typeParams ) {
 	DeclarationNode * newnode = new DeclarationNode;
-	newnode->name = assign_strptr( name );
+	newnode->name = name;
 	newnode->type = new TypeData( TypeData::Symbolic );
 	newnode->type->symbolic.isTypedef = false;
@@ -319,5 +333,5 @@
 	newnode->type->array.dimension = size;
 	newnode->type->array.isStatic = isStatic;
-	if ( newnode->type->array.dimension == 0 || newnode->type->array.dimension->isExpressionType<ConstantExpr * >() ) {
+	if ( newnode->type->array.dimension == nullptr || newnode->type->array.dimension->isExpressionType<ConstantExpr * >() ) {
 		newnode->type->array.isVarLen = false;
 	} else {
@@ -330,5 +344,5 @@
 	DeclarationNode * newnode = new DeclarationNode;
 	newnode->type = new TypeData( TypeData::Array );
-	newnode->type->array.dimension = 0;
+	newnode->type->array.dimension = nullptr;
 	newnode->type->array.isStatic = false;
 	newnode->type->array.isVarLen = true;
@@ -365,7 +379,7 @@
 DeclarationNode * DeclarationNode::newAttr( std::string * name, ExpressionNode * expr ) {
 	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Attr );
-//	newnode->type = nullptr;
-	newnode->attr.name = assign_strptr( name );
+//	newnode->type = new TypeData( TypeData::Attr );
+	newnode->type = nullptr;
+	newnode->attr.name = name;
 	newnode->attr.expr = expr;
 	return newnode;
@@ -374,7 +388,7 @@
 DeclarationNode * DeclarationNode::newAttr( std::string * name, DeclarationNode * type ) {
 	DeclarationNode * newnode = new DeclarationNode;
-	newnode->type = new TypeData( TypeData::Attr );
-//	newnode->type = nullptr;
-	newnode->attr.name = assign_strptr( name );
+//	newnode->type = new TypeData( TypeData::Attr );
+	newnode->type = nullptr;
+	newnode->attr.name = name;
 	newnode->attr.type = type;
 	return newnode;
@@ -429,5 +443,5 @@
 			dst->forall = src->forall;
 		} // if
-		src->forall = 0;
+		src->forall = nullptr;
 	} // if
 	if ( dst->base ) {
@@ -435,5 +449,5 @@
 	} else if ( dst->kind == TypeData::Function ) {
 		dst->base = src;
-		src = 0;
+		src = nullptr;
 	} else {
 		dst->qualifiers |= src->qualifiers;
@@ -442,5 +456,5 @@
 
 DeclarationNode * DeclarationNode::addQualifiers( DeclarationNode * q ) {
-	if ( ! q ) return this;
+	if ( ! q ) { delete q; return this; }
 
 	checkStorageClasses( q );
@@ -469,10 +483,10 @@
 				type->aggregate.params = q->type->forall;
 				// change implicit typedef from TYPEDEFname to TYPEGENname
-				typedefTable.changeKind( type->aggregate.name, TypedefTable::TG );
+				typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG );
 			} else {
 				type->forall = q->type->forall;
 			} // if
 		} // if
-		q->type->forall = 0;
+		q->type->forall = nullptr;
 	} // if
 	delete q;
@@ -487,5 +501,5 @@
 			dst->forall = src->forall;
 		} // if
-		src->forall = 0;
+		src->forall = nullptr;
 	} // if
 	if ( dst->base ) {
@@ -496,5 +510,5 @@
 			src->qualifiers |= dst->qualifiers;
 			dst = src;
-			src = 0;
+			src = nullptr;
 			break;
 		  case TypeData::Basic:
@@ -536,5 +550,5 @@
 				} // if
 				dst->base->qualifiers |= src->qualifiers;
-				src = 0;
+				src = nullptr;
 				break;
 			  default:
@@ -544,7 +558,7 @@
 					dst->forall = src->forall;
 				} // if
-				src->forall = 0;
+				src->forall = nullptr;
 				dst->base = src;
-				src = 0;
+				src = nullptr;
 			} // switch
 		} // switch
@@ -568,5 +582,5 @@
 					type = o->type;
 				} // if
-				o->type = 0;
+				o->type = nullptr;
 			} else {
 				addTypeToType( o->type, type );
@@ -588,7 +602,7 @@
 DeclarationNode * DeclarationNode::addTypedef() {
 	TypeData * newtype = new TypeData( TypeData::Symbolic );
-	newtype->symbolic.params = 0;
+	newtype->symbolic.params = nullptr;
 	newtype->symbolic.isTypedef = true;
-	newtype->symbolic.name = name;
+	newtype->symbolic.name = name ? new string( *name ) : nullptr;
 	newtype->base = type;
 	type = newtype;
@@ -597,4 +611,13 @@
 
 DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
+	if ( variable.name ) {
+	  	if ( variable.assertions ) {
+	  		variable.assertions->appendList( assertions );
+	  	} else {
+	  		variable.assertions = assertions;
+	  	} // if
+	  	return this;
+	} // if
+
 	assert( type );
 	switch ( type->kind ) {
@@ -606,11 +629,11 @@
 		} // if
 		break;
-	  case TypeData::Variable:
-		if ( variable.assertions ) {
-			variable.assertions->appendList( assertions );
-		} else {
-			variable.assertions = assertions;
-		} // if
-		break;
+	  // case TypeData::Variable:
+	  // 	if ( variable.assertions ) {
+	  // 		variable.assertions->appendList( assertions );
+	  // 	} else {
+	  // 		variable.assertions = assertions;
+	  // 	} // if
+	  // 	break;
 	  default:
 		assert( false );
@@ -621,5 +644,6 @@
 
 DeclarationNode * DeclarationNode::addName( std::string * newname ) {
-	name = assign_strptr( newname );
+	assert( ! name );
+	name = newname;
 	return this;
 }
@@ -639,5 +663,5 @@
 	assert( type );
 	assert( type->kind == TypeData::Function );
-	assert( type->function.body == 0 );
+	assert( ! type->function.body );
 	type->function.body = body;
 	type->function.hasBody = true;
@@ -648,5 +672,5 @@
 	assert( type );
 	assert( type->kind == TypeData::Function );
-	assert( type->function.oldDeclList == 0 );
+	assert( ! type->function.oldDeclList );
 	type->function.oldDeclList = list;
 	return this;
@@ -657,5 +681,5 @@
 		TypeData * prevBase = type;
 		TypeData * curBase = type->base;
-		while ( curBase != 0 ) {
+		while ( curBase != nullptr ) {
 			prevBase = curBase;
 			curBase = curBase->base;
@@ -671,5 +695,5 @@
 		assert( p->type->kind == TypeData::Pointer );
 		setBase( type, p->type );
-		p->type = 0;
+		p->type = nullptr;
 		delete p;
 	} // if
@@ -681,5 +705,5 @@
 		assert( a->type->kind == TypeData::Array );
 		setBase( type, a->type );
-		a->type = 0;
+		a->type = nullptr;
 		delete a;
 	} // if
@@ -705,5 +729,5 @@
 				p->type->base = type;
 			} // switch
-			type = 0;
+			type = nullptr;
 		} // if
 		delete this;
@@ -741,5 +765,5 @@
 				lastArray->base = type;
 			} // switch
-			type = 0;
+			type = nullptr;
 		} // if
 		delete this;
@@ -770,5 +794,5 @@
 		return newtype;
 	} // if
-}
+} // addIdListToType
 
 DeclarationNode * DeclarationNode::addIdList( DeclarationNode * ids ) {
@@ -778,64 +802,6 @@
 
 DeclarationNode * DeclarationNode::addInitializer( InitializerNode * init ) {
-	//assert
 	initializer = init;
 	return this;
-}
-
-DeclarationNode * DeclarationNode::cloneBaseType( string * newName ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	TypeData * srcType = type;
-	while ( srcType->base ) {
-		srcType = srcType->base;
-	} // while
-	newnode->type = maybeClone( srcType );
-	if ( newnode->type->kind == TypeData::AggregateInst ) {
-		// don't duplicate members
-		if ( newnode->type->aggInst.aggregate->kind == TypeData::Enum ) {
-			delete newnode->type->aggInst.aggregate->enumeration.constants;
-			newnode->type->aggInst.aggregate->enumeration.constants = 0;
-		} else {
-			assert( newnode->type->aggInst.aggregate->kind == TypeData::Aggregate );
-			delete newnode->type->aggInst.aggregate->aggregate.fields;
-			newnode->type->aggInst.aggregate->aggregate.fields = 0;
-		} // if
-	} // if
-	newnode->type->forall = maybeClone( type->forall );
-	assert( storageClass == NoStorageClass );
-	newnode->copyStorageClasses( this );
-	newnode->name = assign_strptr( newName );
-	return newnode;
-}
-
-DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o ) {
-	if ( o ) {
-		o->copyStorageClasses( this );
-		if ( type ) {
-			TypeData * srcType = type;
-			while ( srcType->base ) {
-				srcType = srcType->base;
-			} // while
-			TypeData * newType = srcType->clone();
-			if ( newType->kind == TypeData::AggregateInst ) {
-				// don't duplicate members
-				if ( newType->aggInst.aggregate->kind == TypeData::Enum ) {
-					delete newType->aggInst.aggregate->enumeration.constants;
-					newType->aggInst.aggregate->enumeration.constants = 0;
-				} else {
-					assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
-					delete newType->aggInst.aggregate->aggregate.fields;
-					newType->aggInst.aggregate->aggregate.fields = 0;
-				} // if
-			} // if
-			newType->forall = maybeClone( type->forall );
-			if ( ! o->type ) {
-				o->type = newType;
-			} else {
-				addTypeToType( newType, o->type );
-				delete newType;
-			} // if
-		} // if
-	} // if
-	return o;
 }
 
@@ -846,23 +812,40 @@
 	newnode->copyStorageClasses( this );
 	assert( newName );
-	newnode->name = assign_strptr( newName );
-	return newnode;
-}
-
-DeclarationNode * DeclarationNode::cloneType( DeclarationNode * o ) {
-	if ( o ) {
-		assert( storageClass == NoStorageClass );
-		o->copyStorageClasses( this );
-		if ( type ) {
-			TypeData * newType = type->clone();
-			if ( ! o->type ) {
-				o->type = newType;
+	newnode->name = newName;
+	return newnode;
+}
+
+DeclarationNode * DeclarationNode::cloneBaseType( DeclarationNode * o ) {
+	if ( ! o ) return nullptr;
+
+	o->copyStorageClasses( this );
+	if ( type ) {
+		TypeData * srcType = type;
+
+		while ( srcType->base ) {
+			srcType = srcType->base;
+		} // while
+
+		TypeData * newType = srcType->clone();
+		if ( newType->kind == TypeData::AggregateInst ) {
+			// don't duplicate members
+			if ( newType->aggInst.aggregate->kind == TypeData::Enum ) {
+				delete newType->aggInst.aggregate->enumeration.constants;
+				newType->aggInst.aggregate->enumeration.constants = nullptr;
 			} else {
-				addTypeToType( newType, o->type );
-				delete newType;
+				assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
+				delete newType->aggInst.aggregate->aggregate.fields;
+				newType->aggInst.aggregate->aggregate.fields = nullptr;
 			} // if
 		} // if
-	} // if
-	delete o;
+
+		newType->forall = maybeClone( type->forall );
+		if ( ! o->type ) {
+			o->type = newType;
+		} else {
+			addTypeToType( newType, o->type );
+			delete newType;
+		} // if
+	} // if
 	return o;
 }
@@ -877,5 +860,5 @@
 		} // if
 	} // if
-	return 0;
+	return nullptr;
 }
 
@@ -884,4 +867,5 @@
 	std::back_insert_iterator< std::list< Declaration * > > out( outputList );
 	const DeclarationNode * cur = firstNode;
+
 	while ( cur ) {
 		try {
@@ -894,4 +878,5 @@
 				delete extr;
 			} // if
+
 			Declaration * decl = cur->build();
 			if ( decl ) {
@@ -903,8 +888,9 @@
 		cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
 	} // while
+
 	if ( ! errors.isEmpty() ) {
 		throw errors;
 	} // if
-}
+} // buildList
 
 void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) {
@@ -920,9 +906,9 @@
 				} 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 );
+					* out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
 					delete agg;
 				} 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 );
+					* out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
 				} // if
 			} // if
@@ -935,5 +921,5 @@
 		throw errors;
 	} // if
-}
+} // buildList
 
 void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList ) {
@@ -941,4 +927,5 @@
 	std::back_insert_iterator< std::list< Type * > > out( outputList );
 	const DeclarationNode * cur = firstNode;
+
 	while ( cur ) {
 		try {
@@ -949,24 +936,29 @@
 		cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
 	} // while
+
 	if ( ! errors.isEmpty() ) {
 		throw errors;
 	} // if
-}
+} // buildTypeList
 
 Declaration * DeclarationNode::build() const {
 	if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this );
+
+	if ( variable.name ) {
+		static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
+		TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
+		buildList( variable.assertions, ret->get_assertions() );
+		return ret;
+	} // if
+
 	if ( type ) {
-		if ( type->kind == TypeData::Variable ) {
-			static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
-			TypeDecl * ret = new TypeDecl( variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ variable.tyClass ] );
-			buildList( variable.assertions, ret->get_assertions() );
-			return ret;
-		} else {
-			return buildDecl( type, name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
-		} // if
-	} // if
+		return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
+	} // if
+
 	if ( ! isInline && ! isNoreturn ) {
-		return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
-	} // if
+		assertf( name, "ObjectDecl are assumed to have names\n" );
+		return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
+	} // if
+
 	throw SemanticError( "invalid function specifier ", this );
 }
@@ -975,18 +967,29 @@
 	assert( type );
 
+	if ( attr.name ) {
+		AttrType * ret;
+		if ( attr.expr ) {
+			ret = new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() );
+		} else {
+			assert( attr.type );
+			ret = new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() );
+		} // if
+		return ret;
+	} // if
+
 	switch ( type->kind ) {
 	  case TypeData::Enum:
-		return new EnumInstType( buildQualifiers( type ), type->enumeration.name );
+		return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
 	  case TypeData::Aggregate: {
 		  ReferenceToType * ret;
 		  switch ( type->aggregate.kind ) {
 			case DeclarationNode::Struct:
-			  ret = new StructInstType( buildQualifiers( type ), type->aggregate.name );
+			  ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
 			  break;
 			case DeclarationNode::Union:
-			  ret = new UnionInstType( buildQualifiers( type ), type->aggregate.name );
+			  ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
 			  break;
 			case DeclarationNode::Trait:
-			  ret = new TraitInstType( buildQualifiers( type ), type->aggregate.name );
+			  ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
 			  break;
 			default:
@@ -997,18 +1000,6 @@
 	  }
 	  case TypeData::Symbolic: {
-		  TypeInstType * ret = new TypeInstType( buildQualifiers( type ), type->symbolic.name, false );
+		  TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false );
 		  buildList( type->symbolic.actuals, ret->get_parameters() );
-		  return ret;
-	  }
-	  case TypeData::Attr: {
-		  assert( type->kind == TypeData::Attr );
-		  // assert( type->attr );
-		  AttrType * ret;
-		  if ( attr.expr ) {
-			  ret = new AttrType( buildQualifiers( type ), attr.name, attr.expr->build() );
-		  } else {
-			  assert( attr.type );
-			  ret = new AttrType( buildQualifiers( type ), attr.name, attr.type->buildType() );
-		  } // if
 		  return ret;
 	  }
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision 1b7727498168639c89eefe42fd1a1772a41b30d1)
+++ src/Parser/ParseNode.h	(revision 2298f728513aa541b29ac43ced6409a7bde8e38c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep 16 15:02:38 2016
-// Update Count     : 613
+// Last Modified On : Sat Sep 24 11:12:04 2016
+// Update Count     : 633
 //
 
@@ -41,5 +41,5 @@
   public:
 	ParseNode() {};
-	virtual ~ParseNode() { delete next; };
+	virtual ~ParseNode() { delete next; delete name; };
 	virtual ParseNode * clone() const = 0;
 
@@ -49,9 +49,9 @@
 	ParseNode * get_last() {
 		ParseNode * current;
-		for ( current = this; current->get_next() != 0; current = current->get_next() );
+		for ( current = this; current->get_next() != nullptr; current = current->get_next() );
 		return current;
 	}
 	ParseNode * set_last( ParseNode * newlast ) {
-		if ( newlast != 0 ) get_last()->set_next( newlast );
+		if ( newlast != nullptr ) get_last()->set_next( newlast );
 		return this;
 	}
@@ -63,5 +63,5 @@
 
 	ParseNode * next = nullptr;
-	std::string name;
+	std::string * name = nullptr;
 }; // ParseNode
 
@@ -70,6 +70,6 @@
 class InitializerNode : public ParseNode {
   public:
-	InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = 0 );
-	InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = 0 );
+	InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
+	InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
 	~InitializerNode();
 	virtual InitializerNode * clone() const { assert( false ); return nullptr; }
@@ -178,5 +178,5 @@
 Expression * build_attrexpr( NameExpr * var, ExpressionNode * expr_node );
 Expression * build_attrtype( NameExpr * var, DeclarationNode * decl_node );
-Expression * build_tuple( ExpressionNode * expr_node = 0 );
+Expression * build_tuple( ExpressionNode * expr_node = nullptr );
 Expression * build_func( ExpressionNode * function, ExpressionNode * expr_node );
 Expression * build_range( ExpressionNode * low, ExpressionNode * high );
@@ -214,5 +214,5 @@
 	static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
 	static DeclarationNode * newQualifier( Qualifier );
-	static DeclarationNode * newForall( DeclarationNode *);
+	static DeclarationNode * newForall( DeclarationNode * );
 	static DeclarationNode * newStorageClass( StorageClass );
 	static DeclarationNode * newBasicType( BasicType );
@@ -221,13 +221,13 @@
 	static DeclarationNode * newLength( Length lnth );
 	static DeclarationNode * newBuiltinType( BuiltinType );
-	static DeclarationNode * newFromTypedef( std::string *);
+	static DeclarationNode * newFromTypedef( std::string * );
 	static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
 	static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants );
 	static DeclarationNode * newEnumConstant( std::string * name, ExpressionNode * constant );
-	static DeclarationNode * newName( std::string *);
+	static DeclarationNode * newName( std::string * );
 	static DeclarationNode * newFromTypeGen( std::string *, ExpressionNode * params );
-	static DeclarationNode * newTypeParam( TypeClass, std::string *);
-	static DeclarationNode * newTrait( std::string * name, DeclarationNode * params, DeclarationNode * asserts );
-	static DeclarationNode * newTraitUse( std::string * name, ExpressionNode * params );
+	static DeclarationNode * newTypeParam( TypeClass, std::string * );
+	static DeclarationNode * newTrait( const std::string * name, DeclarationNode * params, DeclarationNode * asserts );
+	static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
 	static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
 	static DeclarationNode * newPointer( DeclarationNode * qualifiers );
@@ -244,12 +244,12 @@
 	DeclarationNode * clone() const;
 
-	DeclarationNode * addQualifiers( DeclarationNode *);
+	DeclarationNode * addQualifiers( DeclarationNode * );
 	void checkQualifiers( const TypeData *, const TypeData * );
-	void checkStorageClasses( DeclarationNode *q );
-	DeclarationNode * copyStorageClasses( DeclarationNode *);
-	DeclarationNode * addType( DeclarationNode *);
+	void checkStorageClasses( DeclarationNode * );
+	DeclarationNode * copyStorageClasses( DeclarationNode * );
+	DeclarationNode * addType( DeclarationNode * );
 	DeclarationNode * addTypedef();
-	DeclarationNode * addAssertions( DeclarationNode *);
-	DeclarationNode * addName( std::string *);
+	DeclarationNode * addAssertions( DeclarationNode * );
+	DeclarationNode * addName( std::string * );
 	DeclarationNode * addBitfield( ExpressionNode * size );
 	DeclarationNode * addVarArgs();
@@ -265,7 +265,4 @@
 
 	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 );
 
@@ -290,6 +287,6 @@
   public:
 	struct Variable_t {
+		const std::string * name;
 		DeclarationNode::TypeClass tyClass;
-		std::string name;
 		DeclarationNode * assertions;
 	};
@@ -297,5 +294,5 @@
 
 	struct Attr_t {
-		std::string name;
+		const std::string * name;
 		ExpressionNode * expr;
 		DeclarationNode * type;
@@ -382,5 +379,5 @@
 Statement * build_finally( StatementNode * stmt );
 Statement * build_compound( StatementNode * first );
-Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = 0, ExpressionNode * input = 0, ExpressionNode * clobber = 0, LabelNode * gotolabels = 0 );
+Statement * build_asmstmt( bool voltile, ConstantExpr * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
 
 //##############################################################################
Index: src/Parser/TypeData.cc
===================================================================
--- src/Parser/TypeData.cc	(revision 1b7727498168639c89eefe42fd1a1772a41b30d1)
+++ src/Parser/TypeData.cc	(revision 2298f728513aa541b29ac43ced6409a7bde8e38c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep 16 15:12:55 2016
-// Update Count     : 388
+// Last Modified On : Sat Sep 24 11:14:26 2016
+// Update Count     : 415
 //
 
@@ -24,6 +24,7 @@
 #include "SynTree/Statement.h"
 #include "SynTree/Initializer.h"
-
-TypeData::TypeData( Kind k ) : kind( k ), base( 0 ), forall( 0 ) {
+using namespace std;
+
+TypeData::TypeData( Kind k ) : kind( k ), base( nullptr ), forall( nullptr ) {
 	switch ( kind ) {
 	  case Unknown:
@@ -37,5 +38,5 @@
 	  case Array:
 		// array = new Array_t;
-		array.dimension = 0;
+		array.dimension = nullptr;
 		array.isVarLen = false;
 		array.isStatic = false;
@@ -43,8 +44,8 @@
 	  case Function:
 		// function = new Function_t;
-		function.params = 0;
-		function.idList = 0;
-		function.oldDeclList = 0;
-		function.body = 0;
+		function.params = nullptr;
+		function.idList = nullptr;
+		function.oldDeclList = nullptr;
+		function.body = nullptr;
 		function.hasBody = false;
 		function.newStyle = false;
@@ -52,28 +53,26 @@
 	  case Aggregate:
 		// aggregate = new Aggregate_t;
-		aggregate.params = 0;
-		aggregate.actuals = 0;
-		aggregate.fields = 0;
+		aggregate.name = nullptr;
+		aggregate.params = nullptr;
+		aggregate.actuals = nullptr;
+		aggregate.fields = nullptr;
 		break;
 	  case AggregateInst:
 		// aggInst = new AggInst_t;
-		aggInst.aggregate = 0;
-		aggInst.params = 0;
+		aggInst.aggregate = nullptr;
+		aggInst.params = nullptr;
 		break;
 	  case Enum:
 		// enumeration = new Enumeration_t;
-		enumeration.constants = 0;
+		enumeration.name = nullptr;
+		enumeration.constants = nullptr;
 		break;
 	  case Symbolic:
 	  case SymbolicInst:
 		// symbolic = new Symbolic_t;
-		symbolic.params = 0;
-		symbolic.actuals = 0;
-		symbolic.assertions = 0;
-		break;
-	  case Variable:
-		// variable = new Variable_t;
-		// variable.tyClass = DeclarationNode::Type;
-		// variable.assertions = 0;
+		symbolic.name = nullptr;
+		symbolic.params = nullptr;
+		symbolic.actuals = nullptr;
+		symbolic.assertions = nullptr;
 		break;
 	  case Tuple:
@@ -84,9 +83,4 @@
 		// typeexpr = new Typeof_t;
 		typeexpr = nullptr;
-		break;
-	  case Attr:
-		// attr = new Attr_t;
-		// attr.expr = nullptr;
-		// attr.type = nullptr;
 		break;
 	  case Builtin:
@@ -121,4 +115,5 @@
 		break;
 	  case Aggregate:
+		delete aggregate.name;
 		delete aggregate.params;
 		delete aggregate.actuals;
@@ -132,4 +127,5 @@
 		break;
 	  case Enum:
+		delete enumeration.name;
 		delete enumeration.constants;
 		// delete enumeration;
@@ -137,4 +133,5 @@
 	  case Symbolic:
 	  case SymbolicInst:
+		delete symbolic.name;
 		delete symbolic.params;
 		delete symbolic.actuals;
@@ -142,8 +139,4 @@
 		// delete symbolic;
 		break;
-	  case Variable:
-		// delete variable.assertions;
-		// delete variable;
-		break;
 	  case Tuple:
 		// delete tuple->members;
@@ -153,9 +146,4 @@
 		// delete typeexpr->expr;
 		delete typeexpr;
-		break;
-	  case Attr:
-		// delete attr.expr;
-		// delete attr.type;
-		// delete attr;
 		break;
 	  case Builtin:
@@ -197,8 +185,8 @@
 		break;
 	  case Aggregate:
+		newtype->aggregate.name = aggregate.name ? new string( *aggregate.name ) : nullptr;
 		newtype->aggregate.params = maybeClone( aggregate.params );
 		newtype->aggregate.actuals = maybeClone( aggregate.actuals );
 		newtype->aggregate.fields = maybeClone( aggregate.fields );
-		newtype->aggregate.name = aggregate.name;
 		newtype->aggregate.kind = aggregate.kind;
 		newtype->aggregate.body = aggregate.body;
@@ -209,20 +197,14 @@
 		break;
 	  case Enum:
-		newtype->enumeration.name = enumeration.name;
+		newtype->enumeration.name = enumeration.name ? new string( *enumeration.name ) : nullptr;
 		newtype->enumeration.constants = maybeClone( enumeration.constants );
 		break;
 	  case Symbolic:
 	  case SymbolicInst:
+		newtype->symbolic.name = symbolic.name ? new string( *symbolic.name ) : nullptr;
 		newtype->symbolic.params = maybeClone( symbolic.params );
 		newtype->symbolic.actuals = maybeClone( symbolic.actuals );
 		newtype->symbolic.assertions = maybeClone( symbolic.assertions );
 		newtype->symbolic.isTypedef = symbolic.isTypedef;
-		newtype->symbolic.name = symbolic.name;
-		break;
-	  case Variable:
-		assert( false );
-		// newtype->variable.assertions = maybeClone( variable.assertions );
-		// newtype->variable.name = variable.name;
-		// newtype->variable.tyClass = variable.tyClass;
 		break;
 	  case Tuple:
@@ -231,9 +213,4 @@
 	  case Typeof:
 		newtype->typeexpr = maybeClone( typeexpr );
-		break;
-	  case Attr:
-		assert( false );
-		// newtype->attr.expr = maybeClone( attr.expr );
-		// newtype->attr.type = maybeClone( attr.type );
 		break;
 	  case Builtin:
@@ -245,8 +222,5 @@
 } // TypeData::clone
 
-void TypeData::print( std::ostream &os, int indent ) const {
-	using std::endl;
-	using std::string;
-
+void TypeData::print( ostream &os, int indent ) const {
 	for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) {
 		if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' ';
@@ -326,5 +300,5 @@
 		break;
 	  case Aggregate:
-		os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << aggregate.name << endl;
+		os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl;
 		if ( aggregate.params ) {
 			os << string( indent + 2, ' ' ) << "with type parameters " << endl;
@@ -363,5 +337,5 @@
 		break;
 	  case SymbolicInst:
-		os << "instance of type " << symbolic.name;
+		os << "instance of type " << *symbolic.name;
 		if ( symbolic.actuals ) {
 			os << " with parameters" << endl;
@@ -389,12 +363,4 @@
 		} // if
 		break;
-	  case Variable:
-		// os << DeclarationNode::typeClassName[ variable.tyClass ] << " variable ";
-		// if ( variable.assertions ) {
-		// 	os << endl << string( indent + 2, ' ' ) << "with assertions" << endl;
-		// 	variable.assertions->printList( os, indent + 4 );
-		// 	os << string( indent + 2, ' ' );
-		// } // if
-		break;
 	  case Tuple:
 		os << "tuple ";
@@ -410,13 +376,4 @@
 		} // if
 		break;
-	  case Attr:
-		// os << "attribute type decl " << attr.name << " applied to ";
-		// if ( attr.expr ) {
-		// 	attr.expr->print( os, indent + 2 );
-		// } // if
-		// if ( attr.type ) {
-		// 	attr.type->print( os, indent + 2 );
-		// } // if
-		break;
 	  case Builtin:
 		os << "gcc builtin type";
@@ -428,31 +385,31 @@
 } // TypeData::print
 
-void buildForall( const DeclarationNode * firstNode, std::list< TypeDecl* > &outputList ) {
+void buildForall( const DeclarationNode * firstNode, list< TypeDecl* > &outputList ) {
 	buildList( firstNode, outputList );
-	for ( std::list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
+	for ( list< TypeDecl* >::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
 		if ( (*i)->get_kind() == TypeDecl::Any ) {
 			// add assertion parameters to `type' tyvars in reverse order
 			// add dtor:  void ^?{}(T *)
 			FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
-			dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
-			(*i)->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, 0, false, false ) );
+			dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+			(*i)->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
 
 			// add copy ctor:  void ?{}(T *, T)
 			FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
-			copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
-			copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
-			(*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, 0, false, false ) );
+			copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+			copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+			(*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
 
 			// add default ctor:  void ?{}(T *)
 			FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
-			ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
-			(*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, 0, false, false ) );
+			ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+			(*i)->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
 
 			// add assignment operator:  T * ?=?(T *, T)
 			FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
-			assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), 0 ) );
-			assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
-			assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), 0 ) );
-			(*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, 0, false, false ) );
+			assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ) ), nullptr ) );
+			assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+			assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), (*i)->get_name(), *i ), nullptr ) );
+			(*i)->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
 		} // if
 	} // for
@@ -486,16 +443,14 @@
 	  case TypeData::Builtin:
 		return new VarArgsType( buildQualifiers( td ) );
-	  case TypeData::Attr:
 	  case TypeData::Symbolic:
 	  case TypeData::Enum:
 	  case TypeData::Aggregate:
-	  case TypeData::Variable:
 		assert( false );
 	} // switch
-	return 0;
+	return nullptr;
 } // typebuild
 
 TypeData * typeextractAggregate( const TypeData * td, bool toplevel ) {
-	TypeData * ret = 0;
+	TypeData * ret = nullptr;
 
 	switch ( td->kind ) {
@@ -547,8 +502,8 @@
 	  case DeclarationNode::Bool:
 		if ( td->signedness != DeclarationNode::NoSignedness ) {
-			throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+			throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
 		} // if
 		if ( td->length != DeclarationNode::NoLength ) {
-			throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+			throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
 		} // if
 
@@ -563,5 +518,5 @@
 
 		if ( td->length != DeclarationNode::NoLength ) {
-			throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+			throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
 		} // if
 
@@ -593,8 +548,8 @@
 	  FloatingPoint: ;
 		if ( td->signedness != DeclarationNode::NoSignedness ) {
-			throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+			throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
 		} // if
 		if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
-			throw SemanticError( std::string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+			throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
 		} // if
 		if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
@@ -653,13 +608,13 @@
 	switch ( td->aggregate.kind ) {
 	  case DeclarationNode::Struct:
-		at = new StructDecl( td->aggregate.name );
+		at = new StructDecl( *td->aggregate.name );
 		buildForall( td->aggregate.params, at->get_parameters() );
 		break;
 	  case DeclarationNode::Union:
-		at = new UnionDecl( td->aggregate.name );
+		at = new UnionDecl( *td->aggregate.name );
 		buildForall( td->aggregate.params, at->get_parameters() );
 		break;
 	  case DeclarationNode::Trait:
-		at = new TraitDecl( td->aggregate.name );
+		at = new TraitDecl( *td->aggregate.name );
 		buildList( td->aggregate.params, at->get_parameters() );
 		break;
@@ -679,16 +634,17 @@
 	ReferenceToType * ret;
 	if ( td->aggInst.aggregate->kind == TypeData::Enum ) {
-		ret = new EnumInstType( buildQualifiers( td ), td->aggInst.aggregate->enumeration.name );
+		ret = new EnumInstType( buildQualifiers( td ), *td->aggInst.aggregate->enumeration.name );
 	} else {
 		assert( td->aggInst.aggregate->kind == TypeData::Aggregate );
 		switch ( td->aggInst.aggregate->aggregate.kind ) {
 		  case DeclarationNode::Struct:
-			ret = new StructInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+			assert( td->aggInst.aggregate->aggregate.name );
+			ret = new StructInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
 			break;
 		  case DeclarationNode::Union:
-			ret = new UnionInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+			ret = new UnionInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
 			break;
 		  case DeclarationNode::Trait:
-			ret = new TraitInstType( buildQualifiers( td ), td->aggInst.aggregate->aggregate.name );
+			ret = new TraitInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
 			break;
 		  default:
@@ -701,5 +657,5 @@
 } // buildAggInst
 
-NamedTypeDecl * buildSymbolic( const TypeData * td, const std::string & name, DeclarationNode::StorageClass sc ) {
+NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) {
 	assert( td->kind == TypeData::Symbolic );
 	NamedTypeDecl * ret;
@@ -715,24 +671,13 @@
 } // buildSymbolic
 
-TypeDecl * buildVariable( const TypeData * td ) {
-	assert( false );
-	return nullptr;
-	// assert( td->kind == TypeData::Variable );
-	// static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Ftype, TypeDecl::Dtype };
-
-	// TypeDecl * ret = new TypeDecl( td->variable.name, DeclarationNode::NoStorageClass, 0, kindMap[ td->variable.tyClass ] );
-	// buildList( td->variable.assertions, ret->get_assertions() );
-	// return ret;
-} // buildSymbolic
-
 EnumDecl * buildEnum( const TypeData * td ) {
 	assert( td->kind == TypeData::Enum );
-	EnumDecl * ret = new EnumDecl( td->enumeration.name );
+	EnumDecl * ret = new EnumDecl( *td->enumeration.name );
 	buildList( td->enumeration.constants, ret->get_members() );
-	std::list< Declaration * >::iterator members = ret->get_members().begin();
+	list< Declaration * >::iterator members = ret->get_members().begin();
 	for ( const DeclarationNode * cur = td->enumeration. constants; cur != nullptr; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ), ++members ) {
 		if ( cur->has_enumeratorValue() ) {
 			ObjectDecl * member = dynamic_cast< ObjectDecl * >(* members);
-			member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), std::list< Expression * >() ) );
+			member->set_init( new SingleInit( maybeMoveBuild< Expression >( cur->consume_enumeratorValue() ), list< Expression * >() ) );
 		} // if
 	} // for
@@ -742,5 +687,5 @@
 TypeInstType * buildSymbolicInst( const TypeData * td ) {
 	assert( td->kind == TypeData::SymbolicInst );
-	TypeInstType * ret = new TypeInstType( buildQualifiers( td ), td->symbolic.name, false );
+	TypeInstType * ret = new TypeInstType( buildQualifiers( td ), *td->symbolic.name, false );
 	buildList( td->symbolic.actuals, ret->get_parameters() );
 	buildForall( td->forall, ret->get_forall() );
@@ -763,5 +708,5 @@
 } // buildTypeof
 
-Declaration * buildDecl( const TypeData * td, std::string name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) {
+Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, Initializer * init ) {
 	if ( td->kind == TypeData::Function ) {
 		FunctionDecl * decl;
@@ -773,13 +718,13 @@
 				decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn );
 			} else {
-				// std::list< Label > ls;
-				decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( std::list< Label >() ), isInline, isNoreturn );
+				// list< Label > ls;
+				decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), new CompoundStmt( list< Label >() ), isInline, isNoreturn );
 			} // if
 		} else {
-			decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), 0, isInline, isNoreturn );
-		} // if
-		for ( DeclarationNode * cur = td->function.idList; cur != 0; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
-			if ( cur->name != "" ) {
-				decl->get_oldIdents().insert( decl->get_oldIdents().end(), cur->name );
+			decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), nullptr, isInline, isNoreturn );
+		} // if
+		for ( DeclarationNode * cur = td->function.idList; cur != nullptr; cur = dynamic_cast< DeclarationNode* >( cur->get_next() ) ) {
+			if ( cur->name ) {
+				decl->get_oldIdents().insert( decl->get_oldIdents().end(), *cur->name );
 			} // if
 		} // for
@@ -792,11 +737,8 @@
 	} else if ( td->kind == TypeData::Symbolic ) {
 		return buildSymbolic( td, name, sc );
-	} else if ( td->kind == TypeData::Variable ) {
-		assert( false );
-		return buildVariable( td );
 	} else {
-		return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, std::list< Attribute * >(), isInline, isNoreturn );
+		return new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, list< Attribute * >(), isInline, isNoreturn );
 	} // if
-	return 0;
+	return nullptr;
 } // buildDecl
 
@@ -814,8 +756,8 @@
 			break;
 		  default:
-			ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, 0, false, false, LinkageSpec::Cforall ) ) );
+			ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall ) ) );
 		} // switch
 	} else {
-		ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), 0 ) );
+		ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
 	} // if
 	return ft;
Index: src/Parser/TypeData.h
===================================================================
--- src/Parser/TypeData.h	(revision 1b7727498168639c89eefe42fd1a1772a41b30d1)
+++ src/Parser/TypeData.h	(revision 2298f728513aa541b29ac43ced6409a7bde8e38c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep 16 15:17:31 2016
-// Update Count     : 131
+// Last Modified On : Sat Sep 24 11:10:38 2016
+// Update Count     : 141
 //
 
@@ -24,11 +24,11 @@
 struct TypeData {
 	enum Kind { Unknown, Basic, Pointer, Array, Function, Aggregate, AggregateInst,
-				Enum, EnumConstant, Symbolic, SymbolicInst, Variable, Tuple, Typeof, Builtin, Attr };
+				Enum, EnumConstant, Symbolic, SymbolicInst, Tuple, Typeof, Builtin };
 
 	struct Aggregate_t {
 		DeclarationNode::Aggregate kind;
-		std::string name;
+		const std::string * name;
 		DeclarationNode * params;
-		ExpressionNode  * actuals;						// holds actual parameters later applied to AggInst
+		ExpressionNode * actuals;						// holds actual parameters later applied to AggInst
 		DeclarationNode * fields;
 		bool body;
@@ -47,5 +47,5 @@
 
 	struct Enumeration_t {
-		std::string name;
+		const std::string * name;
 		DeclarationNode * constants;
 	};
@@ -61,5 +61,5 @@
 
 	struct Symbolic_t {
-		std::string name;
+		const std::string * name;
 		bool isTypedef;									// false => TYPEGENname, true => TYPEDEFname
 		DeclarationNode * params;
@@ -110,5 +110,5 @@
 TupleType * buildTuple( const TypeData * );
 TypeofType * buildTypeof( const TypeData * );
-Declaration * buildDecl( const TypeData *, std::string, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = 0 );
+Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, Initializer * init = nullptr );
 FunctionType * buildFunction( const TypeData * );
 
Index: src/Parser/parser.h
===================================================================
--- src/Parser/parser.h	(revision 1b7727498168639c89eefe42fd1a1772a41b30d1)
+++ src/Parser/parser.h	(revision 2298f728513aa541b29ac43ced6409a7bde8e38c)
@@ -262,5 +262,5 @@
 
 /* Line 2068 of yacc.c  */
-#line 115 "parser.yy"
+#line 116 "parser.yy"
 
 	Token tok;
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision 1b7727498168639c89eefe42fd1a1772a41b30d1)
+++ src/Parser/parser.yy	(revision 2298f728513aa541b29ac43ced6409a7bde8e38c)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep 16 18:12:21 2016
-// Update Count     : 1978
+// Last Modified On : Sat Sep 24 11:30:40 2016
+// Update Count     : 1991
 //
 
@@ -54,4 +54,5 @@
 #include "TypeData.h"
 #include "LinkageSpec.h"
+using namespace std;
 
 extern DeclarationNode * parseTree;
@@ -59,7 +60,7 @@
 extern TypedefTable typedefTable;
 
-std::stack< LinkageSpec::Spec > linkageStack;
-
-void appendStr( std::string *to, std::string *from ) {
+stack< LinkageSpec::Spec > linkageStack;
+
+void appendStr( string *to, string *from ) {
 	// "abc" "def" "ghi" => "abcdefghi", remove new text from quotes and insert before last quote in old string.
 	to->insert( to->length() - 1, from->substr( 1, from->length() - 2 ) );
@@ -389,5 +390,5 @@
 		{
 			Token fn;
-			fn.str = new std::string( "?{}" ); // location undefined
+			fn.str = new string( "?{}" );				// location undefined
 			$$ = new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) );
 		}
@@ -666,5 +667,5 @@
 		{
 			Token fn;
-			fn.str = new std::string( "^?{}" ); // location undefined
+			fn.str = new string( "^?{}" );				// location undefined
 			$$ = new StatementNode( build_expr( new ExpressionNode( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $2 )->set_last( $4 ) ) ) ) );
 		}
@@ -1467,9 +1468,9 @@
 aggregate_name:
 	aggregate_key '{' field_declaration_list '}'
-		{ $$ = DeclarationNode::newAggregate( $1, new std::string( "" ), nullptr, $3, true ); }
+		{ $$ = DeclarationNode::newAggregate( $1, nullptr, nullptr, $3, true ); }
 	| aggregate_key no_attr_identifier_or_type_name
 		{
 			typedefTable.makeTypedef( *$2 );
-			$$ = DeclarationNode::newAggregate( $1, $2, 0, 0, false );
+			$$ = DeclarationNode::newAggregate( $1, $2, nullptr, nullptr, false );
 		}
 	| aggregate_key no_attr_identifier_or_type_name
@@ -1478,5 +1479,5 @@
 		{ $$ = DeclarationNode::newAggregate( $1, $2, nullptr, $5, true ); }
 	| aggregate_key '(' type_name_list ')' '{' field_declaration_list '}' // CFA
-		{ $$ = DeclarationNode::newAggregate( $1, new std::string( "" ), $3, $6, false ); }
+		{ $$ = DeclarationNode::newAggregate( $1, nullptr, $3, $6, false ); }
 	| aggregate_key typegen_name						// CFA, S/R conflict
 		{ $$ = $2; }
@@ -1559,5 +1560,5 @@
 enum_name:
 	enum_key '{' enumerator_list comma_opt '}'
-		{ $$ = DeclarationNode::newEnum( new std::string( "" ), $3 ); }
+		{ $$ = DeclarationNode::newEnum( nullptr, $3 ); }
 	| enum_key no_attr_identifier_or_type_name
 		{
@@ -2520,5 +2521,5 @@
 abstract_function:
 	'(' push parameter_type_list_opt pop ')'			// empty parameter list OBSOLESCENT (see 3)
-		{ $$ = DeclarationNode::newFunction( new std::string( "" ), nullptr, $3, nullptr ); }
+		{ $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); }
 	| '(' abstract_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
 		{ $$ = $2->addParamList( $6 ); }
@@ -2589,5 +2590,5 @@
 abstract_parameter_function:
 	'(' push parameter_type_list_opt pop ')'			// empty parameter list OBSOLESCENT (see 3)
-		{ $$ = DeclarationNode::newFunction( new std::string( "" ), nullptr, $3, nullptr ); }
+		{ $$ = DeclarationNode::newFunction( nullptr, nullptr, $3, nullptr ); }
 	| '(' abstract_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
 		{ $$ = $2->addParamList( $6 ); }
@@ -2793,13 +2794,13 @@
 		// empty (void) function return type.
 	'[' ']' type_specifier
-		{ $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		{ $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
 	| '[' ']' multi_array_dimension type_specifier
-		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
 	| multi_array_dimension type_specifier
 		{ $$ = $2->addNewArray( $1 ); }
 	| '[' ']' new_abstract_ptr
-		{ $$ = $3->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		{ $$ = $3->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
 	| '[' ']' multi_array_dimension new_abstract_ptr
-		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( 0, 0, false ) ); }
+		{ $$ = $4->addNewArray( $3 )->addNewArray( DeclarationNode::newArray( nullptr, nullptr, false ) ); }
 	| multi_array_dimension new_abstract_ptr
 		{ $$ = $2->addNewArray( $1 ); }
@@ -2813,9 +2814,9 @@
 new_abstract_function:									// CFA
 	'[' ']' '(' new_parameter_type_list_opt ')'
-	{ $$ = DeclarationNode::newFunction( new std::string( "" ), DeclarationNode::newTuple( nullptr ), $4, nullptr ); }
+		{ $$ = DeclarationNode::newFunction( nullptr, DeclarationNode::newTuple( nullptr ), $4, nullptr ); }
 	| new_abstract_tuple '(' push new_parameter_type_list_opt pop ')'
-		{ $$ = DeclarationNode::newFunction( new std::string( "" ), $1, $4, nullptr ); }
+		{ $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
 	| new_function_return '(' push new_parameter_type_list_opt pop ')'
-		{ $$ = DeclarationNode::newFunction( new std::string( "" ), $1, $4, nullptr ); }
+		{ $$ = DeclarationNode::newFunction( nullptr, $1, $4, nullptr ); }
 	;
 
@@ -2852,9 +2853,9 @@
 
 void yyerror( const char * ) {
-	std::cout << "Error ";
+	cout << "Error ";
 	if ( yyfilename ) {
-		std::cout << "in file " << yyfilename << " ";
+		cout << "in file " << yyfilename << " ";
 	} // if
-	std::cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << std::endl;
+	cout << "at line " << yylineno << " reading token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << "\"" << endl;
 }