Changeset 68fe077a for src/Parser

Timestamp:

Mar 16, 2017, 8:23:42 AM (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:

26ba208

Parents:

6e8bd43

git-author:

Peter A. Buhr <pabuhr@…> (03/16/17 08:19:39)

git-committer:

Peter A. Buhr <pabuhr@…> (03/16/17 08:23:42)

Message:

move type StorageClasses? from DeclarationNode? to Type

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (7 diffs)
• ParseNode.h (modified) (4 diffs)
• TypeData.cc (modified) (5 diffs)
• TypeData.h (modified) (2 diffs)
• parser.yy (modified) (2 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 : Wed Mar 15 23:36:49 2017
-// Update Count     : 997
+// Last Modified On : Thu Mar 16 07:59:40 2017
+// Update Count     : 1003
 //
 
@@ -33 +33 @@
 
 // These must remain in the same order as the corresponding DeclarationNode enumerations.
-const char * DeclarationNode::StorageClasses::Names[] = { "extern", "static", "auto", "register", "_Thread_local", "NoStorageClassNames" };
 const char * DeclarationNode::FuncSpecifiers::Names[] = { "inline", "fortran", "_Noreturn", "NoFunctionSpecifierNames" };
 const char * DeclarationNode::basicTypeNames[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicTypeNames" };
@@ -181 +180 @@
 
 
-DeclarationNode * DeclarationNode::newStorageClass( StorageClasses sc ) {
+DeclarationNode * DeclarationNode::newStorageClass( Type::StorageClasses sc ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->storageClasses = sc;
@@ -458 +457 @@
         if ( storageClasses.any() && src->storageClasses.any() ) { // any reason to check ?
                 if ( (storageClasses.val & src->storageClasses.val ) != 0 ) { // duplicates ?
-                        for ( unsigned int i = 0; i < NumStorageClass; i += 1 ) { // find duplicates
+                        for ( unsigned int i = 0; i < Type::NumStorageClass; i += 1 ) { // find duplicates
                                 if ( storageClasses[i] && src->storageClasses[i] ) {
-                                        appendError( error, string( "duplicate " ) + StorageClasses::Names[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 " ) + StorageClasses::Names[ffs( storageClasses.val ) - 1] +
-                                                 " & " + StorageClasses::Names[ffs( src->storageClasses.val ) - 1] );
+                        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
@@ -970 +969 @@
                                 } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
                                         StructInstType * inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
-                                        auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                        auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
                                         obj->location = cur->location;
                                         * out++ = obj;
@@ -976 +975 @@
                                 } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
                                         UnionInstType * inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
-                                        auto obj = new ObjectDecl( "", DeclarationNode::StorageClasses(), linkage, nullptr, inst, nullptr );
+                                        auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
                                         obj->location = cur->location;
                                         * out++ = obj;
@@ -1023 +1022 @@
                 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( *name, DeclarationNode::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
+                TypeDecl * ret = new TypeDecl( *name, Type::StorageClasses(), nullptr, kindMap[ variable.tyClass ] );
                 buildList( variable.assertions, ret->get_assertions() );
                 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 : Wed Mar 15 23:31:02 2017
-// Update Count     : 770
+// Last Modified On : Thu Mar 16 07:46:33 2017
+// Update Count     : 772
 //
 
@@ -201 +201 @@
 class DeclarationNode : public ParseNode {
   public:
-        // These must remain in the same order as the corresponding DeclarationNode names.
-
-        enum { Extern = 1 << 0, Static = 1 << 1, Auto = 1 << 2, Register = 1 << 3, Threadlocal = 1 << 4, NumStorageClass = 5 };
-        union StorageClasses {
-                static const char * Names[];
-                unsigned int val;
-                struct {
-                        bool is_extern : 1;
-                        bool is_static : 1;
-                        bool is_auto : 1;
-                        bool is_register : 1;
-                        bool is_threadlocal : 1;
-                };
-
-                StorageClasses() : val( 0 ) {}
-                StorageClasses( unsigned int val ) : val( val ) {}
-                bool operator[]( unsigned int i ) const { return val & (1 << i); }
-                bool any() const { return val != 0; }
-                void print( std::ostream & os ) const {
-                        if ( (*this).any() ) {                                          // any storage classes ?
-                                for ( unsigned int i = 0; i < NumStorageClass; i += 1 ) {
-                                        if ( (*this)[i] ) {
-                                                os << StorageClasses::Names[i] << ' ';
-                                        } // if
-                                } // for
-                        } // if
-                }
-        }; // StorageClasses
-
         enum { Inline = 1 << 0, Noreturn = 1 << 1, Fortran = 1 << 2, NumFuncSpecifier = 3 };
         union FuncSpecifiers {
@@ -270 +241 @@
         static const char * builtinTypeNames[];
 
-        static DeclarationNode * newStorageClass( StorageClasses );
+        static DeclarationNode * newStorageClass( Type::StorageClasses );
         static DeclarationNode * newFuncSpecifier( FuncSpecifiers );
         static DeclarationNode * newTypeQualifier( Type::Qualifiers );
@@ -368 +339 @@
         TypeData * type;
 
-        StorageClasses storageClasses;
+        Type::StorageClasses storageClasses;
         FuncSpecifiers funcSpecs;
 

src/Parser/TypeData.cc ¶

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 22:53:04 2017
-// Update Count     : 557
+// Last Modified On : Thu Mar 16 07:54:50 2017
+// Update Count     : 558
 //
 
@@ -398 +398 @@
                         // add dtor:  void ^?{}(T *)
                         FunctionType * dtorType = new FunctionType( Type::Qualifiers(), 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 ) );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "^?{}", Type::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::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 ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", Type::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::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 ) );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?{}", Type::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::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 ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        assignType->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
+                        td->get_assertions().push_front( new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Cforall, assignType, nullptr ) );
                 } // if
         } // for
@@ -726 +726 @@
 } // buildAggInst
 
-NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, DeclarationNode::StorageClasses scs ) {
+NamedTypeDecl * buildSymbolic( const TypeData * td, const string & name, Type::StorageClasses scs ) {
         assert( td->kind == TypeData::Symbolic );
         NamedTypeDecl * ret;
@@ -778 +778 @@
 } // buildTypeof
 
-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 ) {
+Declaration * buildDecl( const TypeData * td, const string &name, Type::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 ?
@@ -814 +814 @@
                         break;
                   default:
-                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", DeclarationNode::StorageClasses(), nullptr, DeclarationNode::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
+                        ft->get_returnVals().push_back( dynamic_cast< DeclarationWithType * >( buildDecl( td->base, "", Type::StorageClasses(), nullptr, DeclarationNode::FuncSpecifiers(), LinkageSpec::Cforall, nullptr ) ) );
                 } // switch
         } else {
-                ft->get_returnVals().push_back( new ObjectDecl( "", DeclarationNode::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
+                ft->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr ) );
         } // if
         return ft;

src/Parser/TypeData.h ¶

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 22:10:23 2017
-// Update Count     : 183
+// Last Modified On : Thu Mar 16 07:53:41 2017
+// Update Count     : 184
 //
 
@@ -109 +109 @@
 TupleType * buildTuple( const TypeData * );
 TypeofType * buildTypeof( const TypeData * );
-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 * >() );
+Declaration * buildDecl( const TypeData *, const std::string &, Type::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/parser.yy ¶

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Mar 15 22:06:22 2017
-// Update Count     : 2308
+// Last Modified On : Thu Mar 16 08:00:59 2017
+// Update Count     : 2309
 //
 
@@ -1449 +1449 @@
 storage_class:
         EXTERN
-                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Extern ); }
+                { $$ = DeclarationNode::newStorageClass( Type::Extern ); }
         | STATIC
-                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Static ); }
+                { $$ = DeclarationNode::newStorageClass( Type::Static ); }
         | AUTO
-                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Auto ); }
+                { $$ = DeclarationNode::newStorageClass( Type::Auto ); }
         | REGISTER
-                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Register ); }
+                { $$ = DeclarationNode::newStorageClass( Type::Register ); }
         | THREADLOCAL                                                                           // C11
-                { $$ = DeclarationNode::newStorageClass( DeclarationNode::Threadlocal ); }
+                { $$ = DeclarationNode::newStorageClass( Type::Threadlocal ); }
                 // Put function specifiers here to simplify parsing rules, but separate them semantically.
         | INLINE                                                                                        // C99