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

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 12 20:49:31 2016
-// Update Count     : 164
+// Last Modified On : Tue Jul 14 14:46:32 2015
+// Update Count     : 126
 //
 
@@ -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 parser.yy
+extern LinkageSpec::Type linkage;               /* defined in cfa.y */
 
 DeclarationNode *DeclarationNode::clone() const {
@@ -55 +54 @@
         newnode->linkage = linkage;
         return newnode;
-} // DeclarationNode::clone
+}
 
 DeclarationNode::DeclarationNode() : type( 0 ), bitfieldWidth( 0 ), initializer( 0 ), hasEllipsis( false ), linkage( ::linkage ) {
@@ -97 +96 @@
                 os << endl << string( indent + 2, ' ' ) << "with initializer ";
                 initializer->printOneLine( os );
-                os << " maybe constructed? " << initializer->get_maybeConstructed();
-
         } // if
 
@@ -119 +116 @@
         newnode->type->function->newStyle = newStyle;
         newnode->type->function->body = body;
-        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
 
         if ( body ) {
@@ -132 +128 @@
 
         return newnode;
-} // DeclarationNode::newFunction
+}
 
 DeclarationNode *DeclarationNode::newQualifier( Qualifier q ) {
@@ -139 +135 @@
         newnode->type->qualifiers.push_back( q );
         return newnode;
-} // DeclarationNode::newQualifier
+}
 
 DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
@@ -145 +141 @@
         newnode->storageClasses.push_back( sc );
         return newnode;
-} // DeclarationNode::newStorageClass
+}
 
 DeclarationNode *DeclarationNode::newBasicType( BasicType bt ) {
@@ -152 +148 @@
         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 ) {
@@ -166 +155 @@
         newnode->type->basic->modifiers.push_back( mod );
         return newnode;
-} // DeclarationNode::newModifier
+}
 
 DeclarationNode *DeclarationNode::newForall( DeclarationNode *forall ) {
@@ -173 +162 @@
         newnode->type->forall = forall;
         return newnode;
-} // DeclarationNode::newForall
+}
 
 DeclarationNode *DeclarationNode::newFromTypedef( std::string *name ) {
@@ -182 +171 @@
         newnode->type->symbolic->params = 0;
         return newnode;
-} // DeclarationNode::newFromTypedef
-
-DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields, bool body ) {
+}
+
+DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, const std::string *name, ExpressionNode *actuals, DeclarationNode *fields ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
@@ -190 +179 @@
         newnode->type->aggregate->name = assign_strptr( name );
         if ( newnode->type->aggregate->name == "" ) {           // anonymous aggregate ?
-                newnode->type->aggregate->name = anonymous.newName();
+                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() );
         } // if
         newnode->type->aggregate->actuals = actuals;
         newnode->type->aggregate->fields = fields;
-        newnode->type->aggregate->body = body;
-        return newnode;
-} // DeclarationNode::newAggregate
+        return newnode;
+}
 
 DeclarationNode *DeclarationNode::newEnum( std::string *name, DeclarationNode *constants ) {
@@ -205 +200 @@
         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 );
-        newnode->enumeratorValue = constant;
-        typedefTable.addToEnclosingScope( newnode->name, TypedefTable::ID );
-        return newnode;
-} // DeclarationNode::newEnumConstant
+        // do something with the constant
+        return newnode;
+}
 
 DeclarationNode *DeclarationNode::newName( std::string *name ) {
@@ -222 +223 @@
         newnode->name = assign_strptr( name );
         return newnode;
-} // DeclarationNode::newName
+}
 
 DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {
@@ -231 +232 @@
         newnode->type->symbolic->actuals = params;
         return newnode;
-} // DeclarationNode::newFromTypeGen
+}
 
 DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) {
@@ -240 +241 @@
         newnode->type->variable->name = newnode->name;
         return newnode;
-} // DeclarationNode::newTypeParam
-
-DeclarationNode *DeclarationNode::newTrait( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
+}
+
+DeclarationNode *DeclarationNode::newContext( std::string *name, DeclarationNode *params, DeclarationNode *asserts ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
-        newnode->type->aggregate->kind = Trait;
+        newnode->type->aggregate->kind = Context;
         newnode->type->aggregate->params = params;
         newnode->type->aggregate->fields = asserts;
         newnode->type->aggregate->name = assign_strptr( name );
         return newnode;
-} // DeclarationNode::newTrait
-
-DeclarationNode *DeclarationNode::newTraitUse( std::string *name, ExpressionNode *params ) {
+}
+
+DeclarationNode *DeclarationNode::newContextUse( 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 = Trait;
+        newnode->type->aggInst->aggregate->aggregate->kind = Context;
         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 ) {
@@ -270 +271 @@
         newnode->type->symbolic->name = newnode->name;
         return newnode;
-} // DeclarationNode::newTypeDecl
+}
 
 DeclarationNode *DeclarationNode::newPointer( DeclarationNode *qualifiers ) {
@@ -276 +277 @@
         newnode->type = new TypeData( TypeData::Pointer );
         return newnode->addQualifiers( qualifiers );
-} // DeclarationNode::newPointer
+}
 
 DeclarationNode *DeclarationNode::newArray( ExpressionNode *size, DeclarationNode *qualifiers, bool isStatic ) {
@@ -289 +290 @@
         } // if
         return newnode->addQualifiers( qualifiers );
-} // DeclarationNode::newArray
+}
 
 DeclarationNode *DeclarationNode::newVarArray( DeclarationNode *qualifiers ) {
@@ -356 +357 @@
         } // if
 }
-
+          
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
         if ( q ) {
@@ -507 +508 @@
                 assert( false );
         } // switch
-
+        
         return this;
 }
@@ -618 +619 @@
                 assert( a->type->kind == TypeData::Array );
                 TypeData *lastArray = findLast( a->type );
-                if ( type ) {
+                if ( type ) {  
                         switch ( type->kind ) {
                           case TypeData::Aggregate:
@@ -662 +663 @@
         } // if
 }
-
+        
 DeclarationNode *DeclarationNode::addIdList( DeclarationNode *ids ) {
         type = addIdListToType( type, ids );
@@ -793 +794 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast<DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -856 +857 @@
 Declaration *DeclarationNode::build() const {
         if ( type ) {
-                return type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildFuncSpecifier( Inline ), buildFuncSpecifier( Noreturn ), linkage, maybeBuild< Initializer >(initializer) )->set_extension( extension );
+                Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildFuncSpecifier( Inline ), buildFuncSpecifier( Noreturn ), linkage, maybeBuild< Initializer >(initializer) );
+                return newDecl;
         } // if
         if ( ! buildFuncSpecifier( Inline ) && ! buildFuncSpecifier( Noreturn ) ) {
-                return (new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
+                return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
         } // if
         throw SemanticError( "invalid function specifier in declaration of ", this );
@@ -866 +868 @@
 Type *DeclarationNode::buildType() const {
         assert( type );
-
+  
         switch ( type->kind ) {
           case TypeData::Enum:
@@ -879 +881 @@
                           ret = new UnionInstType( type->buildQualifiers(), type->aggregate->name );
                           break;
-                        case DeclarationNode::Trait:
-                          ret = new TraitInstType( type->buildQualifiers(), type->aggregate->name );
+                        case DeclarationNode::Context:
+                          ret = new ContextInstType( type->buildQualifiers(), type->aggregate->name );
                           break;
                         default: