Changes in src/Parser/DeclarationNode.cc [e496303:c3396e0]

File:

• src/Parser/DeclarationNode.cc (modified) (18 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 : Tue Mar 14 14:45:52 2017
-// Update Count     : 973
+// Last Modified On : Tue Mar  7 17:28:56 2017
+// Update Count     : 937
 //
 
@@ -90 +90 @@
         newnode->type = maybeClone( type );
         newnode->storageClasses = storageClasses;
+        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
         newnode->funcSpecs = funcSpecs;
-        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
         newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
         newnode->hasEllipsis = hasEllipsis;
@@ -117 +117 @@
 
 void DeclarationNode::print_StorageClass( std::ostream & output, StorageClasses storageClasses ) {
-        if ( storageClasses.val != 0 ) {                                        // storage classes ?
+        if ( storageClasses.any() ) {                                                           // function specifiers?
                 for ( unsigned int i = 0; i < DeclarationNode::NoStorageClass; i += 1 ) {
                         if ( storageClasses[i] ) {
@@ -127 +127 @@
 
 void DeclarationNode::print_FuncSpec( std::ostream & output, DeclarationNode::FuncSpecifiers funcSpec ) {
-        if ( funcSpec.val != 0 ) {                                                      // function specifiers ?
+        if ( funcSpec.any() ) {                                                         // function specifiers?
                 for ( unsigned int i = 0; i < DeclarationNode::NoFuncSpecifier; i += 1 ) {
                         if ( funcSpec[i] ) {
@@ -202 +202 @@
 
 
-DeclarationNode * DeclarationNode::newStorageClass( StorageClasses sc ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->storageClasses = sc;
+DeclarationNode * DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->storageClasses[ sc ] = true;
         return newnode;
 } // DeclarationNode::newStorageClass
 
-DeclarationNode * DeclarationNode::newFuncSpecifier( FuncSpecifiers fs ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->funcSpecs = fs;
+DeclarationNode * DeclarationNode::newFuncSpecifier( DeclarationNode::FuncSpecifier fs ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->funcSpecs[ fs ] = true;
         return newnode;
 } // DeclarationNode::newFuncSpecifier
 
-DeclarationNode * DeclarationNode::newTypeQualifier( TypeQualifiers tq ) {
+DeclarationNode * DeclarationNode::newTypeQualifier( TypeQualifier tq ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData();
-        newnode->type->typeQualifiers = tq;
+        newnode->type->typeQualifiers[ tq ] = true;
         return newnode;
 } // DeclarationNode::newQualifier
@@ -457 +457 @@
 
 void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
-        const TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization
-
-        if ( (qsrc.val & qdst.val) != 0 ) {                                     // duplicates ?
-                for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find duplicates
+        const TypeData::TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization
+
+        if ( (qsrc & qdst).any() ) {                                            // common qualifier ?
+                for ( unsigned int i = 0; i < NoTypeQualifier; i += 1 ) { // find common qualifiers
                         if ( qsrc[i] && qdst[i] ) {
                                 appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] );
@@ -469 +469 @@
 
 void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
-        if ( (funcSpecs.val & src->funcSpecs.val) != 0 ) {                // duplicates ?
-                for ( unsigned int i = 0; i < NoFuncSpecifier; i += 1 ) { // find duplicates
+        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] );
@@ -477 +477 @@
         } // if
 
-        if ( storageClasses.val != 0 && src->storageClasses.val != 0 ) { // any reason to check ?
-                if ( (storageClasses.val & src->storageClasses.val ) != 0 ) { // duplicates ?
+        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] ) {
@@ -485 +485 @@
                         } // for
                         // src is the new item being added and has a single bit
-                } else if ( ! src->storageClasses.is_threadlocal ) { // conflict ?
-                        appendError( error, string( "conflicting " ) + storageClassNames[ffs( storageClasses.val ) - 1] +
-                                                 " & " + storageClassNames[ffs( src->storageClasses.val ) - 1] );
-                        src->storageClasses.val = 0;                            // FIX to preserve invariant of one basic storage specifier
+                } 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
@@ -496 +496 @@
 
 DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
-        funcSpecs.val = funcSpecs.val | q->funcSpecs.val;
-        storageClasses.val = storageClasses.val | q->storageClasses.val;
+        funcSpecs = funcSpecs | q->funcSpecs;
+        storageClasses = storageClasses | q->storageClasses;
 
         for ( Attribute *attr: reverseIterate( q->attributes ) ) {
@@ -520 +520 @@
                 src = nullptr;
         } else {
-                dst->typeQualifiers.val |= src->typeQualifiers.val;
+                dst->typeQualifiers |= src->typeQualifiers;
         } // if
 } // addQualifiersToType
@@ -578 +578 @@
                 switch ( dst->kind ) {
                   case TypeData::Unknown:
-                        src->typeQualifiers.val |= dst->typeQualifiers.val;
+                        src->typeQualifiers |= dst->typeQualifiers;
                         dst = src;
                         src = nullptr;
                         break;
                   case TypeData::Basic:
-                        dst->typeQualifiers.val |= src->typeQualifiers.val;
+                        dst->typeQualifiers |= src->typeQualifiers;
                         if ( src->kind != TypeData::Unknown ) {
                                 assert( src->kind == TypeData::Basic );
@@ -619 +619 @@
                                         dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
                                 } // if
-                                dst->base->typeQualifiers.val |= src->typeQualifiers.val;
+                                dst->base->typeQualifiers |= src->typeQualifiers;
                                 src = nullptr;
                                 break;
@@ -651 +651 @@
                                                 type->aggInst.hoistType = o->type->enumeration.body;
                                         } // if
-                                        type->typeQualifiers.val |= o->type->typeQualifiers.val;
+                                        type->typeQualifiers |= o->type->typeQualifiers;
                                 } else {
                                         type = o->type;
@@ -807 +807 @@
                                         p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
                                 } // if
-                                p->type->base->typeQualifiers.val |= type->typeQualifiers.val;
+                                p->type->base->typeQualifiers |= type->typeQualifiers;
                                 break;
 
@@ -844 +844 @@
                                         lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
                                 } // if
-                                lastArray->base->typeQualifiers.val |= type->typeQualifiers.val;
+                                lastArray->base->typeQualifiers |= type->typeQualifiers;
                                 break;
                           default:
@@ -1058 +1058 @@
                 //    inline _Noreturn int g( int i );  // allowed
                 //    inline _Noreturn int i;                   // disallowed
-                if ( type->kind != TypeData::Function && funcSpecs.val != 0 ) {
+                if ( type->kind != TypeData::Function && funcSpecs.any() ) {
                         throw SemanticError( "invalid function specifier for ", this );
                 } // if
@@ -1068 +1068 @@
         //    inlne _Noreturn struct S { ... };         // disallowed
         //    inlne _Noreturn enum   E { ... };         // disallowed
-        if ( funcSpecs.val != 0 ) {
+        if ( funcSpecs.any() ) {
                 throw SemanticError( "invalid function specifier for ", this );
         } // if