Changes in src/Parser/DeclarationNode.cc [44a81853:c0aa336]

File:

• src/Parser/DeclarationNode.cc (modified) (13 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 : Sat Jan 14 14:36:23 2017
-// Update Count     : 669
+// Last Modified On : Mon Feb  6 16:01:29 2017
+// Update Count     : 739
 //
 
@@ -83 +83 @@
 DeclarationNode * DeclarationNode::clone() const {
         DeclarationNode * newnode = new DeclarationNode;
+        newnode->set_next( maybeClone( get_next() ) );
+        newnode->name = name ? new string( *name ) : nullptr;
+
         newnode->type = maybeClone( type );
-        newnode->name = name ? new string( *name ) : nullptr;
         newnode->storageClass = storageClass;
+        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
         newnode->isInline = isInline;
         newnode->isNoreturn = isNoreturn;
-        newnode->bitfieldWidth = maybeClone( bitfieldWidth );
+        newnode->enumeratorValue.reset( maybeClone( enumeratorValue.get() ) );
         newnode->hasEllipsis = hasEllipsis;
-        newnode->initializer = maybeClone( initializer );
-        newnode->set_next( maybeClone( get_next() ) );
         newnode->linkage = linkage;
         newnode->asmName = maybeClone( asmName );
+        cloneAll( attributes, newnode->attributes );
+        newnode->initializer = maybeClone( initializer );
+        newnode->extension = extension;
+        newnode->error = error;
 
 //      newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
@@ -159 +164 @@
         newnode->type->function.newStyle = newStyle;
         newnode->type->function.body = body;
+
         // ignore unnamed routine declarations: void p( int (*)(int) );
         if ( newnode->name ) {
@@ -436 +442 @@
         } // if
         appendError( error, q->error );
-} // DeclarationNode::copyStorageClasses
+} // DeclarationNode::checkStorageClasses
 
 DeclarationNode * DeclarationNode::copyStorageClasses( DeclarationNode * q ) {
@@ -446 +452 @@
                 storageClass = q->storageClass;
         } // if
-        attributes.splice( attributes.end(), q->attributes );
+
+        for ( Attribute *attr: reverseIterate( q->attributes ) ) {
+                attributes.push_front( attr->clone() );
+        } // for
         return this;
 } // DeclarationNode::copyStorageClasses
@@ -656 +665 @@
 }
 
-DeclarationNode * DeclarationNode::addAsmName( ConstantExpr * newname ) {
+DeclarationNode * DeclarationNode::addAsmName( DeclarationNode * newname ) {
         assert( ! asmName );
-        asmName = newname;
-        return this;
+        asmName = newname ? newname->asmName : nullptr;
+        return this->addQualifiers( newname );
 }
 
@@ -690 +699 @@
 }
 
-static void setBase( TypeData *&type, TypeData * newType ) {
+DeclarationNode * DeclarationNode::setBase( TypeData * newType ) {
         if ( type ) {
                 TypeData * prevBase = type;
@@ -702 +711 @@
                 type = newType;
         } // if
-}
+        return this;
+}
+
+DeclarationNode * DeclarationNode::copyAttribute( DeclarationNode * a ) {
+        if ( a ) {
+                for ( Attribute *attr: reverseIterate( a->attributes ) ) {
+                        attributes.push_front( attr );
+                } // for
+                a->attributes.clear();
+        } // if
+        return this;
+} // copyAttribute
 
 DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) {
         if ( p ) {
                 assert( p->type->kind == TypeData::Pointer );
-                setBase( type, p->type );
+                setBase( p->type );
                 p->type = nullptr;
+                copyAttribute( p );
                 delete p;
         } // if
@@ -717 +738 @@
         if ( a ) {
                 assert( a->type->kind == TypeData::Array );
-                setBase( type, a->type );
+                setBase( a->type );
                 a->type = nullptr;
+                copyAttribute( a );
                 delete a;
         } // if
@@ -790 +812 @@
         TypeData * ftype = new TypeData( TypeData::Function );
         ftype->function.params = params;
-        setBase( type, ftype );
+        setBase( ftype );
         return this;
 }
@@ -836 +858 @@
                 TypeData * srcType = type;
 
+                // search for the base type by scanning off pointers and array designators
                 while ( srcType->base ) {
                         srcType = srcType->base;
@@ -986 +1009 @@
         if ( attr.expr ) {
 //              return new AttrType( buildQualifiers( type ), *attr.name, attr.expr->build() );
-                return new AttrType( buildQualifiers( type ), *name, attr.expr->build() );
+                return new AttrType( buildQualifiers( type ), *name, attr.expr->build(), attributes );
         } else if ( attr.type ) {
 //              return new AttrType( buildQualifiers( type ), *attr.name, attr.type->buildType() );
-                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType() );
+                return new AttrType( buildQualifiers( type ), *name, attr.type->buildType(), attributes );
         } // if
 
         switch ( type->kind ) {
-          case TypeData::Enum:
-                return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
+          case TypeData::Enum: {
+                  EnumDecl * typedecl = buildEnum( type, attributes );
+                  return new EnumInstType( buildQualifiers( type ), typedecl );
+          }
           case TypeData::Aggregate: {
+                  AggregateDecl * typedecl = buildAggregate( type, attributes );
                   ReferenceToType * ret;
                   switch ( type->aggregate.kind ) {
                         case DeclarationNode::Struct:
-                          ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
+                          ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
                           break;
                         case DeclarationNode::Union:
-                          ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
+                          ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
                           break;
                         case DeclarationNode::Trait:
-                          ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
+                          assert( false );
+                          //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
                           break;
                         default:
@@ -1014 +1041 @@
           }
           case TypeData::Symbolic: {
-                  TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false );
+                  TypeInstType * ret = new TypeInstType( buildQualifiers( type ), *type->symbolic.name, false, attributes );
                   buildList( type->symbolic.actuals, ret->get_parameters() );
                   return ret;
           }
           default:
-                return typebuild( type );
+                Type * simpletypes = typebuild( type );
+                simpletypes->get_attributes() = attributes;             // copy because member is const
+                return simpletypes;
         } // switch
 }