Changeset 13e3b50 for src/Parser

Timestamp:

Aug 16, 2016, 2:41:17 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

1f6d4624

Parents:

7880579

Message:

DeclarationNodes? and Declaration now store exactly the same data for storage classes

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (13 diffs)
• ParseNode.h (modified) (2 diffs)

src/Parser/DeclarationNode.cc

@@ -48 +48 @@
         newnode->type = maybeClone( type );
         newnode->name = name;
-        newnode->storageClasses = storageClasses;
+        newnode->storageClass = storageClass;
+        newnode->isInline = isInline;
+        newnode->isNoreturn = isNoreturn;
         newnode->bitfieldWidth = bitfieldWidth;
         newnode->hasEllipsis = hasEllipsis;
@@ -57 +59 @@
 } // DeclarationNode::clone
 
-DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) {
+DeclarationNode::DeclarationNode()
+        : type( 0 )
+        , storageClass( NoStorageClass )
+        , isInline( false )
+        , isNoreturn( false )
+        , bitfieldWidth( 0 )
+        , initializer( 0 )
+        , hasEllipsis( false )
+        , linkage( ::linkage )
+        , extension( false )
+        , error() {
 }
 
@@ -82 +94 @@
         } // if
 
-        printEnums( storageClasses.begin(), storageClasses.end(), DeclarationNode::storageName, os );
+        if(storageClass != NoStorageClass) os << DeclarationNode::storageName[storageClass] << ' ';
+        if(isInline) os << DeclarationNode::storageName[Inline] << ' ';
+        if(isNoreturn) os << DeclarationNode::storageName[Noreturn] << ' ';
         if ( type ) {
                 type->print( os, indent );
@@ -143 +157 @@
 DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
         DeclarationNode *newnode = new DeclarationNode;
-        newnode->storageClasses.push_back( sc );
+        switch (sc) {
+                case Inline: newnode->isInline = true; break;
+                case Noreturn: newnode->isNoreturn = true; break;
+                default: newnode->storageClass = sc; break;
+        }
         return newnode;
 } // DeclarationNode::newStorageClass
@@ -359 +377 @@
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
         if ( q ) {
-                storageClasses.splice( storageClasses.end(), q->storageClasses );
+                copyStorageClasses(q);
                 if ( q->type ) {
                         if ( ! type ) {
@@ -386 +404 @@
 
 DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
-        storageClasses = q->storageClasses;
+        isInline = isInline || q->isInline;
+        isNoreturn = isNoreturn || q->isNoreturn;
+        if(storageClass == NoStorageClass) {
+                storageClass = q->storageClass;
+        }
+        else if (q->storageClass != NoStorageClass) {
+                q->error = "invalid combination of storage classes in declaration of ";
+        }
+        if(error.empty()) error = q->error;
         return this;
 }
@@ -446 +472 @@
 DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
         if ( o ) {
-                storageClasses.splice( storageClasses.end(), o->storageClasses );
+                copyStorageClasses( o );
                 if ( o->type ) {
                         if ( ! type ) {
@@ -693 +719 @@
         } // if
         newnode->type->forall = maybeClone( type->forall );
-        newnode->storageClasses = storageClasses;
+        newnode->copyStorageClasses( this );
         newnode->name = assign_strptr( newName );
         return newnode;
@@ -700 +726 @@
 DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) {
         if ( o ) {
-                o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
+                o->copyStorageClasses( this );
                 if ( type ) {
                         TypeData *srcType = type;
@@ -733 +759 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
-        newnode->storageClasses = storageClasses;
+        newnode->copyStorageClasses( this );
         newnode->name = assign_strptr( newName );
         return newnode;
@@ -740 +766 @@
 DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
         if ( o ) {
-                o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
+                o->copyStorageClasses( this );
                 if ( type ) {
                         TypeData *newType = type->clone();
@@ -855 +881 @@
 
 Declaration *DeclarationNode::build() const {
+        if( !error.empty() ) throw SemanticError( error, this );
         if ( type ) {
-                return type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildFuncSpecifier( Inline ), buildFuncSpecifier( Noreturn ), linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
-        } // if
-        if ( ! buildFuncSpecifier( Inline ) && ! buildFuncSpecifier( Noreturn ) ) {
-                return (new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
+                return type->buildDecl( name, storageClass, maybeBuild< Expression >( bitfieldWidth ), isInline, isNoreturn, linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
+        } // if
+        if ( ! isInline && ! isNoreturn ) {
+                return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
         } // if
         throw SemanticError( "invalid function specifier in declaration of ", this );
@@ -898 +925 @@
 }
 
-DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const {
-        DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass;
-        for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
-          if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers
-          if ( ret != DeclarationNode::NoStorageClass ) {       // already have a valid storage class ?
-                        throw SemanticError( "invalid combination of storage classes in declaration of ", this );
-                } // if
-                ret = *i;
-        } // for
-        return ret;
-}
-
-bool DeclarationNode::buildFuncSpecifier( DeclarationNode::StorageClass key ) const {
-        std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), key );
-  if ( first == storageClasses.end() ) return false;    // not found
-        first = std::find( ++first, storageClasses.end(), key ); // found
-  if ( first == storageClasses.end() ) return true;             // not found again
-        throw SemanticError( "duplicate function specifier in declaration of ", this );
-}
+// DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const {
+//      DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass;
+//      for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
+//        if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers
+//        if ( ret != DeclarationNode::NoStorageClass ) {       // already have a valid storage class ?
+//                      throw SemanticError( "invalid combination of storage classes in declaration of ", this );
+//              } // if
+//              ret = *i;
+//      } // for
+//      return ret;
+// }
+
+// bool DeclarationNode::buildFuncSpecifier( DeclarationNode::StorageClass key ) const {
+//      std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), key );
+//   if ( first == storageClasses.end() ) return false; // not found
+//      first = std::find( ++first, storageClasses.end(), key ); // found
+//   if ( first == storageClasses.end() ) return true;          // not found again
+//      throw SemanticError( "duplicate function specifier in declaration of ", this );
+// }
 
 // Local Variables: //

src/Parser/ParseNode.h

@@ -271 +271 @@
         DeclarationNode *set_extension( bool exten ) { extension = exten; return this; }
   private:
-        StorageClass buildStorageClass() const;
-        bool buildFuncSpecifier( StorageClass key ) const;
+        // StorageClass buildStorageClass() const;
+        // bool buildFuncSpecifier( StorageClass key ) const;
 
         TypeData *type;
         std::string name;
-        std::list< StorageClass > storageClasses;
+        // std::list< StorageClass > storageClasses;
+        StorageClass storageClass;
+        bool isInline, isNoreturn;
         std::list< std::string > attributes;
         ExpressionNode *bitfieldWidth;
@@ -284 +286 @@
         LinkageSpec::Type linkage;
         bool extension = false;
+        std::string error;
 
         static UniqueName anonymous;