Changeset 43c89a7 for src/Parser

Timestamp:

Feb 24, 2017, 3:58:03 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

167a9c8

Parents:

24cde55

Message:

add hoistType flag (currently unused)

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (6 diffs)
• TypeData.cc (modified) (4 diffs)
• TypeData.h (modified) (3 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 Feb 23 15:45:02 2017
-// Update Count     : 759
+// Last Modified On : Thu Feb 23 22:21:06 2017
+// Update Count     : 775
 //
 
@@ -607 +607 @@
                                         type->aggInst.aggregate = o->type;
                                         if ( o->type->kind == TypeData::Aggregate ) {
+                                                type->aggInst.hoistType = o->type->aggregate.body;
                                                 type->aggInst.params = maybeClone( o->type->aggregate.actuals );
+                                        } else {
+                                                type->aggInst.hoistType = o->type->enumeration.body;
                                         } // if
                                         type->qualifiers |= o->type->qualifiers;
@@ -881 +884 @@
                                 newType->aggInst.aggregate->aggregate.fields = nullptr;
                         } // if
+                        // don't hoist twice
+                        newType->aggInst.hoistType = false;
                 } // if
 
@@ -941 +946 @@
         SemanticError errors;
         std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
-        
+
         for ( const DeclarationNode * cur = firstNode; cur; cur = dynamic_cast< DeclarationNode * >( cur->get_next() ) ) {
                 try {
@@ -953 +958 @@
                                         auto obj = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, nullptr, inst, nullptr );
                                         obj->location = cur->location;
-                                        * out++ = obj; 
+                                        * out++ = obj;
                                         delete agg;
                                 } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
@@ -1035 +1040 @@
 
         switch ( type->kind ) {
-          case TypeData::Enum: {
-                  if ( type->enumeration.body ) {
-                          EnumDecl * typedecl = buildEnum( type, attributes );
-                          return new EnumInstType( buildQualifiers( type ), typedecl );
-                  } else {
-                          return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
-                  }
-          }
+          case TypeData::Enum:
           case TypeData::Aggregate: {
-                  ReferenceToType * ret;
-                  if ( type->aggregate.body ) {
-                          AggregateDecl * typedecl = buildAggregate( type, attributes );
-                          switch ( type->aggregate.kind ) {
-                                case DeclarationNode::Struct:
-                                  ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
-                                  break;
-                                case DeclarationNode::Union:
-                                  ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
-                                  break;
-                                case DeclarationNode::Trait:
-                                  assert( false );
-                                  //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
-                                  break;
-                                default:
-                                  assert( false );
-                          } // switch
-                  } else {
-                          switch ( type->aggregate.kind ) {
-                                case DeclarationNode::Struct:
-                                  ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
-                                  break;
-                                case DeclarationNode::Union:
-                                  ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
-                                  break;
-                                case DeclarationNode::Trait:
-                                  assert( false );
-                                  //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
-                                  break;
-                                default:
-                                  assert( false );
-                          } // switch
-                  } // if
+                  ReferenceToType * ret = buildComAggInst( type, attributes );
                   buildList( type->aggregate.actuals, ret->get_parameters() );
                   return ret;

src/Parser/TypeData.cc ¶

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 16:26:39 2017
-// Update Count     : 477
+// Last Modified On : Thu Feb 23 21:48:55 2017
+// Update Count     : 485
 //
 
@@ -62 +62 @@
                 aggInst.aggregate = nullptr;
                 aggInst.params = nullptr;
+                aggInst.hoistType = false;;
                 break;
           case Enum:
@@ -195 +196 @@
                 newtype->aggInst.aggregate = maybeClone( aggInst.aggregate );
                 newtype->aggInst.params = maybeClone( aggInst.params );
+                newtype->aggInst.hoistType = aggInst.hoistType;
                 break;
           case Enum:
@@ -644 +646 @@
 } // buildAggregate
 
+ReferenceToType * buildComAggInst( const TypeData * type, std::list< Attribute * > attributes ) {
+        switch ( type->kind ) {
+          case TypeData::Enum: {
+                  if ( type->enumeration.body ) {
+                          EnumDecl * typedecl = buildEnum( type, attributes );
+                          return new EnumInstType( buildQualifiers( type ), typedecl );
+                  } else {
+                          return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
+                  } // if
+          }
+          case TypeData::Aggregate: {
+                  ReferenceToType * ret;
+                  if ( type->aggregate.body ) {
+                          AggregateDecl * typedecl = buildAggregate( type, attributes );
+                          switch ( type->aggregate.kind ) {
+                                case DeclarationNode::Struct:
+                                  ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
+                                  break;
+                                case DeclarationNode::Union:
+                                  ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
+                                  break;
+                                case DeclarationNode::Trait:
+                                  assert( false );
+                                  //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
+                                  break;
+                                default:
+                                  assert( false );
+                          } // switch
+                  } else {
+                          switch ( type->aggregate.kind ) {
+                                case DeclarationNode::Struct:
+                                  ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
+                                  break;
+                                case DeclarationNode::Union:
+                                  ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
+                                  break;
+                                case DeclarationNode::Trait:
+                                  ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
+                                  break;
+                                default:
+                                  assert( false );
+                          } // switch
+                  } // if
+                  return ret;
+          }
+          default:
+                assert( false );
+        } // switch
+} // buildAggInst
+
 ReferenceToType * buildAggInst( const TypeData * td ) {
         assert( td->kind == TypeData::AggregateInst );
 
-        ReferenceToType * ret;
-        if ( td->aggInst.aggregate->kind == TypeData::Enum ) {
-                ret = new EnumInstType( buildQualifiers( td ), *td->aggInst.aggregate->enumeration.name );
-        } else {
-                assert( td->aggInst.aggregate->kind == TypeData::Aggregate );
-                switch ( td->aggInst.aggregate->aggregate.kind ) {
-                  case DeclarationNode::Struct:
-                        assert( td->aggInst.aggregate->aggregate.name );
-                        ret = new StructInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
-                        break;
-                  case DeclarationNode::Union:
-                        ret = new UnionInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
-                        break;
-                  case DeclarationNode::Trait:
-                        ret = new TraitInstType( buildQualifiers( td ), *td->aggInst.aggregate->aggregate.name );
-                        break;
-                  default:
-                        assert( false );
-                } // switch
-        } // if
+        // ReferenceToType * ret = buildComAggInst( td->aggInst.aggregate, std::list< Attribute * >() );
+        ReferenceToType * ret = nullptr;
+        TypeData * type = td->aggInst.aggregate;
+        switch ( type->kind ) {
+          case TypeData::Enum: {
+                  return new EnumInstType( buildQualifiers( type ), *type->enumeration.name );
+          }
+          case TypeData::Aggregate: {
+                  switch ( type->aggregate.kind ) {
+                        case DeclarationNode::Struct:
+                          ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
+                          break;
+                        case DeclarationNode::Union:
+                          ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
+                          break;
+                        case DeclarationNode::Trait:
+                          ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
+                          break;
+                        default:
+                          assert( false );
+                  } // switch
+          }
+          break;
+          default:
+                assert( false );
+        } // switch
+
+        ret->set_hoistType( td->aggInst.hoistType );
         buildList( td->aggInst.params, ret->get_parameters() );
         buildForall( td->forall, ret->get_forall() );

src/Parser/TypeData.h ¶

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 23 15:16:18 2017
-// Update Count     : 155
+// Last Modified On : Thu Feb 23 17:14:46 2017
+// Update Count     : 158
 //
 
@@ -38 +38 @@
                 TypeData * aggregate;
                 ExpressionNode * params;
+                bool hoistType;
         };
 
@@ -104 +105 @@
 ArrayType * buildArray( const TypeData * );
 AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
+ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes );
 ReferenceToType * buildAggInst( const TypeData * );
 NamedTypeDecl * buildSymbolic( const TypeData *, const std::string &name, DeclarationNode::StorageClass sc );