Changeset be8bd88 for src/Parser

Timestamp:

Mar 8, 2017, 3:22:50 PM (9 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

031a2c95, 0e7ea335

Parents:

87c3bef (diff), 6363ad1 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (29 diffs)
• ExpressionNode.cc (modified) (3 diffs)
• ParseNode.h (modified) (12 diffs)
• TypeData.cc (modified) (17 diffs)
• TypeData.h (modified) (4 diffs)
• lex.cc (deleted)
• lex.ll (modified) (2 diffs)
• parser.cc (deleted)
• parser.h (deleted)
• parser.yy (modified) (7 diffs)

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 22:21:06 2017
-// Update Count     : 775
+// Last Modified On : Tue Mar  7 08:02:09 2017
+// Update Count     : 936
 //
 
@@ -19 +19 @@
 #include <algorithm>
 #include <cassert>
+#include <strings.h>                                                                    // ffs
 
 #include "TypeData.h"
@@ -32 +33 @@
 
 // These must remain in the same order as the corresponding DeclarationNode enumerations.
-const char * DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
-const char * DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
-const char * DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
-const char * DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
-const char * DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
-const char * DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
-const char * DeclarationNode::aggregateName[] = { "struct", "union", "context" };
-const char * DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
-const char * DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
+const char * DeclarationNode::storageClassNames[] = { "extern", "static", "auto", "register", "_Thread_local", "NoStorageClassNames" };
+const char * DeclarationNode::funcSpecifierNames[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" };
+const char * DeclarationNode::typeQualifierNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic", "NoTypeQualifierNames" };
+const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
+const char * DeclarationNode::complexTypeNames[] = { "_Complex", "_Imaginary", "NoComplexTypeNames" };
+const char * DeclarationNode::signednessNames[] = { "signed", "unsigned", "NoSignednessNames" };
+const char * DeclarationNode::lengthNames[] = { "short", "long", "long long", "NoLengthNames" };
+const char * DeclarationNode::aggregateNames[] = { "struct", "union", "context", "NoAggregateNames" };
+const char * DeclarationNode::typeClassNames[] = { "otype", "dtype", "ftype", "NoTypeClassNames" };
+const char * DeclarationNode::builtinTypeNames[] = { "__builtin_va_list", "NoBuiltinTypeNames" };
 
 UniqueName DeclarationNode::anonymous( "__anonymous" );
@@ -48 +50 @@
 DeclarationNode::DeclarationNode() :
                 type( nullptr ),
-                storageClass( NoStorageClass ),
                 bitfieldWidth( nullptr ),
-                isInline( false ),
-                isNoreturn( false ),
                 hasEllipsis( false ),
                 linkage( ::linkage ),
@@ -90 +89 @@
 
         newnode->type = maybeClone( type );
-        newnode->storageClass = storageClass;
+        newnode->storageClasses = storageClasses;
         newnode->bitfieldWidth = maybeClone( bitfieldWidth );
-        newnode->isInline = isInline;
-        newnode->isNoreturn = isNoreturn;
+        newnode->funcSpecs = funcSpecs;
         newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
         newnode->hasEllipsis = hasEllipsis;
@@ -118 +116 @@
 }
 
+void DeclarationNode::print_StorageClass( std::ostream & output, StorageClasses storageClasses ) {
+        if ( storageClasses.any() ) {                                                           // function specifiers?
+                for ( unsigned int i = 0; i < DeclarationNode::NoStorageClass; i += 1 ) {
+                        if ( storageClasses[i] ) {
+                                output << DeclarationNode::storageClassNames[i] << ' ';
+                        } // if
+                } // for
+        } // if
+} // print_StorageClass
+
+void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpecifiers funcSpec ) {
+        if ( funcSpec.any() ) {                                                         // function specifiers?
+                for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) {
+                        if ( funcSpec[i] ) {
+                                output << DeclarationNode::funcSpecifierNames[i] << ' ';
+                        } // if
+                } // for
+        } // if
+} // print_FuncSpec
+
 void DeclarationNode::print( std::ostream &os, int indent ) const {
         os << string( indent, ' ' );
@@ -130 +148 @@
         } // if
 
-        if ( storageClass != NoStorageClass ) os << DeclarationNode::storageName[storageClass] << ' ';
-        if ( isInline ) os << DeclarationNode::storageName[Inline] << ' ';
-        if ( isNoreturn ) os << DeclarationNode::storageName[Noreturn] << ' ';
+        print_StorageClass( os, storageClasses );
+        print_FuncSpec( os, funcSpecs );
+
         if ( type ) {
                 type->print( os, indent );
@@ -183 +201 @@
 } // DeclarationNode::newFunction
 
-DeclarationNode * DeclarationNode::newQualifier( Qualifier q ) {
+
+DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->storageClasses[ sc ] = true;
+        return newnode;
+} // DeclarationNode::newStorageClass
+
+DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->funcSpecs[ fs ] = true;
+        return newnode;
+} // DeclarationNode::newFuncSpecifier
+
+DeclarationNode * DeclarationNode::newTypeQualifier( TypeQualifier tq ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData();
-        newnode->type->qualifiers[ q ] = 1;
+        newnode->type->typeQualifiers[ tq ] = true;
         return newnode;
 } // DeclarationNode::newQualifier
+
+DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Basic );
+        newnode->type->basictype = bt;
+        return newnode;
+} // DeclarationNode::newBasicType
+
+DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Basic );
+        newnode->type->complextype = ct;
+        return newnode;
+} // DeclarationNode::newComplexType
+
+DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Basic );
+        newnode->type->signedness = sn;
+        return newnode;
+} // DeclarationNode::newSignedNess
+
+DeclarationNode * DeclarationNode::newLength( Length lnth ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Basic );
+        newnode->type->length = lnth;
+        return newnode;
+} // DeclarationNode::newLength
 
 DeclarationNode * DeclarationNode::newForall( DeclarationNode * forall ) {
@@ -196 +255 @@
         return newnode;
 } // DeclarationNode::newForall
-
-DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->storageClass = sc;
-        return newnode;
-} // DeclarationNode::newStorageClass
-
-DeclarationNode * DeclarationNode::newBasicType( BasicType bt ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->basictype = bt;
-        return newnode;
-} // DeclarationNode::newBasicType
-
-DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->complextype = ct;
-        return newnode;
-} // DeclarationNode::newComplexType
-
-DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->signedness = sn;
-        return newnode;
-} // DeclarationNode::newSignedNess
-
-DeclarationNode * DeclarationNode::newLength( Length lnth ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->length = lnth;
-        return newnode;
-} // DeclarationNode::newLength
 
 DeclarationNode * DeclarationNode::newFromTypedef( string * name ) {
@@ -428 +453 @@
 
 void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
-        TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
+        const TypeData::TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization
 
         if ( (qsrc & qdst).any() ) {                                            // common qualifier ?
-                for ( int i = 0; i < NoQualifier; i += 1 ) {    // find common qualifiers
+                for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers
                         if ( qsrc[i] && qdst[i] ) {
-                                appendError( error, string( "duplicate " ) + DeclarationNode::qualifierName[i] );
+                                appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] );
                         } // if
                 } // for
-        } // if
+        } // for
 } // DeclarationNode::checkQualifiers
 
-void DeclarationNode::checkStorageClasses( DeclarationNode * q ) {
-        if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
-                if ( storageClass == q->storageClass ) {                // duplicate qualifier
-                        appendError( error, string( "duplicate " ) + storageName[ storageClass ] );
-                } else {                                                                                // only one storage class
-                        appendError( error, string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ] );
-                        q->storageClass = storageClass;                         // FIX ERROR, prevent assertions from triggering
-                } // if
-        } // if
-        appendError( error, q->error );
-} // DeclarationNode::checkStorageClasses
-
-DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) {
-        isInline = isInline || q->isInline;
-        isNoreturn = isNoreturn || q->isNoreturn;
-        // do not overwrite an existing value with NoStorageClass
-        if ( q->storageClass != NoStorageClass ) {
-                assert( storageClass == NoStorageClass || storageClass == q->storageClass );
-                storageClass = q->storageClass;
-        } // if
+void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
+        if ( (funcSpecs & src->funcSpecs).any() ) {                     // common specifier ?
+                for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find common specifier
+                        if ( funcSpecs[i] && src->funcSpecs[i] ) {
+                                appendError( error, string( "duplicate " ) + DeclarationNode::funcSpecifierNames[i] );
+                        } // if
+                } // for
+        } // if
+
+        if ( storageClasses != 0 && src->storageClasses != 0 ) { // any reason to check ?
+                if ( (storageClasses & src->storageClasses).any() ) { // duplicates ?
+                        for ( unsigned int i = 0; i < NoStorageClass; i += 1 ) { // find duplicates
+                                if ( storageClasses[i] && src->storageClasses[i] ) {
+                                        appendError( error, string( "duplicate " ) + storageClassNames[i] );
+                                } // if
+                        } // for
+                        // src is the new item being added and has a single bit
+                } else if ( ! src->storageClasses[ Threadlocal ] ) { // conflict ?
+                        appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.to_ulong() ) - 1] +
+                                                 " & " + storageClassNames[ffs( src->storageClasses.to_ulong() ) - 1] );
+                        src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
+                } // if
+        } // if
+
+        appendError( error, src->error );
+} // DeclarationNode::checkSpecifiers
+
+DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
+        funcSpecs = funcSpecs | q->funcSpecs;
+        storageClasses = storageClasses | q->storageClasses;
 
         for ( Attribute *attr: reverseIterate( q->attributes ) ) {
@@ -464 +499 @@
         } // for
         return this;
-} // DeclarationNode::copyStorageClasses
+} // DeclarationNode::copySpecifiers
 
 static void addQualifiersToType( TypeData *&src, TypeData * dst ) {
@@ -481 +516 @@
                 src = nullptr;
         } else {
-                dst->qualifiers |= src->qualifiers;
+                dst->typeQualifiers |= src->typeQualifiers;
         } // if
 } // addQualifiersToType
@@ -488 +523 @@
         if ( ! q ) { delete q; return this; }
 
-        checkStorageClasses( q );
-        copyStorageClasses( q );
+        checkSpecifiers( q );
+        copySpecifiers( q );
 
         if ( ! q->type ) {
@@ -518 +553 @@
         } // if
 
-        checkQualifiers( q->type, type );
+        checkQualifiers( type, q->type );
         addQualifiersToType( q->type, type );
 
@@ -539 +574 @@
                 switch ( dst->kind ) {
                   case TypeData::Unknown:
-                        src->qualifiers |= dst->qualifiers;
+                        src->typeQualifiers |= dst->typeQualifiers;
                         dst = src;
                         src = nullptr;
                         break;
                   case TypeData::Basic:
-                        dst->qualifiers |= src->qualifiers;
+                        dst->typeQualifiers |= src->typeQualifiers;
                         if ( src->kind != TypeData::Unknown ) {
                                 assert( src->kind == TypeData::Basic );
@@ -551 +586 @@
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: ", src );
 
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: ", src );
 
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: ", src );
 
                                 if ( dst->length == DeclarationNode::NoLength ) {
@@ -568 +603 @@
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
+                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: ", src );
                         } // if
                         break;
@@ -580 +615 @@
                                         dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
                                 } // if
-                                dst->base->qualifiers |= src->qualifiers;
+                                dst->base->typeQualifiers |= src->typeQualifiers;
                                 src = nullptr;
                                 break;
@@ -599 +634 @@
 DeclarationNode * DeclarationNode::addType( DeclarationNode * o ) {
         if ( o ) {
-                checkStorageClasses( o );
-                copyStorageClasses( o );
+                checkSpecifiers( o );
+                copySpecifiers( o );
                 if ( o->type ) {
                         if ( ! type ) {
@@ -612 +647 @@
                                                 type->aggInst.hoistType = o->type->enumeration.body;
                                         } // if
-                                        type->qualifiers |= o->type->qualifiers;
+                                        type->typeQualifiers |= o->type->typeQualifiers;
                                 } else {
                                         type = o->type;
@@ -768 +803 @@
                                         p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
                                 } // if
-                                p->type->base->qualifiers |= type->qualifiers;
+                                p->type->base->typeQualifiers |= type->typeQualifiers;
                                 break;
 
@@ -805 +840 @@
                                         lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
                                 } // if
-                                lastArray->base->qualifiers |= type->qualifiers;
+                                lastArray->base->typeQualifiers |= type->typeQualifiers;
                                 break;
                           default:
@@ -854 +889 @@
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
-        assert( storageClass == NoStorageClass );
-        newnode->copyStorageClasses( this );
+        newnode->copySpecifiers( this );
         assert( newName );
         newnode->name = newName;
@@ -864 +898 @@
         if ( ! o ) return nullptr;
 
-        o->copyStorageClasses( this );
+        o->copySpecifiers( this );
         if ( type ) {
                 TypeData * srcType = type;
@@ -956 +990 @@
                                 } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
                                         StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
-                                        auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
+                                        auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
                                         obj->location = cur->location;
                                         * out++ = obj;
@@ -962 +996 @@
                                 } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
                                         UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
-                                        auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
+                                        auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
                                         obj->location = cur->location;
                                         * out++ = obj;
@@ -1005 +1039 @@
         } // if
 
-//      if ( variable.name ) {
         if ( variable.tyClass != NoTypeClass ) {
                 static const TypeDecl::Kind kindMap[] = { TypeDecl::Any, TypeDecl::Dtype, TypeDecl::Ftype, TypeDecl::Ttype };
                 assertf( sizeof(kindMap)/sizeof(kindMap[0] == NoTypeClass-1), "DeclarationNode::build: kindMap is out of sync." );
                 assertf( variable.tyClass < sizeof(kindMap)/sizeof(kindMap[0]), "Variable's tyClass is out of bounds." );
-//              TypeDecl * ret = new TypeDecl( *variable.name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
-                TypeDecl * ret = new TypeDecl( *name, DeclarationNode::NoStorageClass, nullptr, kindMap[ variable.tyClass ] );
+                TypeDecl * ret = new TypeDecl( *name, DeclarationNode::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
                 buildList( variable.assertions, ret->get_assertions() );
                 return ret;
@@ -1017 +1049 @@
 
         if ( type ) {
-                return buildDecl( type, name ? *name : string( "" ), storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
-        } // if
-
-        if ( ! isInline && ! isNoreturn ) {
-                assertf( name, "ObjectDecl are assumed to have names\n" );
-                return (new ObjectDecl( *name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
-        } // if
-
-        throw SemanticError( "invalid function specifier ", this );
+                // Function specifiers can only appear on a function definition/declaration.
+                //
+                //    inline _Noreturn int f();                 // allowed
+                //    inline _Noreturn int g( int i );  // allowed
+                //    inline _Noreturn int i;                   // disallowed
+                if ( type->kind != TypeData::Function && funcSpecs.any() ) {
+                        throw SemanticError( "invalid function specifier for ", this );
+                } // if
+                return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
+        } // if
+
+        // SUE's cannot have function specifiers, either
+        //
+        //    inlne _Noreturn struct S { ... };         // disallowed
+        //    inlne _Noreturn enum   E { ... };         // disallowed
+        if ( funcSpecs.any() ) {
+                throw SemanticError( "invalid function specifier for ", this );
+        } // if
+        assertf( name, "ObjectDecl must a have name\n" );
+        return (new ObjectDecl( *name, storageClasses, linkage, maybeBuild< Expression >( bitfieldWidth ), nullptr, maybeBuild< Initializer >( initializer ) ))->set_asmName( asmName )->set_extension( extension );
 }
 
@@ -1032 +1075 @@
 
         if ( attr.expr ) {
-//              return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() );
                 return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
         } else if ( attr.type ) {
-//              return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() );
                 return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
         } // if

src/Parser/ExpressionNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Sep 16 16:27:44 2016
-// Update Count     : 508
+// Last Modified On : Sat Mar  4 06:58:47 2017
+// Update Count     : 509
 //
 
@@ -173 +173 @@
 
 Expression *build_constantZeroOne( const std::string & str ) {
-        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type*)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) );
+        Expression * ret = new ConstantExpr( Constant( str == "0" ? (Type *)new ZeroType( emptyQualifiers ) : (Type*)new OneType( emptyQualifiers ), str ) );
         delete &str;                                                                            // created by lex
         return ret;
@@ -275 +275 @@
 }
 Expression *build_offsetOf( DeclarationNode *decl_node, NameExpr *member ) {
-        Expression* ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
+        Expression * ret = new UntypedOffsetofExpr( maybeMoveBuildType( decl_node ), member->get_name() );
         delete member;
         return ret;

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 15:22:10 2017
-// Update Count     : 662
+// Last Modified On : Tue Mar  7 08:10:53 2017
+// Update Count     : 726
 //
 
@@ -19 +19 @@
 #include <string>
 #include <list>
+#include <bitset>
 #include <iterator>
 #include <memory>
@@ -39 +40 @@
 //##############################################################################
 
-extern char* yyfilename;
+extern char * yyfilename;
 extern int yylineno;
 
@@ -122 +123 @@
         }
 
-        Expression * build() const { return const_cast<ExpressionNode*>(this)->expr.release(); }
+        Expression * build() const { return const_cast<ExpressionNode *>(this)->expr.release(); }
   private:
         bool extension = false;
@@ -203 +204 @@
         // These must remain in the same order as the corresponding DeclarationNode names.
 
-        // enum StorageClass { Extern, Static, Auto, Register, NoStorageClass };
-        // enum FunctionSpec { Inline, Fortran, Noreturn, NoFunctionSpec };
-        // enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, Threadlocal, Mutex, NoQualifier };
-
-        enum StorageClass { Extern, Static, Auto, Register, Inline, Fortran, Noreturn, Threadlocal, NoStorageClass, };
-        enum Qualifier { Const, Restrict, Volatile, Lvalue, Atomic, NoQualifier };
+        enum StorageClass { Extern, Static, Auto, Register, Threadlocal, NoStorageClass,
+                                                ExternClass = 1 << Extern, StaticClass = 1 << Static, AutoClass = 1 << Auto, RegisterClass = 1 << Register, ThreadlocalClass = 1 << Threadlocal };
+        enum FuncSpecifier { Inline, Noreturn, Fortran, NoFuncSpecifier,
+                                                 InlineSpec = 1 << Inline, NoreturnSpec = 1 << Noreturn, FortranSpec = 1 << Fortran };
+        enum TypeQualifier { Const, Restrict, Volatile, Lvalue, Mutex, Atomic, NoTypeQualifier };
         enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
         enum ComplexType { Complex, Imaginary, NoComplexType };
@@ -217 +217 @@
         enum BuiltinType { Valist, Zero, One, NoBuiltinType };
 
-        static const char * storageName[];
-        static const char * qualifierName[];
-        static const char * basicTypeName[];
-        static const char * complexTypeName[];
-        static const char * signednessName[];
-        static const char * lengthName[];
-        static const char * aggregateName[];
-        static const char * typeClassName[];
-        static const char * builtinTypeName[];
-
-        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
-        static DeclarationNode * newQualifier( Qualifier );
-        static DeclarationNode * newForall( DeclarationNode * );
+        static const char * storageClassNames[];
+        static const char * funcSpecifierNames[];
+        static const char * typeQualifierNames[];
+        static const char * basicTypeNames[];
+        static const char * complexTypeNames[];
+        static const char * signednessNames[];
+        static const char * lengthNames[];
+        static const char * aggregateNames[];
+        static const char * typeClassNames[];
+        static const char * builtinTypeNames[];
+
         static DeclarationNode * newStorageClass( StorageClass );
+        static DeclarationNode * newFuncSpecifier( FuncSpecifier );
+        static DeclarationNode * newTypeQualifier( TypeQualifier );
         static DeclarationNode * newBasicType( BasicType );
         static DeclarationNode * newComplexType( ComplexType );
-        static DeclarationNode * newSignedNess( Signedness sn );
-        static DeclarationNode * newLength( Length lnth );
+        static DeclarationNode * newSignedNess( Signedness );
+        static DeclarationNode * newLength( Length );
         static DeclarationNode * newBuiltinType( BuiltinType );
+        static DeclarationNode * newForall( DeclarationNode * );
         static DeclarationNode * newFromTypedef( std::string * );
+        static DeclarationNode * newFunction( std::string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body, bool newStyle = false );
         static DeclarationNode * newAggregate( Aggregate kind, const std::string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body );
         static DeclarationNode * newEnum( std::string * name, DeclarationNode * constants, bool body );
@@ -263 +265 @@
         DeclarationNode * addQualifiers( DeclarationNode * );
         void checkQualifiers( const TypeData *, const TypeData * );
-        void checkStorageClasses( DeclarationNode * );
-        DeclarationNode * copyStorageClasses( DeclarationNode * );
+        void checkSpecifiers( DeclarationNode * );
+        DeclarationNode * copySpecifiers( DeclarationNode * );
         DeclarationNode * addType( DeclarationNode * );
         DeclarationNode * addTypedef();
@@ -295 +297 @@
 
         Declaration * build() const;
-        ::Type * buildType() const;
+        Type * buildType() const;
 
         bool get_hasEllipsis() const;
@@ -301 +303 @@
         DeclarationNode * extractAggregate() const;
         bool has_enumeratorValue() const { return (bool)enumeratorValue; }
-        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode*>(this)->enumeratorValue.release(); }
+        ExpressionNode * consume_enumeratorValue() const { return const_cast<DeclarationNode *>(this)->enumeratorValue.release(); }
 
         bool get_extension() const { return extension; }
@@ -323 +325 @@
 
         TypeData * type;
-        StorageClass storageClass;
+
+        typedef std::bitset< DeclarationNode::NoStorageClass > StorageClasses;
+        StorageClasses storageClasses;
+        static void print_StorageClass( std::ostream & output, StorageClasses storageClasses );
+
+        typedef std::bitset< DeclarationNode::NoFuncSpecifier > FuncSpecifiers;
+        FuncSpecifiers funcSpecs;
+        static void print_FuncSpec( std::ostream & output, FuncSpecifiers funcSpecs );
+
         ExpressionNode * bitfieldWidth;
-        bool isInline, isNoreturn;
         std::unique_ptr<ExpressionNode> enumeratorValue;
         bool hasEllipsis;
@@ -342 +351 @@
 
 static inline Type * maybeMoveBuildType( const DeclarationNode * orig ) {
-        Type* ret = orig ? orig->buildType() : nullptr;
+        Type * ret = orig ? orig->buildType() : nullptr;
         delete orig;
         return ret;
@@ -357 +366 @@
 
         virtual StatementNode * clone() const final { assert( false ); return nullptr; }
-        Statement * build() const { return const_cast<StatementNode*>(this)->stmt.release(); }
+        Statement * build() const { return const_cast<StatementNode *>(this)->stmt.release(); }
 
         virtual StatementNode * add_label( const std::string * name, DeclarationNode * attr = nullptr ) {

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 21:48:55 2017
-// Update Count     : 485
+// Last Modified On : Tue Mar  7 08:08:21 2017
+// Update Count     : 538
 //
 
@@ -157 +157 @@
 TypeData * TypeData::clone() const {
         TypeData * newtype = new TypeData( kind );
-        newtype->qualifiers = qualifiers;
+        newtype->typeQualifiers = typeQualifiers;
         newtype->base = maybeClone( base );
         newtype->forall = maybeClone( forall );
@@ -226 +226 @@
 
 void TypeData::print( ostream &os, int indent ) const {
-        for ( int i = 0; i < DeclarationNode::NoQualifier; i += 1 ) {
-                if ( qualifiers[i] ) os << DeclarationNode::qualifierName[ i ] << ' ';
+        for ( int i = 0; i < DeclarationNode::NoTypeQualifier; i += 1 ) {
+                if ( typeQualifiers[i] ) os << DeclarationNode::typeQualifierNames[ i ] << ' ';
         } // for
 
@@ -250 +250 @@
                 break;
           case Basic:
-                if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessName[ signedness ] << " ";
-                if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthName[ length ] << " ";
+                if ( signedness != DeclarationNode::NoSignedness ) os << DeclarationNode::signednessNames[ signedness ] << " ";
+                if ( length != DeclarationNode::NoLength ) os << DeclarationNode::lengthNames[ length ] << " ";
                 assert( basictype != DeclarationNode::NoBasicType );
-                os << DeclarationNode::basicTypeName[ basictype ] << " ";
-                if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeName[ complextype ] << " ";
+                os << DeclarationNode::basicTypeNames[ basictype ] << " ";
+                if ( complextype != DeclarationNode::NoComplexType ) os << DeclarationNode::complexTypeNames[ complextype ] << " ";
                 break;
           case Array:
@@ -301 +301 @@
                 break;
           case Aggregate:
-                os << DeclarationNode::aggregateName[ aggregate.kind ] << ' ' << *aggregate.name << endl;
+                os << DeclarationNode::aggregateNames[ aggregate.kind ] << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters " << endl;
@@ -393 +393 @@
         buildList( firstNode, outputList );
         for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i ) {
-                TypeDecl * td = static_cast<TypeDecl*>(*i);
+                TypeDecl * td = static_cast<TypeDecl *>(*i);
                 if ( td->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, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, dtorType, nullptr, false, false ) );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "^?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
 
                         // add copy ctor:  void ?{}(T *, T)
                         FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
-                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, copyCtorType, nullptr, false, false ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
 
                         // add default ctor:  void ?{}(T *)
                         FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
-                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, ctorType, nullptr, false, false ) );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
 
                         // add assignment operator:  T * ?=?(T *, T)
                         FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
-                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
-                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
-                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, assignType, nullptr, false, false ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        assignType->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?=?", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
                 } // if
         } // for
@@ -494 +494 @@
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
         Type::Qualifiers q;
-        q.isConst = td->qualifiers[ DeclarationNode::Const ];
-        q.isVolatile = td->qualifiers[ DeclarationNode::Volatile ];
-        q.isRestrict = td->qualifiers[ DeclarationNode::Restrict ];
-        q.isLvalue = td->qualifiers[ DeclarationNode::Lvalue ];
-        q.isAtomic = td->qualifiers[ DeclarationNode::Atomic ];;
+        q.isConst = td->typeQualifiers[ DeclarationNode::Const ];
+        q.isVolatile = td->typeQualifiers[ DeclarationNode::Volatile ];
+        q.isRestrict = td->typeQualifiers[ DeclarationNode::Restrict ];
+        q.isLvalue = td->typeQualifiers[ DeclarationNode::Lvalue ];
+        q.isAtomic = td->typeQualifiers[ DeclarationNode::Atomic ];;
         return q;
 } // buildQualifiers
@@ -516 +516 @@
           case DeclarationNode::Bool:
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
                 } // if
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
                 } // if
 
@@ -532 +532 @@
 
                 if ( td->length != DeclarationNode::NoLength ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
                 } // if
 
@@ -562 +562 @@
           FloatingPoint: ;
                 if ( td->signedness != DeclarationNode::NoSignedness ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessName[ td->signedness ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::signednessNames[ td->signedness ] + " in type: ", td );
                 } // if
                 if ( td->length == DeclarationNode::Short || td->length == DeclarationNode::LongLong ) {
-                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthName[ td->length ] + " in type: ", td );
+                        throw SemanticError( string( "invalid type specifier " ) + DeclarationNode::lengthNames[ td->length ] + " in type: ", td );
                 } // if
                 if ( td->basictype == DeclarationNode::Float && td->length == DeclarationNode::Long ) {
@@ -732 +732 @@
 } // buildAggInst
 
-NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClass sc ) {
+NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClasses scs ) {
         assert( td->kind == TypeData::Symbolic );
         NamedTypeDecl * ret;
         assert( td->base );
         if ( td->symbolic.isTypedef ) {
-                ret = new TypedefDecl( name, sc, typebuild( td->base ) );
+                ret = new TypedefDecl( name, scs, typebuild( td->base ) );
         } else {
-                ret = new TypeDecl( name, sc, typebuild( td->base ), TypeDecl::Any );
+                ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Any );
         } // if
         buildList( td->symbolic.params, ret->get_parameters() );
@@ -784 +784 @@
 } // buildTypeof
 
-Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClass sc, Expression * bitfieldWidth, bool isInline, bool isNoreturn, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
+Declaration * buildDecl( const TypeData * td, const string &name, DeclarationNode::StorageClasses scs, Expression * bitfieldWidth, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec linkage, ConstantExpr *asmName, Initializer * init, std::list< Attribute * > attributes ) {
         if ( td->kind == TypeData::Function ) {
                 if ( td->function.idList ) {                                    // KR function ?
@@ -792 +792 @@
                 FunctionDecl * decl;
                 Statement * stmt = maybeBuild<Statement>( td->function.body );
-                CompoundStmt * body = dynamic_cast< CompoundStmt* >( stmt );
-                decl = new FunctionDecl( name, sc, linkage, buildFunction( td ), body, isInline, isNoreturn, attributes );
+                CompoundStmt * body = dynamic_cast< CompoundStmt * >( stmt );
+                decl = new FunctionDecl( name, scs, linkage, buildFunction( td ), body, attributes, funcSpec );
                 return decl->set_asmName( asmName );
         } else if ( td->kind == TypeData::Aggregate ) {
@@ -800 +800 @@
                 return buildEnum( td, attributes );
         } else if ( td->kind == TypeData::Symbolic ) {
-                return buildSymbolic( td, name, sc );
+                return buildSymbolic( td, name, scs );
         } else {
-                return (new ObjectDecl( name, sc, linkage, bitfieldWidth, typebuild( td ), init, attributes, isInline, isNoreturn ))->set_asmName( asmName );
+                return (new ObjectDecl( name, scs, linkage, bitfieldWidth, typebuild( td ), init, attributes ))->set_asmName( asmName );
         } // if
         return nullptr;
@@ -820 +820 @@
                         break;
                   default:
-                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType* >( buildDecl( td->base,  "", DeclarationNode::NoStorageClass, nullptr, false, false, LinkageSpec::Cforall, nullptr ) ) );
+                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", DeclarationNode::StorageClasses(), nullptr, DeclarationNode::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
                 } // switch
         } else {
-                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::NoStorageClass, LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
+                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
         } // if
         return ft;
@@ -846 +846 @@
         for ( DeclarationNode * decl = function.oldDeclList; decl != nullptr; decl = dynamic_cast< DeclarationNode * >( decl->get_next() ) ) {
                 // scan ALL parameter names for each declaration name to check for duplicates
-                for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) {
+                for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode * >( param->get_next() ) ) {
                         if ( *decl->name == *param->name ) {
                                 // type set => parameter name already transformed by a declaration names so there is a duplicate
@@ -867 +867 @@
         //    rtb( a, b, c ) const char * b; {} => int rtn( int a, const char * b, int c ) {}
 
-        for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode* >( param->get_next() ) ) {
+        for ( DeclarationNode * param = function.idList; param != nullptr; param = dynamic_cast< DeclarationNode * >( param->get_next() ) ) {
                 if ( ! param->type ) {                                                  // generate type int for empty parameter type
                         param->type = new TypeData( TypeData::Basic );

src/Parser/TypeData.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 17:14:46 2017
-// Update Count     : 158
+// Last Modified On : Tue Mar  7 08:03:53 2017
+// Update Count     : 173
 //
 
@@ -76 +76 @@
         DeclarationNode::Length length = DeclarationNode::NoLength;
         DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
-        typedef std::bitset< DeclarationNode::NoQualifier > Qualifiers;
-        Qualifiers qualifiers;
+        typedef std::bitset< DeclarationNode::NoTypeQualifier > TypeQualifiers;
+        TypeQualifiers typeQualifiers;
         DeclarationNode * forall;
 
@@ -107 +107 @@
 ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes );
 ReferenceToType * buildAggInst( const TypeData * );
-NamedTypeDecl * buildSymbolic( const TypeData *, const std::string &name, DeclarationNode::StorageClass sc );
 TypeDecl * buildVariable( const TypeData * );
 EnumDecl * buildEnum( const TypeData *, std::list< Attribute * > );
@@ -113 +112 @@
 TupleType * buildTuple( const TypeData * );
 TypeofType * buildTypeof( const TypeData * );
-Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClass, Expression *, bool isInline, bool isNoreturn, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
+Declaration * buildDecl( const TypeData *, const std::string &, DeclarationNode::StorageClasses, Expression *, DeclarationNode::FuncSpecifiers funcSpec, LinkageSpec::Spec, ConstantExpr *asmName, Initializer * init = nullptr, std::list< class Attribute * > attributes = std::list< class Attribute * >() );
 FunctionType * buildFunction( const TypeData * );
 void buildKRFunction( const TypeData::Function_t & function );

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Tue Nov 29 11:32:00 2016
- * Update Count     : 501
+ * Last Modified On : Fri Mar  3 22:18:00 2017
+ * Update Count     : 502
  */
 
@@ -235 +235 @@
 long                    { KEYWORD_RETURN(LONG); }
 lvalue                  { KEYWORD_RETURN(LVALUE); }                             // CFA
+mutex                   { KEYWORD_RETURN(MUTEX); }                              // CFA
 _Noreturn               { KEYWORD_RETURN(NORETURN); }                   // C11
 __builtin_offsetof { KEYWORD_RETURN(OFFSETOF); }                // GCC

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Feb 28 09:58:10 2017
-// Update Count     : 2208
+// Last Modified On : Sun Mar  5 15:48:24 2017
+// Update Count     : 2227
 //
 
@@ -91 +91 @@
 // keywords
 %token TYPEDEF
-%token AUTO EXTERN REGISTER STATIC
-%token INLINE                                                                                   // C99
-%token FORTRAN                                                                                  // C99, extension ISO/IEC 9899:1999 Section J.5.9(1)
+%token EXTERN STATIC AUTO REGISTER
+%token THREADLOCAL                                                                              // C11
+%token INLINE FORTRAN                                                                   // C99, extension ISO/IEC 9899:1999 Section J.5.9(1)
+%token NORETURN                                                                                 // C11
 %token CONST VOLATILE
 %token RESTRICT                                                                                 // C99
-%token FORALL LVALUE                                                                    // CFA
+%token ATOMIC                                                                                   // C11
+%token FORALL LVALUE MUTEX                                                              // CFA
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED ZERO_T ONE_T
 %token VALIST                                                                                   // GCC
@@ -102 +104 @@
 %token TYPEOF LABEL                                                                             // GCC
 %token ENUM STRUCT UNION
-%token OTYPE FTYPE DTYPE TTYPE TRAIT                                                    // CFA
+%token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
 %token SIZEOF OFFSETOF
 %token ATTRIBUTE EXTENSION                                                              // GCC
@@ -108 +110 @@
 %token CHOOSE DISABLE ENABLE FALLTHRU TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT        // CFA
 %token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
-%token ALIGNAS ALIGNOF ATOMIC GENERIC NORETURN STATICASSERT THREADLOCAL // C11
+%token ALIGNAS ALIGNOF GENERIC STATICASSERT                             // C11
 
 // names and constants: lexer differentiates between identifier and typedef names
@@ -1400 +1402 @@
 type_qualifier_name:
         CONST
-                { $$ = DeclarationNode::newQualifier( DeclarationNode::Const ); }
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Const ); }
         | RESTRICT
-                { $$ = DeclarationNode::newQualifier( DeclarationNode::Restrict ); }
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Restrict ); }
         | VOLATILE
-                { $$ = DeclarationNode::newQualifier( DeclarationNode::Volatile ); }
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Volatile ); }
         | LVALUE                                                                                        // CFA
-                { $$ = DeclarationNode::newQualifier( DeclarationNode::Lvalue ); }
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Lvalue ); }
+        | MUTEX
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Mutex ); }
         | ATOMIC
-                { $$ = DeclarationNode::newQualifier( DeclarationNode::Atomic ); }
+                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Atomic ); }
         | FORALL '('
                 {
@@ -1448 +1452 @@
         | REGISTER
                 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
-        | INLINE                                                                                        // C99
-                //{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Inline ); }
-                { $$ = new DeclarationNode; $$->isInline = true; }
-        | FORTRAN                                                                                       // C99
-                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Fortran ); }
-        | NORETURN                                                                                      // C11
-                //{ $$ = DeclarationNode::newStorageClass( DeclarationNode::Noreturn ); }
-                { $$ = new DeclarationNode; $$->isNoreturn = true; }
         | THREADLOCAL                                                                           // C11
                 { $$ = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
+                // Put function specifiers here to simplify parsing rules, but separate them semantically.
+        | INLINE                                                                                        // C99
+                { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Inline ); }
+        | FORTRAN                                                                                       // C99
+                { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Fortran ); }
+        | NORETURN                                                                                      // C11
+                { $$ = DeclarationNode::newFuncSpecifier( DeclarationNode::Noreturn ); }
         ;
 
@@ -2033 +2036 @@
                 { $$ = $3->addQualifiers( $1 ); }
         | type_declaring_list ',' type_declarator
-                { $$ = $1->appendList( $3->copyStorageClasses( $1 ) ); }
+                { $$ = $1->appendList( $3->copySpecifiers( $1 ) ); }
         ;