Changeset 6f95000 for src/Parser

Timestamp:

Mar 16, 2017, 6:14:27 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

395fc37

Parents:

d6d747d

Message:

more cleanup for bit-field type usage and create struct forward for typedef

Location:

src/Parser

Files:

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

src/Parser/parser.yy ¶

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Mar 16 08:36:17 2017
-// Update Count     : 2310
+// Last Modified On : Thu Mar 16 12:57:03 2017
+// Update Count     : 2316
 //
 
@@ -1608 +1608 @@
 aggregate_type:                                                                                 // struct, union
         aggregate_key attribute_list_opt '{' field_declaration_list '}'
-                { $$ = DeclarationNode::newAggregate( $1, nullptr, nullptr, $4, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), nullptr, $4, true )->addQualifiers( $2 ); }
         | aggregate_key attribute_list_opt no_attr_identifier_or_type_name
                 { typedefTable.makeTypedef( *$3 ); }
@@ -1614 +1614 @@
                 { $$ = DeclarationNode::newAggregate( $1, $3, nullptr, $6, true )->addQualifiers( $2 ); }
         | aggregate_key attribute_list_opt '(' type_name_list ')' '{' field_declaration_list '}' // CFA
-                { $$ = DeclarationNode::newAggregate( $1, nullptr, $4, $7, false )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newAggregate( $1, new string( DeclarationNode::anonymous.newName() ), $4, $7, false )->addQualifiers( $2 ); }
         | aggregate_type_nobody
         ;
@@ -1684 +1684 @@
         // empty
                 { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
-        // '@' // empty
-        //      { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
+        // '@'
+        //      { $$ = DeclarationNode::newName( new string( DeclarationNode::anonymous.newName() ) ); } // CFA, no field name
         | bit_subrange_size                                                                     // no field name
                 { $$ = DeclarationNode::newBitfield( $1 ); }
@@ -1711 +1711 @@
 enum_type:                                                                                              // enum
         ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
-                { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
+                { $$ = DeclarationNode::newEnum( new string( DeclarationNode::anonymous.newName() ), $4, true )->addQualifiers( $2 ); }
         | ENUM attribute_list_opt no_attr_identifier_or_type_name
                 { typedefTable.makeTypedef( *$3 ); }