Changeset 0f9e4403 for src/Parser/DeclarationNode.cc

Timestamp:

Apr 15, 2016, 12:03:11 PM (9 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

29ad0ac

Parents:

c5833e8 (diff), 37f0da8 (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 gc_noraii

File:

• src/Parser/DeclarationNode.cc (modified) (21 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 : Tue Jul 14 14:46:32 2015
-// Update Count     : 126
+// Last Modified On : Wed Apr 13 16:53:17 2016
+// Update Count     : 161
 //
 
@@ -34 +34 @@
 const char *DeclarationNode::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "" };
 const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" };
-const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary" };
+const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary",  };
 const char *DeclarationNode::modifierName[]  = { "signed", "unsigned", "short", "long" };
 const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" };
 const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" };
+const char *DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
 
 UniqueName DeclarationNode::anonymous( "__anonymous" );
 
-extern LinkageSpec::Type linkage;               /* defined in cfa.y */
+extern LinkageSpec::Type linkage;                                               // defined in parser.yy
 
 DeclarationNode *DeclarationNode::clone() const {
@@ -54 +55 @@
         newnode->linkage = linkage;
         return newnode;
-}
+} // DeclarationNode::clone
 
 DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) {
@@ -116 +117 @@
         newnode->type->function->newStyle = newStyle;
         newnode->type->function->body = body;
+        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
 
         if ( body ) {
@@ -128 +130 @@
 
         return newnode;
-}
+} // DeclarationNode::newFunction
 
 DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) {
@@ -135 +137 @@
         newnode->type->qualifiers.push_back( q );
         return newnode;
-}
+} // DeclarationNode::newQualifier
 
 DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
@@ -141 +143 @@
         newnode->storageClasses.push_back( sc );
         return newnode;
-}
+} // DeclarationNode::newStorageClass
 
 DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) {
@@ -148 +150 @@
         newnode->type->basic->typeSpec.push_back( bt );
         return newnode;
-}
+} // DeclarationNode::newBasicType
+
+DeclarationNode *DeclarationNode::newBuiltinType( BuiltinType bt ) {
+        DeclarationNode *newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::Builtin );
+        newnode->type->builtin->type = bt;
+        return newnode;
+} // DeclarationNode::newBuiltinType
 
 DeclarationNode *DeclarationNode::newModifier( Modifier mod ) {
@@ -155 +164 @@
         newnode->type->basic->modifiers.push_back( mod );
         return newnode;
-}
+} // DeclarationNode::newModifier
 
 DeclarationNode *DeclarationNode::newForall( DeclarationNode *forall ) {
@@ -162 +171 @@
         newnode->type->forall = forall;
         return newnode;
-}
+} // DeclarationNode::newForall
 
 DeclarationNode *DeclarationNode::newFromTypedef( std::string *name ) {
@@ -171 +180 @@
         newnode->type->symbolic->params = 0;
         return newnode;
-}
+} // DeclarationNode::newFromTypedef
 
 DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields ) {
@@ -179 +188 @@
         newnode->type->aggregate->name = assign_strptr( name );
         if ( newnode->type->aggregate->name == "" ) {           // anonymous aggregate ?
-                newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
-        } else {
-                // SKULLDUGGERY: generate a typedef for the aggregate name so that the aggregate does not have to be qualified
-                // by "struct"
-                typedefTable.addToEnclosingScope( newnode->type->aggregate->name, TypedefTable::TD );
-                DeclarationNode *typedf = new DeclarationNode;
-                typedf->name = newnode->type->aggregate->name;
-                newnode->appendList( typedf->addType( newnode->clone() )->addTypedef() );
+                newnode->type->aggregate->name = anonymous.newName();
         } // if
         newnode->type->aggregate->actuals = actuals;
         newnode->type->aggregate->fields = fields;
         return newnode;
-}
+} // DeclarationNode::newAggregate
 
 DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) {
@@ -200 +202 @@
         if ( newnode->type->enumeration->name == "" ) {         // anonymous enumeration ?
                 newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
-        } else {
-                // SKULLDUGGERY: generate a typedef for the enumeration name so that the enumeration does not have to be
-                // qualified by "enum"
-                typedefTable.addToEnclosingScope( newnode->type->enumeration->name, TypedefTable::TD );
-                DeclarationNode *typedf = new DeclarationNode;
-                typedf->name = newnode->type->enumeration->name;
-                newnode->appendList( typedf->addType( newnode->clone() )->addTypedef() );
         } // if
         newnode->type->enumeration->constants = constants;
         return newnode;
-}
+} // DeclarationNode::newEnum
 
 DeclarationNode *DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->name = assign_strptr( name );
-        // do something with the constant
-        return newnode;
-}
+        newnode->enumeratorValue = constant;
+        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
+        return newnode;
+} // DeclarationNode::newEnumConstant
 
 DeclarationNode *DeclarationNode::newName( std::string *name ) {
@@ -223 +219 @@
         newnode->name = assign_strptr( name );
         return newnode;
-}
+} // DeclarationNode::newName
 
 DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {
@@ -232 +228 @@
         newnode->type->symbolic->actuals = params;
         return newnode;
-}
+} // DeclarationNode::newFromTypeGen
 
 DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) {
@@ -241 +237 @@
         newnode->type->variable->name = newnode->name;
         return newnode;
-}
-
-DeclarationNode *DeclarationNode::newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
+} // DeclarationNode::newTypeParam
+
+DeclarationNode *DeclarationNode::newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
-        newnode->type->aggregate->kind = Context;
+        newnode->type->aggregate->kind = Trait;
         newnode->type->aggregate->params = params;
         newnode->type->aggregate->fields = asserts;
         newnode->type->aggregate->name = assign_strptr( name );
         return newnode;
-}
-
-DeclarationNode *DeclarationNode::newContextUse( std::string *name, ExpressionNode *params ) {
+} // DeclarationNode::newTrait
+
+DeclarationNode *DeclarationNode::newTraitUse( std::string *name, ExpressionNode *params ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::AggregateInst );
         newnode->type->aggInst->aggregate = new TypeData( TypeData::Aggregate );
-        newnode->type->aggInst->aggregate->aggregate->kind = Context;
+        newnode->type->aggInst->aggregate->aggregate->kind = Trait;
         newnode->type->aggInst->aggregate->aggregate->name = assign_strptr( name );
         newnode->type->aggInst->params = params;
         return newnode;
-}
+} // DeclarationNode::newTraitUse
 
 DeclarationNode *DeclarationNode::newTypeDecl( std::string *name, DeclarationNode *typeParams ) {
@@ -271 +267 @@
         newnode->type->symbolic->name = newnode->name;
         return newnode;
-}
+} // DeclarationNode::newTypeDecl
 
 DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
@@ -277 +273 @@
         newnode->type = new TypeData( TypeData::Pointer );
         return newnode->addQualifiers( qualifiers );
-}
+} // DeclarationNode::newPointer
 
 DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
@@ -290 +286 @@
         } // if
         return newnode->addQualifiers( qualifiers );
-}
+} // DeclarationNode::newArray
 
 DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
@@ -794 +790 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast<DeclarationNode *>( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -881 +877 @@
                           ret = new UnionInstType( type->buildQualifiers(), type->aggregate->name );
                           break;
-                        case DeclarationNode::Context:
-                          ret = new ContextInstType( type->buildQualifiers(), type->aggregate->name );
+                        case DeclarationNode::Trait:
+                          ret = new TraitInstType( type->buildQualifiers(), type->aggregate->name );
                           break;
                         default: