Changeset 738e304

Timestamp:

Mar 15, 2017, 10:46:40 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:

905eca1

Parents:

f2e40a9f

git-author:

Peter A. Buhr <pabuhr@…> (03/15/17 22:42:52)

git-committer:

Peter A. Buhr <pabuhr@…> (03/15/17 22:46:40)

Message:

merge qualifier types and use the one in Type

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (12 diffs)
• ParseNode.h (modified) (4 diffs)
• TypeData.cc (modified) (4 diffs)
• TypeData.h (modified) (2 diffs)
• parser.yy (modified) (4 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 22:42:54 2017
-// Update Count     : 974
+// Last Modified On : Wed Mar 15 22:31:36 2017
+// Update Count     : 983
 //
 
@@ -35 +35 @@
 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" };
@@ -214 +213 @@
 } // DeclarationNode::newFuncSpecifier
 
-DeclarationNode * DeclarationNode::newTypeQualifier( TypeQualifiers tq ) {
+DeclarationNode * DeclarationNode::newTypeQualifier( Type::Qualifiers tq ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData();
-        newnode->type->typeQualifiers = tq;
+        newnode->type->qualifiers = tq;
         return newnode;
 } // DeclarationNode::newQualifier
@@ -457 +456 @@
 
 void DeclarationNode::checkQualifiers( const TypeData * src, const TypeData * dst ) {
-        const TypeQualifiers qsrc = src->typeQualifiers, qdst = dst->typeQualifiers; // optimization
+        const Type::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
 
         if ( (qsrc.val & qdst.val) != 0 ) {                                     // duplicates ?
-                for ( unsigned int i = 0; i < NumTypeQualifier; i += 1 ) { // find duplicates
+                for ( unsigned int i = 0; i < Type::NumTypeQualifier; i += 1 ) { // find duplicates
                         if ( qsrc[i] && qdst[i] ) {
-                                appendError( error, string( "duplicate " ) + DeclarationNode::typeQualifierNames[i] );
+                                appendError( error, string( "duplicate " ) + Type::QualifierNames[i] );
                         } // if
                 } // for
@@ -469 +468 @@
 
 void DeclarationNode::checkSpecifiers( DeclarationNode * src ) {
-        if ( (funcSpecs.val & src->funcSpecs.val) != 0 ) {                // duplicates ?
+        if ( (funcSpecs.val & src->funcSpecs.val) != 0 ) {      // duplicates ?
                 for ( unsigned int i = 0; i < NumFuncSpecifier; i += 1 ) { // find duplicates
                         if ( funcSpecs[i] && src->funcSpecs[i] ) {
@@ -496 +495 @@
 
 DeclarationNode * DeclarationNode::copySpecifiers( DeclarationNode * q ) {
-        funcSpecs.val = funcSpecs.val | q->funcSpecs.val;
-        storageClasses.val = storageClasses.val | q->storageClasses.val;
+        funcSpecs.val |= q->funcSpecs.val;
+        storageClasses.val |= q->storageClasses.val;
 
         for ( Attribute *attr: reverseIterate( q->attributes ) ) {
@@ -520 +519 @@
                 src = nullptr;
         } else {
-                dst->typeQualifiers.val |= src->typeQualifiers.val;
+                dst->qualifiers += src->qualifiers;
         } // if
 } // addQualifiersToType
@@ -578 +577 @@
                 switch ( dst->kind ) {
                   case TypeData::Unknown:
-                        src->typeQualifiers.val |= dst->typeQualifiers.val;
+                        src->qualifiers += dst->qualifiers;
                         dst = src;
                         src = nullptr;
                         break;
                   case TypeData::Basic:
-                        dst->typeQualifiers.val |= src->typeQualifiers.val;
+                        dst->qualifiers += src->qualifiers;
                         if ( src->kind != TypeData::Unknown ) {
                                 assert( src->kind == TypeData::Basic );
@@ -619 +618 @@
                                         dst->base->aggInst.params = maybeClone( src->aggregate.actuals );
                                 } // if
-                                dst->base->typeQualifiers.val |= src->typeQualifiers.val;
+                                dst->base->qualifiers += src->qualifiers;
                                 src = nullptr;
                                 break;
@@ -651 +650 @@
                                                 type->aggInst.hoistType = o->type->enumeration.body;
                                         } // if
-                                        type->typeQualifiers.val |= o->type->typeQualifiers.val;
+                                        type->qualifiers += o->type->qualifiers;
                                 } else {
                                         type = o->type;
@@ -807 +806 @@
                                         p->type->base->aggInst.params = maybeClone( type->aggregate.actuals );
                                 } // if
-                                p->type->base->typeQualifiers.val |= type->typeQualifiers.val;
+                                p->type->base->qualifiers += type->qualifiers;
                                 break;
 
@@ -832 +831 @@
 
 DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) {
-        if ( a ) {
-                assert( a->type->kind == TypeData::Array );
-                TypeData * lastArray = findLast( a->type );
-                if ( type ) {
-                        switch ( type->kind ) {
-                          case TypeData::Aggregate:
-                          case TypeData::Enum:
-                                lastArray->base = new TypeData( TypeData::AggregateInst );
-                                lastArray->base->aggInst.aggregate = type;
-                                if ( type->kind == TypeData::Aggregate ) {
-                                        lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
-                                } // if
-                                lastArray->base->typeQualifiers.val |= type->typeQualifiers.val;
-                                break;
-                          default:
-                                lastArray->base = type;
-                        } // switch
-                        type = nullptr;
-                } // if
-                delete this;
-                return a;
-        } else {
-                return this;
-        } // if
+  if ( ! a ) return this;
+        assert( a->type->kind == TypeData::Array );
+        TypeData * lastArray = findLast( a->type );
+        if ( type ) {
+                switch ( type->kind ) {
+                  case TypeData::Aggregate:
+                  case TypeData::Enum:
+                        lastArray->base = new TypeData( TypeData::AggregateInst );
+                        lastArray->base->aggInst.aggregate = type;
+                        if ( type->kind == TypeData::Aggregate ) {
+                                lastArray->base->aggInst.params = maybeClone( type->aggregate.actuals );
+                        } // if
+                        lastArray->base->qualifiers += type->qualifiers;
+                        break;
+                  default:
+                        lastArray->base = type;
+                } // switch
+                type = nullptr;
+        } // if
+        delete this;
+        return a;
 }
 

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 14 22:41:37 2017
-// Update Count     : 758
+// Last Modified On : Wed Mar 15 22:17:50 2017
+// Update Count     : 762
 //
 
@@ -231 +231 @@
         }; // FuncSpecifiers
 
-        enum { Const = 1 << 0, Restrict = 1 << 1, Volatile = 1 << 2, Lvalue = 1 << 3, Mutex = 1 << 4, Atomic = 1 << 5, NumTypeQualifier = 6 };
-        union TypeQualifiers {
-                unsigned int val;
-                struct {
-                        bool is_const : 1;
-                        bool is_restrict : 1;
-                        bool is_volatile : 1;
-                        bool is_lvalue : 1;
-                        bool is_mutex : 1;
-                        bool is_atomic : 1;
-                };
-                TypeQualifiers() : val( 0 ) {}
-                TypeQualifiers( unsigned int val ) : val( val ) {}
-                bool operator[]( unsigned int i ) const { return val & (1 << i); }
-        }; // TypeQualifiers
-
         enum BasicType { Void, Bool, Char, Int, Float, Double, LongDouble, NoBasicType };
         enum ComplexType { Complex, Imaginary, NoComplexType };
@@ -257 +241 @@
         static const char * storageClassNames[];
         static const char * funcSpecifierNames[];
-        static const char * typeQualifierNames[];
         static const char * basicTypeNames[];
         static const char * complexTypeNames[];
@@ -268 +251 @@
         static DeclarationNode * newStorageClass( StorageClasses );
         static DeclarationNode * newFuncSpecifier( FuncSpecifiers );
-        static DeclarationNode * newTypeQualifier( TypeQualifiers );
+        static DeclarationNode * newTypeQualifier( Type::Qualifiers );
         static DeclarationNode * newBasicType( BasicType );
         static DeclarationNode * newComplexType( ComplexType );

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 14 22:43:20 2017
-// Update Count     : 549
+// Last Modified On : Wed Mar 15 22:22:29 2017
+// Update Count     : 555
 //
 
@@ -157 +157 @@
 TypeData * TypeData::clone() const {
         TypeData * newtype = new TypeData( kind );
-        newtype->typeQualifiers = typeQualifiers;
+        newtype->qualifiers = qualifiers;
         newtype->base = maybeClone( base );
         newtype->forall = maybeClone( forall );
@@ -226 +226 @@
 
 void TypeData::print( ostream &os, int indent ) const {
-        for ( int i = 0; i < DeclarationNode::NumTypeQualifier; i += 1 ) {
-                if ( typeQualifiers[i] ) os << DeclarationNode::typeQualifierNames[ i ] << ' ';
+        for ( int i = 0; i < Type::NumTypeQualifier; i += 1 ) {
+                if ( qualifiers[i] ) os << Type::QualifierNames[ i ] << ' ';
         } // for
 
@@ -493 +493 @@
 
 Type::Qualifiers buildQualifiers( const TypeData * td ) {
-        Type::Qualifiers q;
-        q.isConst = td->typeQualifiers.is_const;
-        q.isVolatile = td->typeQualifiers.is_volatile;
-        q.isRestrict = td->typeQualifiers.is_restrict;
-        q.isLvalue = td->typeQualifiers.is_lvalue;
-        q.isAtomic = td->typeQualifiers.is_atomic;
-        return q;
+        return td->qualifiers;
 } // buildQualifiers
 

src/Parser/TypeData.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Mar 14 16:51:26 2017
-// Update Count     : 181
+// Last Modified On : Wed Mar 15 22:10:23 2017
+// Update Count     : 183
 //
 
@@ -75 +75 @@
         DeclarationNode::BuiltinType builtintype = DeclarationNode::NoBuiltinType;
 
-        DeclarationNode::TypeQualifiers typeQualifiers;
+        Type::Qualifiers qualifiers;
         DeclarationNode * forall;
 

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  9 21:40:20 2017
-// Update Count     : 2292
+// Last Modified On : Wed Mar 15 22:06:22 2017
+// Update Count     : 2308
 //
 
@@ -437 +437 @@
 argument_expression:
         // empty
-                { $$ = nullptr; }                                                               // use default argument
+                { $$ = nullptr; }
+        // | '@'                                                                                                // use default argument
+        //      { $$ = new ExpressionNode( build_constantInteger( *new string( "2" ) ) ); }
         | assignment_expression
         ;
@@ -1404 +1406 @@
 type_qualifier_name:
         CONST
-                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Const ); }
+                { $$ = DeclarationNode::newTypeQualifier( Type::Const ); }
         | RESTRICT
-                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Restrict ); }
+                { $$ = DeclarationNode::newTypeQualifier( Type::Restrict ); }
         | VOLATILE
-                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Volatile ); }
+                { $$ = DeclarationNode::newTypeQualifier( Type::Volatile ); }
         | LVALUE                                                                                        // CFA
-                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Lvalue ); }
+                { $$ = DeclarationNode::newTypeQualifier( Type::Lvalue ); }
         | MUTEX
-                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Mutex ); }
+                { $$ = DeclarationNode::newTypeQualifier( Type::Mutex ); }
         | ATOMIC
-                { $$ = DeclarationNode::newTypeQualifier( DeclarationNode::Atomic ); }
+                { $$ = DeclarationNode::newTypeQualifier( Type::Atomic ); }
         | FORALL '('
                 {
@@ -1682 +1684 @@
         // empty
                 { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
+        // '@' // empty
+        //      { $$ = DeclarationNode::newName( 0 ); /* XXX */ } // CFA, no field name
         | bit_subrange_size                                                                     // no field name
                 { $$ = DeclarationNode::newBitfield( $1 ); }