Changeset 04cdd9b for src/Parser/DeclarationNode.cc

Timestamp:

Aug 19, 2016, 2:42:04 PM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, 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:

e85a8631

Parents:

03da511 (diff), ac71a86 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into ctor

File:

• src/Parser/DeclarationNode.cc (modified) (25 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 : Sun Aug  7 08:01:55 2016
-// Update Count     : 165
+// Last Modified On : Thu Aug 18 23:48:23 2016
+// Update Count     : 182
 //
 
@@ -25 +25 @@
 #include "SynTree/Expression.h"
 
-#include "Parser.h"
 #include "TypedefTable.h"
 extern TypedefTable typedefTable;
@@ -42 +41 @@
 UniqueName DeclarationNode::anonymous( "__anonymous" );
 
-extern LinkageSpec::Type linkage;                                               // defined in parser.yy
+extern LinkageSpec::Spec linkage;                                               // defined in parser.yy
 
 DeclarationNode *DeclarationNode::clone() const {
@@ -48 +47 @@
         newnode->type = maybeClone( type );
         newnode->name = name;
-        newnode->storageClasses = storageClasses;
-//PAB   newnode->bitfieldWidth = maybeClone( bitfieldWidth );
+        newnode->storageClass = storageClass;
+        newnode->isInline = isInline;
+        newnode->isNoreturn = isNoreturn;
         newnode->bitfieldWidth = bitfieldWidth;
         newnode->hasEllipsis = hasEllipsis;
         newnode->initializer = initializer;
-        newnode->next = maybeClone( next );
+        newnode->set_next( maybeClone( get_next() ) );
         newnode->linkage = linkage;
         return newnode;
 } // 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() {
 }
 
@@ -83 +93 @@
         } // 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 );
@@ -144 +156 @@
 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
@@ -284 +300 @@
         newnode->type->array->dimension = size;
         newnode->type->array->isStatic = isStatic;
-        if ( newnode->type->array->dimension == 0 || dynamic_cast<ConstantNode *>( newnode->type->array->dimension ) ) {
+        if ( newnode->type->array->dimension == 0 || newnode->type->array->dimension->isExpressionType<ConstantExpr *>() ) {
                 newnode->type->array->isVarLen = false;
         } else {
@@ -360 +376 @@
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
         if ( q ) {
-                storageClasses.splice( storageClasses.end(), q->storageClasses );
+                copyStorageClasses(q);
                 if ( q->type ) {
                         if ( ! type ) {
@@ -387 +403 @@
 
 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;
 }
@@ -447 +471 @@
 DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
         if ( o ) {
-                storageClasses.splice( storageClasses.end(), o->storageClasses );
+                copyStorageClasses( o );
                 if ( o->type ) {
                         if ( ! type ) {
@@ -470 +494 @@
 
                 // there may be typedefs chained onto the type
-                if ( o->get_link() ) {
-                        set_link( o->get_link()->clone() );
+                if ( o->get_next() ) {
+                        set_last( o->get_next()->clone() );
                 } // if
         } // if
@@ -694 +718 @@
         } // if
         newnode->type->forall = maybeClone( type->forall );
-        newnode->storageClasses = storageClasses;
+        newnode->copyStorageClasses( this );
         newnode->name = assign_strptr( newName );
         return newnode;
@@ -701 +725 @@
 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;
@@ -734 +758 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
-        newnode->storageClasses = storageClasses;
+        newnode->copyStorageClasses( this );
         newnode->name = assign_strptr( newName );
         return newnode;
@@ -741 +765 @@
 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();
@@ -755 +779 @@
 }
 
-DeclarationNode *DeclarationNode::appendList( DeclarationNode *node ) {
-        if ( node != 0 ) {
-                set_link( node );
-        } // if
-        return this;
-}
-
 DeclarationNode *DeclarationNode::extractAggregate() const {
         if ( type ) {
@@ -776 +793 @@
 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 ) {
@@ -794 +811 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast<DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -801 +818 @@
 }
 
-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 ) {
@@ -817 +834 @@
                         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 );
@@ -831 +848 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -838 +855 @@
 }
 
-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 ) {
@@ -848 +865 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode * >( cur->get_next() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -856 +873 @@
 
 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 );
@@ -899 +917 @@
 }
 
-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: //