Changeset 7030dab for src/Parser/TypeData.cc

Timestamp:

Apr 6, 2020, 4:46:28 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

e3bc51c

Parents:

71d6bd8 (diff), 057298e (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 new-ast

File:

• src/Parser/TypeData.cc (modified) (9 diffs)

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Feb 13 18:16:23 2019
-// Update Count     : 649
+// Last Modified On : Mon Dec 16 07:56:46 2019
+// Update Count     : 662
 //
 
@@ -67 +67 @@
           case Aggregate:
                 // aggregate = new Aggregate_t;
-                aggregate.kind = DeclarationNode::NoAggregate;
+                aggregate.kind = AggregateDecl::NoAggregate;
                 aggregate.name = nullptr;
                 aggregate.params = nullptr;
@@ -345 +345 @@
                 break;
           case Aggregate:
-                os << DeclarationNode::aggregateNames[ aggregate.kind ] << ' ' << *aggregate.name << endl;
+                os << AggregateDecl::aggrString( aggregate.kind ) << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
                         os << string( indent + 2, ' ' ) << "with type parameters" << endl;
@@ -489 +489 @@
         for ( typename ForallList::iterator i = outputList.begin(); i != outputList.end(); ++i, n = (DeclarationNode*)n->get_next() ) {
                 TypeDecl * td = static_cast<TypeDecl *>(*i);
-                if ( n->variable.tyClass == DeclarationNode::Otype ) {
+                if ( n->variable.tyClass == TypeDecl::Otype ) {
                         // add assertion parameters to `type' tyvars in reverse order
                         // add dtor:  void ^?{}(T *)
@@ -522 +522 @@
         switch ( td->kind ) {
           case TypeData::Unknown:
-                        // fill in implicit int
-                        return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
+                // fill in implicit int
+                return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
           case TypeData::Basic:
-                        return buildBasicType( td );
+                return buildBasicType( td );
           case TypeData::Pointer:
-                        return buildPointer( td );
+                return buildPointer( td );
           case TypeData::Array:
-                        return buildArray( td );
+                return buildArray( td );
           case TypeData::Reference:
-                        return buildReference( td );
+                return buildReference( td );
           case TypeData::Function:
-                        return buildFunction( td );
+                return buildFunction( td );
           case TypeData::AggregateInst:
-                        return buildAggInst( td );
+                return buildAggInst( td );
           case TypeData::EnumConstant:
-                        // the name gets filled in later -- by SymTab::Validate
-                        return new EnumInstType( buildQualifiers( td ), "" );
+                // the name gets filled in later -- by SymTab::Validate
+                return new EnumInstType( buildQualifiers( td ), "" );
           case TypeData::SymbolicInst:
-                        return buildSymbolicInst( td );
+                return buildSymbolicInst( td );
           case TypeData::Tuple:
-                        return buildTuple( td );
+                return buildTuple( td );
           case TypeData::Typeof:
           case TypeData::Basetypeof:
-                        return buildTypeof( td );
+                return buildTypeof( td );
           case TypeData::Builtin:
-                        if (td->builtintype == DeclarationNode::Zero) {
-                                return new ZeroType( noQualifiers );
-                        }
-                        else if (td->builtintype == DeclarationNode::One) {
-                                return new OneType( noQualifiers );
-                        }
-                        else {
-                                return new VarArgsType( buildQualifiers( td ) );
-                        }
+                switch ( td->builtintype ) {
+                  case DeclarationNode::Zero:
+                        return new ZeroType( noQualifiers );
+                  case DeclarationNode::One:
+                        return new OneType( noQualifiers );
+                  default:
+                        return new VarArgsType( buildQualifiers( td ) );
+                } // switch
           case TypeData::GlobalScope:
-                        return new GlobalScopeType();
-                case TypeData::Qualified:
-                        return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
+                return new GlobalScopeType();
+          case TypeData::Qualified:
+                return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
           case TypeData::Symbolic:
           case TypeData::Enum:
           case TypeData::Aggregate:
-                        assert( false );
+                assert( false );
         } // switch
 
@@ -768 +767 @@
         AggregateDecl * at;
         switch ( td->aggregate.kind ) {
-          case DeclarationNode::Struct:
-          case DeclarationNode::Coroutine:
-          case DeclarationNode::Monitor:
-          case DeclarationNode::Thread:
+          case AggregateDecl::Struct:
+          case AggregateDecl::Coroutine:
+          case AggregateDecl::Generator:
+          case AggregateDecl::Monitor:
+          case AggregateDecl::Thread:
                 at = new StructDecl( *td->aggregate.name, td->aggregate.kind, attributes, linkage );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
-          case DeclarationNode::Union:
+          case AggregateDecl::Union:
                 at = new UnionDecl( *td->aggregate.name, attributes, linkage );
                 buildForall( td->aggregate.params, at->get_parameters() );
                 break;
-          case DeclarationNode::Trait:
+          case AggregateDecl::Trait:
                 at = new TraitDecl( *td->aggregate.name, attributes, linkage );
                 buildList( td->aggregate.params, at->get_parameters() );
@@ -809 +809 @@
                           AggregateDecl * typedecl = buildAggregate( type, attributes, linkage );
                           switch ( type->aggregate.kind ) {
-                                case DeclarationNode::Struct:
-                                case DeclarationNode::Coroutine:
-                                case DeclarationNode::Monitor:
-                                case DeclarationNode::Thread:
+                                case AggregateDecl::Struct:
+                                case AggregateDecl::Coroutine:
+                                case AggregateDecl::Monitor:
+                                case AggregateDecl::Thread:
                                   ret = new StructInstType( buildQualifiers( type ), (StructDecl *)typedecl );
                                   break;
-                                case DeclarationNode::Union:
+                                case AggregateDecl::Union:
                                   ret = new UnionInstType( buildQualifiers( type ), (UnionDecl *)typedecl );
                                   break;
-                                case DeclarationNode::Trait:
+                                case AggregateDecl::Trait:
                                   assert( false );
                                   //ret = new TraitInstType( buildQualifiers( type ), (TraitDecl *)typedecl );
@@ -827 +827 @@
                   } else {
                           switch ( type->aggregate.kind ) {
-                                case DeclarationNode::Struct:
-                                case DeclarationNode::Coroutine:
-                                case DeclarationNode::Monitor:
-                                case DeclarationNode::Thread:
+                                case AggregateDecl::Struct:
+                                case AggregateDecl::Coroutine:
+                                case AggregateDecl::Monitor:
+                                case AggregateDecl::Thread:
                                   ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
                                   break;
-                                case DeclarationNode::Union:
+                                case AggregateDecl::Union:
                                   ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
                                   break;
-                                case DeclarationNode::Trait:
+                                case AggregateDecl::Trait:
                                   ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
                                   break;
@@ -863 +863 @@
           case TypeData::Aggregate: {
                   switch ( type->aggregate.kind ) {
-                        case DeclarationNode::Struct:
-                        case DeclarationNode::Coroutine:
-                        case DeclarationNode::Monitor:
-                        case DeclarationNode::Thread:
+                        case AggregateDecl::Struct:
+                        case AggregateDecl::Coroutine:
+                        case AggregateDecl::Monitor:
+                        case AggregateDecl::Thread:
                           ret = new StructInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;
-                        case DeclarationNode::Union:
+                        case AggregateDecl::Union:
                           ret = new UnionInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;
-                        case DeclarationNode::Trait:
+                        case AggregateDecl::Trait:
                           ret = new TraitInstType( buildQualifiers( type ), *type->aggregate.name );
                           break;