Changes in src/Parser/DeclarationNode.cc [2037f82:e82aa9df]

File:

• src/Parser/DeclarationNode.cc (modified) (24 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 Aug 18 23:48:23 2016
-// Update Count     : 182
+// Last Modified On : Mon Aug 15 14:30:25 2016
+// Update Count     : 172
 //
 
@@ -25 +25 @@
 #include "SynTree/Expression.h"
 
+#include "Parser.h"
 #include "TypedefTable.h"
 extern TypedefTable typedefTable;
@@ -41 +42 @@
 UniqueName DeclarationNode::anonymous( "__anonymous" );
 
-extern LinkageSpec::Spec linkage;                                               // defined in parser.yy
+extern LinkageSpec::Type linkage;                                               // defined in parser.yy
 
 DeclarationNode *DeclarationNode::clone() const {
@@ -47 +48 @@
         newnode->type = maybeClone( type );
         newnode->name = name;
-        newnode->storageClass = storageClass;
-        newnode->isInline = isInline;
-        newnode->isNoreturn = isNoreturn;
+        newnode->storageClasses = storageClasses;
+//PAB   newnode->bitfieldWidth = maybeClone( bitfieldWidth );
         newnode->bitfieldWidth = bitfieldWidth;
         newnode->hasEllipsis = hasEllipsis;
         newnode->initializer = initializer;
-        newnode->set_next( maybeClone( get_next() ) );
+        newnode->next = maybeClone( next );
         newnode->linkage = linkage;
         return newnode;
 } // DeclarationNode::clone
 
-DeclarationNode::DeclarationNode()
-        : type( 0 )
-        , storageClass( NoStorageClass )
-        , isInline( false )
-        , isNoreturn( false )
-        , bitfieldWidth( 0 )
-        , initializer( 0 )
-        , hasEllipsis( false )
-        , linkage( ::linkage )
-        , extension( false )
-        , error() {
+DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) {
 }
 
@@ -93 +83 @@
         } // if
 
-        if(storageClass != NoStorageClass) os << DeclarationNode::storageName[storageClass] << ' ';
-        if(isInline) os << DeclarationNode::storageName[Inline] << ' ';
-        if(isNoreturn) os << DeclarationNode::storageName[Noreturn] << ' ';
+        printEnums( storageClasses.begin(), storageClasses.end(), DeclarationNode::storageName, os );
         if ( type ) {
                 type->print( os, indent );
@@ -156 +144 @@
 DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
         DeclarationNode *newnode = new DeclarationNode;
-        switch (sc) {
-                case Inline: newnode->isInline = true; break;
-                case Noreturn: newnode->isNoreturn = true; break;
-                default: newnode->storageClass = sc; break;
-        }
+        newnode->storageClasses.push_back( sc );
         return newnode;
 } // DeclarationNode::newStorageClass
@@ -300 +284 @@
         newnode->type->array->dimension = size;
         newnode->type->array->isStatic = isStatic;
-        if ( newnode->type->array->dimension == 0 || newnode->type->array->dimension->isExpressionType<ConstantExpr *>() ) {
+        if ( newnode->type->array->dimension == 0 || dynamic_cast<ConstantExpr *>( newnode->type->array->dimension->build() ) ) {
                 newnode->type->array->isVarLen = false;
         } else {
@@ -376 +360 @@
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
         if ( q ) {
-                copyStorageClasses(q);
+                storageClasses.splice( storageClasses.end(), q->storageClasses );
                 if ( q->type ) {
                         if ( ! type ) {
@@ -403 +387 @@
 
 DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
-        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;
+        storageClasses = q->storageClasses;
         return this;
 }
@@ -471 +447 @@
 DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
         if ( o ) {
-                copyStorageClasses( o );
+                storageClasses.splice( storageClasses.end(), o->storageClasses );
                 if ( o->type ) {
                         if ( ! type ) {
@@ -718 +694 @@
         } // if
         newnode->type->forall = maybeClone( type->forall );
-        newnode->copyStorageClasses( this );
+        newnode->storageClasses = storageClasses;
         newnode->name = assign_strptr( newName );
         return newnode;
@@ -725 +701 @@
 DeclarationNode *DeclarationNode::cloneBaseType( DeclarationNode *o ) {
         if ( o ) {
-                o->copyStorageClasses( this );
+                o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
                 if ( type ) {
                         TypeData *srcType = type;
@@ -758 +734 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
-        newnode->copyStorageClasses( this );
+        newnode->storageClasses = storageClasses;
         newnode->name = assign_strptr( newName );
         return newnode;
@@ -765 +741 @@
 DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
         if ( o ) {
-                o->copyStorageClasses( this );
+                o->storageClasses.insert( o->storageClasses.end(), storageClasses.begin(), storageClasses.end() );
                 if ( type ) {
                         TypeData *newType = type->clone();
@@ -776 +752 @@
                 } // if
         } // if
-        delete o;
         return o;
+}
+
+DeclarationNode *DeclarationNode::appendList( DeclarationNode *node ) {
+        if ( node != 0 ) {
+                set_last( node );
+        } // if
+        return this;
 }
 
@@ -794 +776 @@
 void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ) {
         SemanticError errors;
-        std::back_insert_iterator< std::list< Declaration * > > out( outputList );
+        std::back_insert_iterator< std::list< Declaration *> > out( outputList );
         const DeclarationNode *cur = firstNode;
         while ( cur ) {
@@ -812 +794 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
+                cur = dynamic_cast<DeclarationNode *>( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -819 +801 @@
 }
 
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType * > &outputList ) {
+void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList ) {
         SemanticError errors;
-        std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
+        std::back_insert_iterator< std::list< DeclarationWithType *> > out( outputList );
         const DeclarationNode *cur = firstNode;
         while ( cur ) {
@@ -835 +817 @@
                         Declaration *decl = cur->build();
                         if ( decl ) {
-                                if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
+                                if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType *>( decl ) ) {
                                         *out++ = dwt;
-                                } else if ( StructDecl *agg = dynamic_cast< StructDecl * >( decl ) ) {
+                                } else if ( StructDecl *agg = dynamic_cast< StructDecl *>( decl ) ) {
                                         StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
                                         *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
                                         delete agg;
-                                } else if ( UnionDecl *agg = dynamic_cast< UnionDecl * >( decl ) ) {
+                                } else if ( UnionDecl *agg = dynamic_cast< UnionDecl *>( decl ) ) {
                                         UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
                                         *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
@@ -849 +831 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
+                cur = dynamic_cast< DeclarationNode *>( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -856 +838 @@
 }
 
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type * > &outputList ) {
+void buildTypeList( const DeclarationNode *firstNode, std::list< Type *> &outputList ) {
         SemanticError errors;
-        std::back_insert_iterator< std::list< Type * > > out( outputList );
+        std::back_insert_iterator< std::list< Type *> > out( outputList );
         const DeclarationNode *cur = firstNode;
         while ( cur ) {
@@ -866 +848 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
+                cur = dynamic_cast< DeclarationNode *>( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -874 +856 @@
 
 Declaration *DeclarationNode::build() const {
-        if( !error.empty() ) throw SemanticError( error, this );
         if ( type ) {
-                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 );
+                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 );
         } // if
         throw SemanticError( "invalid function specifier in declaration of ", this );
@@ -918 +899 @@
 }
 
-// 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: //