Changes in src/Parser/DeclarationNode.cc [615a096:fb04321]

File:

• src/Parser/DeclarationNode.cc (modified) (14 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 : Fri Mar 17 08:46:05 2017
-// Update Count     : 1017
+// Last Modified On : Thu Mar 16 09:10:57 2017
+// Update Count     : 1007
 //
 
@@ -19 +19 @@
 #include <algorithm>
 #include <cassert>
+#include <strings.h>                                                                    // ffs
 
 #include "TypeData.h"
@@ -242 +243 @@
 
 DeclarationNode * DeclarationNode::newAggregate( Aggregate kind, const string * name, ExpressionNode * actuals, DeclarationNode * fields, bool body ) {
-        assert( name );
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
         newnode->type->aggregate.kind = kind;
-        newnode->type->aggregate.name = name;
+        if ( name ) {
+                newnode->type->aggregate.name = name;
+        } else {                                                                                        // anonymous aggregate ?
+                newnode->type->aggregate.name = new string( anonymous.newName() );
+        } // if
         newnode->type->aggregate.actuals = actuals;
         newnode->type->aggregate.fields = fields;
@@ -254 +258 @@
 
 DeclarationNode * DeclarationNode::newEnum( string * name, DeclarationNode * constants, bool body ) {
-        assert( name );
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Enum );
-        newnode->type->enumeration.name = name;
+        if ( name ) {
+                newnode->type->enumeration.name = name;
+        } else {                                                                                        // anonymous aggregate ?
+                newnode->type->enumeration.name = new string( anonymous.newName() );
+        } // if
         newnode->type->enumeration.constants = constants;
         newnode->type->enumeration.body = body;
@@ -429 +436 @@
         const Type::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
 
-        if ( (qsrc & qdst).any() ) {                                            // duplicates ?
+        if ( (qsrc.val & qdst.val) != 0 ) {                                     // duplicates ?
                 for ( unsigned int i = 0; i < Type::NumTypeQualifier; i += 1 ) { // find duplicates
                         if ( qsrc[i] && qdst[i] ) {
-                                appendError( error, string( "duplicate " ) + Type::QualifiersNames[i] );
+                                appendError( error, string( "duplicate " ) + Type::Qualifiers::Names[i] );
                         } // if
                 } // for
@@ -439 +446 @@
 
 void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
-        if ( (funcSpecs & src->funcSpecs).any() ) {                     // duplicates ?
+        if ( (funcSpecs.val & src->funcSpecs.val) != 0 ) {      // duplicates ?
                 for ( unsigned int i = 0; i < Type::NumFuncSpecifier; i += 1 ) { // find duplicates
                         if ( funcSpecs[i] && src->funcSpecs[i] ) {
-                                appendError( error, string( "duplicate " ) + Type::FuncSpecifiersNames[i] );
+                                appendError( error, string( "duplicate " ) + Type::FuncSpecifiers::Names[i] );
                         } // if
                 } // for
@@ -448 +455 @@
 
         if ( storageClasses.any() && src->storageClasses.any() ) { // any reason to check ?
-                if ( (storageClasses & src->storageClasses ).any() ) { // duplicates ?
+                if ( (storageClasses.val & src->storageClasses.val ) != 0 ) { // duplicates ?
                         for ( unsigned int i = 0; i < Type::NumStorageClass; i += 1 ) { // find duplicates
                                 if ( storageClasses[i] && src->storageClasses[i] ) {
-                                        appendError( error, string( "duplicate " ) + Type::StorageClassesNames[i] );
+                                        appendError( error, string( "duplicate " ) + Type::StorageClasses::Names[i] );
                                 } // if
                         } // for
                         // src is the new item being added and has a single bit
                 } else if ( ! src->storageClasses.is_threadlocal ) { // conflict ?
-                        appendError( error, string( "conflicting " ) + Type::StorageClassesNames[storageClasses.ffs()] +
-                                                 " & " + Type::StorageClassesNames[src->storageClasses.ffs()] );
-                        src->storageClasses.reset();                            // FIX to preserve invariant of one basic storage specifier
+                        appendError( error, string( "conflicting " ) + Type::StorageClasses::Names[ffs( storageClasses.val ) - 1] +
+                                                 " & " + Type::StorageClasses::Names[ffs( src->storageClasses.val ) - 1] );
+                        src->storageClasses.val = 0;                            // FIX to preserve invariant of one basic storage specifier
                 } // if
         } // if
@@ -466 +473 @@
 
 DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
-        funcSpecs |= q->funcSpecs;
-        storageClasses |= q->storageClasses;
+        funcSpecs.val |= q->funcSpecs.val;
+        storageClasses.val |= q->storageClasses.val;
 
         for ( Attribute *attr: reverseIterate( q->attributes ) ) {
@@ -490 +497 @@
                 src = nullptr;
         } else {
-                dst->qualifiers |= src->qualifiers;
+                dst->qualifiers += src->qualifiers;
         } // if
 } // addQualifiersToType
@@ -548 +555 @@
                 switch ( dst->kind ) {
                   case TypeData::Unknown:
-                        src->qualifiers |= dst->qualifiers;
+                        src->qualifiers += dst->qualifiers;
                         dst = src;
                         src = nullptr;
                         break;
                   case TypeData::Basic:
-                        dst->qualifiers |= src->qualifiers;
+                        dst->qualifiers += src->qualifiers;
                         if ( src->kind != TypeData::Unknown ) {
                                 assert( src->kind == TypeData::Basic );
@@ -589 +596 @@
                                         dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
                                 } // if
-                                dst->base->qualifiers |= src->qualifiers;
+                                dst->base->qualifiers += src->qualifiers;
                                 src = nullptr;
                                 break;
@@ -621 +628 @@
                                                 type->aggInst.hoistType = o->type->enumeration.body;
                                         } // if
-                                        type->qualifiers |= o->type->qualifiers;
+                                        type->qualifiers += o->type->qualifiers;
                                 } else {
                                         type = o->type;
@@ -777 +784 @@
                                         p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
                                 } // if
-                                p->type->base->qualifiers |= type->qualifiers;
+                                p->type->base->qualifiers += type->qualifiers;
                                 break;
 
@@ -814 +821 @@
                                 lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
                         } // if
-                        lastArray->base->qualifiers |= type->qualifiers;
+                        lastArray->base->qualifiers += type->qualifiers;
                         break;
                   default: