Changes in src/Parser/DeclarationNode.cc [1db21619:5d125e4]

File:

• src/Parser/DeclarationNode.cc (modified) (28 diffs)

src/Parser/DeclarationNode.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// DeclarationNode.cc -- 
+// DeclarationNode.cc --
 //
 // Author           : Rodolfo G. Esteves
 // 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 : Tue Jul 12 20:49:31 2016
+// Update Count     : 164
 //
 
@@ -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 ) {
@@ -96 +97 @@
                 os << endl << string( indent + 2, ' ' ) << "with initializer ";
                 initializer->printOneLine( os );
+                os << " maybe constructed? " << initializer->get_maybeConstructed();
+
         } // if
 
@@ -116 +119 @@
         newnode->type->function->newStyle = newStyle;
         newnode->type->function->body = body;
+        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
 
         if ( body ) {
@@ -128 +132 @@
 
         return newnode;
-}
+} // DeclarationNode::newFunction
 
 DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) {
@@ -135 +139 @@
         newnode->type->qualifiers.push_back( q );
         return newnode;
-}
+} // DeclarationNode::newQualifier
 
 DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
@@ -141 +145 @@
         newnode->storageClasses.push_back( sc );
         return newnode;
-}
+} // DeclarationNode::newStorageClass
 
 DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) {
@@ -148 +152 @@
         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 +166 @@
         newnode->type->basic->modifiers.push_back( mod );
         return newnode;
-}
+} // DeclarationNode::newModifier
 
 DeclarationNode *DeclarationNode::newForall( DeclarationNode *forall ) {
@@ -162 +173 @@
         newnode->type->forall = forall;
         return newnode;
-}
+} // DeclarationNode::newForall
 
 DeclarationNode *DeclarationNode::newFromTypedef( std::string *name ) {
@@ -171 +182 @@
         newnode->type->symbolic->params = 0;
         return newnode;
-}
-
-DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields ) {
+} // DeclarationNode::newFromTypedef
+
+DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
@@ -179 +190 @@
         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;
-}
+        newnode->type->aggregate->body = body;
+        return newnode;
+} // DeclarationNode::newAggregate
 
 DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) {
@@ -200 +205 @@
         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 +222 @@
         newnode->name = assign_strptr( name );
         return newnode;
-}
+} // DeclarationNode::newName
 
 DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {
@@ -232 +231 @@
         newnode->type->symbolic->actuals = params;
         return newnode;
-}
+} // DeclarationNode::newFromTypeGen
 
 DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) {
@@ -241 +240 @@
         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 +270 @@
         newnode->type->symbolic->name = newnode->name;
         return newnode;
-}
+} // DeclarationNode::newTypeDecl
 
 DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
@@ -277 +276 @@
         newnode->type = new TypeData( TypeData::Pointer );
         return newnode->addQualifiers( qualifiers );
-}
+} // DeclarationNode::newPointer
 
 DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
@@ -290 +289 @@
         } // if
         return newnode->addQualifiers( qualifiers );
-}
+} // DeclarationNode::newArray
 
 DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
@@ -357 +356 @@
         } // if
 }
-          
+
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
         if ( q ) {
@@ -508 +507 @@
                 assert( false );
         } // switch
-        
+
         return this;
 }
@@ -619 +618 @@
                 assert( a->type->kind == TypeData::Array );
                 TypeData *lastArray = findLast( a->type );
-                if ( type ) {  
+                if ( type ) {
                         switch ( type->kind ) {
                           case TypeData::Aggregate:
@@ -663 +662 @@
         } // if
 }
-        
+
 DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) {
         type = addIdListToType( type, ids );
@@ -794 +793 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast<DeclarationNode *>( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -857 +856 @@
 Declaration *DeclarationNode::build() const {
         if ( type ) {
-                Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildFuncSpecifier( Inline ), buildFuncSpecifier( Noreturn ), linkage, maybeBuild< Initializer >(initializer) );
-                return newDecl;
+                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 ) );
+                return (new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
         } // if
         throw SemanticError( "invalid function specifier in declaration of ", this );
@@ -868 +866 @@
 Type *DeclarationNode::buildType() const {
         assert( type );
-  
+
         switch ( type->kind ) {
           case TypeData::Enum:
@@ -881 +879 @@
                           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: