Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 7527e6365628dd566e55f6dbeaca1521c6718837)
+++ src/Parser/DeclarationNode.cc	(revision 1f6d4624837db00faa1eac5c1d67887fad60e31b)
@@ -48,5 +48,7 @@
 	newnode->type = maybeClone( type );
 	newnode->name = name;
-	newnode->storageClasses = storageClasses;
+	newnode->storageClass = storageClass;
+	newnode->isInline = isInline;
+	newnode->isNoreturn = isNoreturn;
 	newnode->bitfieldWidth = bitfieldWidth;
 	newnode->hasEllipsis = hasEllipsis;
@@ -57,5 +59,15 @@
 } // DeclarationNode::clone
 
-DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) {
+DeclarationNode::DeclarationNode()
+	: type( 0 )
+	, storageClass( NoStorageClass )
+	, isInline( false )
+	, isNoreturn( false )
+	, bitfieldWidth( 0 )
+	, initializer( 0 )
+	, hasEllipsis( false )
+	, linkage( ::linkage )
+	, extension( false )
+	, error() {
 }
 
@@ -82,5 +94,7 @@
 	} // if
 
-	printEnums( storageClasses.begin(), storageClasses.end(), DeclarationNode::storageName, os );
+	if(storageClass != NoStorageClass) os << DeclarationNode::storageName[storageClass] << ' ';
+	if(isInline) os << DeclarationNode::storageName[Inline] << ' ';
+	if(isNoreturn) os << DeclarationNode::storageName[Noreturn] << ' ';
 	if ( type ) {
 		type->print( os, indent );
@@ -143,5 +157,9 @@
 DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
 	DeclarationNode *newnode = new DeclarationNode;
-	newnode->storageClasses.push_back( sc );
+	switch (sc) {
+		case Inline: newnode->isInline = true; break;
+		case Noreturn: newnode->isNoreturn = true; break;
+		default: newnode->storageClass = sc; break;
+	}
 	return newnode;
 } // DeclarationNode::newStorageClass
@@ -359,5 +377,5 @@
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
 	if ( q ) {
-		storageClasses.splice( storageClasses.end(), q->storageClasses );
+		copyStorageClasses(q);
 		if ( q->type ) {
 			if ( ! type ) {
@@ -386,5 +404,13 @@
 
 DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
-	storageClasses = q->storageClasses;
+	isInline = isInline || q->isInline;
+	isNoreturn = isNoreturn || q->isNoreturn;
+	if(storageClass == NoStorageClass) {
+		storageClass = q->storageClass;
+	}
+	else if (q->storageClass != NoStorageClass) {
+		q->error = "invalid combination of storage classes in declaration of ";
+	}
+	if(error.empty()) error = q->error;
 	return this;
 }
@@ -446,5 +472,5 @@
 DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
 	if ( o ) {
-		storageClasses.splice( storageClasses.end(), o->storageClasses );
+		copyStorageClasses( o );
 		if ( o->type ) {
 			if ( ! type ) {
@@ -693,5 +719,5 @@
 	} // if
 	newnode->type->forall = maybeClone( type->forall );
-	newnode->storageClasses = storageClasses;
+	newnode->copyStorageClasses( this );
 	newnode->name = assign_strptr( newName );
 	return newnode;
@@ -700,5 +726,5 @@
 DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) {
 	if ( o ) {
-		o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
+		o->copyStorageClasses( this );
 		if ( type ) {
 			TypeData *srcType = type;
@@ -733,5 +759,5 @@
 	DeclarationNode *newnode = new DeclarationNode;
 	newnode->type = maybeClone( type );
-	newnode->storageClasses = storageClasses;
+	newnode->copyStorageClasses( this );
 	newnode->name = assign_strptr( newName );
 	return newnode;
@@ -740,5 +766,5 @@
 DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
 	if ( o ) {
-		o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
+		o->copyStorageClasses( this );
 		if ( type ) {
 			TypeData *newType = type->clone();
@@ -855,9 +881,10 @@
 
 Declaration *DeclarationNode::build() const {
+	if( !error.empty() ) throw SemanticError( error, this );
 	if ( type ) {
-		return type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildFuncSpecifier( Inline ), buildFuncSpecifier( Noreturn ), linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
-	} // if
-	if ( ! buildFuncSpecifier( Inline ) && ! buildFuncSpecifier( Noreturn ) ) {
-		return (new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
+		return type->buildDecl( name, 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
 	throw SemanticError( "invalid function specifier in declaration of ", this );
@@ -898,23 +925,23 @@
 }
 
-DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const {
-	DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass;
-	for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
-	  if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers
-	  if ( ret != DeclarationNode::NoStorageClass ) {	// already have a valid storage class ?
-			throw SemanticError( "invalid combination of storage classes in declaration of ", this );
-		} // if
-		ret = *i;
-	} // for
-	return ret;
-}
-
-bool DeclarationNode::buildFuncSpecifier( DeclarationNode::StorageClass key ) const {
-	std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), key );
-  if ( first == storageClasses.end() ) return false;	// not found
-	first = std::find( ++first, storageClasses.end(), key ); // found
-  if ( first == storageClasses.end() ) return true;		// not found again
-	throw SemanticError( "duplicate function specifier in declaration of ", this );
-}
+// DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const {
+// 	DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass;
+// 	for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
+// 	  if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers
+// 	  if ( ret != DeclarationNode::NoStorageClass ) {	// already have a valid storage class ?
+// 			throw SemanticError( "invalid combination of storage classes in declaration of ", this );
+// 		} // if
+// 		ret = *i;
+// 	} // for
+// 	return ret;
+// }
+
+// bool DeclarationNode::buildFuncSpecifier( DeclarationNode::StorageClass key ) const {
+// 	std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), key );
+//   if ( first == storageClasses.end() ) return false;	// not found
+// 	first = std::find( ++first, storageClasses.end(), key ); // found
+//   if ( first == storageClasses.end() ) return true;		// not found again
+// 	throw SemanticError( "duplicate function specifier in declaration of ", this );
+// }
 
 // Local Variables: //
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision 7527e6365628dd566e55f6dbeaca1521c6718837)
+++ src/Parser/ParseNode.h	(revision 1f6d4624837db00faa1eac5c1d67887fad60e31b)
@@ -271,10 +271,12 @@
 	DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
   private:
-	StorageClass buildStorageClass() const;
-	bool buildFuncSpecifier( StorageClass key ) const;
+	// StorageClass buildStorageClass() const;
+	// bool buildFuncSpecifier( StorageClass key ) const;
 
 	TypeData *type;
 	std::string name;
-	std::list< StorageClass > storageClasses;
+	// std::list< StorageClass > storageClasses;
+	StorageClass storageClass;
+	bool isInline, isNoreturn;
 	std::list< std::string > attributes;
 	ExpressionNode *bitfieldWidth;
@@ -284,4 +286,5 @@
 	LinkageSpec::Type linkage;
 	bool extension = false;
+	std::string error;
 
 	static UniqueName anonymous;
Index: src/tests/.expect/declarationErrors.txt
===================================================================
--- src/tests/.expect/declarationErrors.txt	(revision 7527e6365628dd566e55f6dbeaca1521c6718837)
+++ src/tests/.expect/declarationErrors.txt	(revision 1f6d4624837db00faa1eac5c1d67887fad60e31b)
@@ -1,6 +1,6 @@
 CFA Version 1.0.0 (debug)
-Error: invalid combination of storage classes in declaration of x9: static static volatile const short int 
+Error: invalid combination of storage classes in declaration of x9: static volatile const short int 
 
-Error: invalid combination of storage classes in declaration of x18: static static const volatile instance of struct __anonymous0
+Error: invalid combination of storage classes in declaration of x18: static const volatile instance of struct __anonymous0
   with members 
     i: int 
@@ -8,5 +8,5 @@
 
 
-Error: invalid combination of storage classes in declaration of x19: static static const volatile volatile instance of struct __anonymous1
+Error: invalid combination of storage classes in declaration of x19: static const volatile volatile instance of struct __anonymous1
   with members 
     i: int 
@@ -14,5 +14,5 @@
 
 
-Error: invalid combination of storage classes in declaration of x28: static static volatile const instance of type Int
+Error: invalid combination of storage classes in declaration of x28: static volatile const instance of type Int
 
 make: *** [declarationErrors] Error 1