Changes in src/Parser/DeclarationNode.cc [843054c2:de62360d]

File:

• src/Parser/DeclarationNode.cc (modified) (53 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 May 21 09:28:54 2015
-// Update Count     : 13
+// Last Modified On : Wed Jun 24 15:29:19 2015
+// Update Count     : 86
 //
 
@@ -21 +21 @@
 
 #include "TypeData.h"
+
+#include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
 
+#include "Parser.h"
+#include "TypedefTable.h"
+extern TypedefTable typedefTable;
 
 using namespace std;
 
 // These must remain in the same order as the corresponding DeclarationNode enumerations.
+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::modifierName[] = { "signed", "unsigned", "short", "long" };
-const char *DeclarationNode::tyConName[] = { "struct", "union", "context" };
+const char *DeclarationNode::modifierName[]  = { "signed", "unsigned", "short", "long" };
+const char *DeclarationNode::aggregateName[] = { "struct", "union", "context" };
 const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" };
 
@@ -63 +69 @@
 }
 
-const char *storageClassName[] = {
-        // order must correspond with DeclarationNode::StorageClass
-        "extern",
-        "static",
-        "auto",
-        "register",
-        "inline",
-        "fortran",
-};
-
 void DeclarationNode::print( std::ostream &os, int indent ) const {
-        os << string(indent, ' ' );
+        os << string( indent, ' ' );
         if ( name == "" ) {
                 os << "unnamed: ";
         } else {
                 os << name << ": ";
-        }
+        } // if
 
         if ( linkage != LinkageSpec::Cforall ) {
                 os << LinkageSpec::toString( linkage ) << " ";
-        }
-
-        printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, os );
+        } // if
+
+        printEnums( storageClasses.begin(), storageClasses.end(), DeclarationNode::storageName, os );
         if ( type ) {
                 type->print( os, indent );
         } else {
                 os << "untyped entity ";
-        }
+        } // if
 
         if ( bitfieldWidth ) {
-                os << endl << string(indent+2,  ' ') << "with bitfield width ";
+                os << endl << string( indent + 2, ' ' ) << "with bitfield width ";
                 bitfieldWidth->printOneLine( os );
-        }
+        } // if
 
         if ( initializer != 0 ) {
-                os << endl << string(indent+2,  ' ') << "with initializer ";
+                os << endl << string( indent + 2, ' ' ) << "with initializer ";
                 initializer->printOneLine( os );
-        }
+        } // if
 
         os << endl;
@@ -109 +105 @@
         if ( hasEllipsis ) {
                 os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
-        }
+        } // if
 }
 
@@ -123 +119 @@
         if ( body ) {
                 newnode->type->function->hasBody = true;
-        }
+        } // if
 
         if ( ret ) {
@@ -129 +125 @@
                 ret->type = 0;
                 delete ret;
-        }
+        } // if
 
         return newnode;
@@ -141 +137 @@
 }
 
-DeclarationNode *DeclarationNode::newStorageClass( StorageClass sc ) {
+DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->storageClasses.push_back( sc );
@@ -161 +157 @@
 }
 
-DeclarationNode *DeclarationNode::newForall( DeclarationNode* forall ) {
+DeclarationNode *DeclarationNode::newForall( DeclarationNode *forall ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Unknown );
@@ -168 +164 @@
 }
 
-DeclarationNode *DeclarationNode::newFromTypedef( std::string* name ) {
+DeclarationNode *DeclarationNode::newFromTypedef( std::string *name ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::SymbolicInst );
@@ -177 +173 @@
 }
 
-DeclarationNode *DeclarationNode::newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) {
+DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
@@ -184 +180 @@
         if ( newnode->type->aggregate->name == "" ) {
                 newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
-        }
+        } // if
+
+        // 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->params = formals;
         newnode->type->aggregate->actuals = actuals;
@@ -198 +202 @@
         if ( newnode->type->enumeration->name == "" ) {
                 newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
-        }
+        } // if
+
+        // 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() );
+
         newnode->type->enumeration->constants = constants;
         return newnode;
 }
 
-DeclarationNode *DeclarationNode::newEnumConstant( std::string* name, ExpressionNode *constant ) {
+DeclarationNode *DeclarationNode::newEnumConstant( std::string *name, ExpressionNode *constant ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->name = assign_strptr( name );
@@ -210 +222 @@
 }
 
-DeclarationNode *DeclarationNode::newName( std::string* name ) {
+DeclarationNode *DeclarationNode::newName( std::string *name ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->name = assign_strptr( name );
@@ -216 +228 @@
 }
 
-DeclarationNode *DeclarationNode::newFromTypeGen( std::string* name, ExpressionNode *params ) {
+DeclarationNode *DeclarationNode::newFromTypeGen( std::string *name, ExpressionNode *params ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::SymbolicInst );
@@ -225 +237 @@
 }
 
-DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string* name ) {
+DeclarationNode *DeclarationNode::newTypeParam( TypeClass tc, std::string *name ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->name = assign_strptr( name );
@@ -331 +343 @@
                         } else {
                                 dst->forall = src->forall;
-                        }
+                        } // if
                         src->forall = 0;
-                }
+                } // if
                 if ( dst->base ) {
                         addQualifiersToType( src, dst->base );
@@ -341 +353 @@
                 } else {
                         dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
-                }
-        }
+                } // if
+        } // if
 }
           
@@ -351 +363 @@
                         if ( ! type ) {
                                 type = new TypeData;
-                        }
+                        } // if
                         addQualifiersToType( q->type, type );
                         if ( q->type && q->type->forall ) {
@@ -357 +369 @@
                                         type->forall->appendList( q->type->forall );
                                 } else {
-                                        type->forall = q->type->forall;
-                                }
+                                        if ( type->kind == TypeData::Aggregate ) {
+                                                type->aggregate->params = q->type->forall;
+                                        } else {
+                                                type->forall = q->type->forall;
+                                        } // if
+                                } // if
                                 q->type->forall = 0;
-                        }
-                }
-        }
+                        } // if
+                } // if
+        } // if
         delete q;
         return this;
@@ -379 +395 @@
                         } else {
                                 dst->forall = src->forall;
-                        }
+                        } // if
                         src->forall = 0;
-                }
+                } // if
                 if ( dst->base ) {
                         addTypeToType( src, dst->base );
@@ -398 +414 @@
                                         dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers );
                                         dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec );
-                                }
+                                } // if
                                 break;
 
@@ -409 +425 @@
                                         if ( src->kind == TypeData::Aggregate ) {
                                                 dst->base->aggInst->params = maybeClone( src->aggregate->actuals );
-                                        }
+                                        } // if
                                         dst->base->qualifiers.splice( dst->base->qualifiers.end(), src->qualifiers );
                                         src = 0;
@@ -419 +435 @@
                                         } else {
                                                 dst->forall = src->forall;
-                                        }
+                                        } // if
                                         src->forall = 0;
                                         dst->base = src;
                                         src = 0;
-                                }
-                        }
-                }
-        }
+                                } // switch
+                        } // switch
+                } // if
+        } // if
 }
 
@@ -439 +455 @@
                                         if ( o->type->kind == TypeData::Aggregate ) {
                                                 type->aggInst->params = maybeClone( o->type->aggregate->actuals );
-                                        }
+                                        } // if
                                         type->qualifiers.splice( type->qualifiers.end(), o->type->qualifiers );
                                 } else {
                                         type = o->type;
-                                }
+                                } // if
                                 o->type = 0;
                         } else {
                                 addTypeToType( o->type, type );
-                        }
-                }
+                        } // if
+                } // if
                 if ( o->bitfieldWidth ) {
                         bitfieldWidth = o->bitfieldWidth;
-                }
-        }
+                } // if
+        } // if
         delete o;
         return this;
@@ -467 +483 @@
 }
 
-DeclarationNode *DeclarationNode::addAssertions( DeclarationNode* assertions ) {
+DeclarationNode *DeclarationNode::addAssertions( DeclarationNode *assertions ) {
         assert( type );
         switch ( type->kind ) {
@@ -475 +491 @@
                 } else {
                         type->symbolic->assertions = assertions;
-                }
+                } // if
                 break;
-        
           case TypeData::Variable:
                 if ( type->variable->assertions ) {
@@ -483 +498 @@
                 } else {
                         type->variable->assertions = assertions;
-                }
+                } // if
                 break;
-        
           default:
                 assert( false );
-        }
+        } // switch
         
         return this;
 }
 
-DeclarationNode *DeclarationNode::addName( std::string* newname ) {
+DeclarationNode *DeclarationNode::addName( std::string *newname ) {
         name = assign_strptr( newname );
         return this;
@@ -526 +540 @@
 }
 
-static void
-setBase( TypeData *&type, TypeData *newType ) {
+static void setBase( TypeData *&type, TypeData *newType ) {
         if ( type ) {
                 TypeData *prevBase = type;
@@ -534 +547 @@
                         prevBase = curBase;
                         curBase = curBase->base;
-                }
+                } // while
                 prevBase->base = newType;
         } else {
                 type = newType;
-        }
+        } // if
 }
 
@@ -547 +560 @@
                 p->type = 0;
                 delete p;
-        }
+        } // if
         return this;
 }
@@ -557 +570 @@
                 a->type = 0;
                 delete a;
-        }
+        } // if
         return this;
 }
@@ -572 +585 @@
                                 if ( type->kind == TypeData::Aggregate ) {
                                         p->type->base->aggInst->params = maybeClone( type->aggregate->actuals );
-                                }
+                                } // if
                                 p->type->base->qualifiers.splice( p->type->base->qualifiers.end(), type->qualifiers );
                                 break;
@@ -578 +591 @@
                           default:
                                 p->type->base = type;
-                        }
+                        } // switch
                         type = 0;
-                }
+                } // if
                 delete this;
                 return p;
         } else {
                 return this;
-        }
+        } // if
 }
 
@@ -593 +606 @@
         while ( cur->base ) {
                 cur = cur->base;
-        }
+        } // while
         return cur;
 }
@@ -609 +622 @@
                                 if ( type->kind == TypeData::Aggregate ) {
                                         lastArray->base->aggInst->params = maybeClone( type->aggregate->actuals );
-                                }
+                                } // if
                                 lastArray->base->qualifiers.splice( lastArray->base->qualifiers.end(), type->qualifiers );
                                 break;
                           default:
                                 lastArray->base = type;
-                        }
+                        } // switch
                         type = 0;
-                }
+                } // if
                 delete this;
                 return a;
         } else {
                 return this;
-        }
+        } // if
 }
 
@@ -637 +650 @@
                 } else {
                         type->function->idList = ids;
-                }
+                } // if
                 return type;
         } else {
@@ -643 +656 @@
                 newtype->function->idList = ids;
                 return newtype;
-        }
+        } // if
 }
         
@@ -662 +675 @@
         while ( srcType->base ) {
                 srcType = srcType->base;
-        }
+        } // while
         newnode->type = maybeClone( srcType );
         if ( newnode->type->kind == TypeData::AggregateInst ) {
@@ -673 +686 @@
                         delete newnode->type->aggInst->aggregate->aggregate->members;
                         newnode->type->aggInst->aggregate->aggregate->members = 0;
-                }
-        }
+                } // if
+        } // if
         newnode->type->forall = maybeClone( type->forall );
         newnode->storageClasses = storageClasses;
@@ -688 +701 @@
                         while ( srcType->base ) {
                                 srcType = srcType->base;
-                        }
+                        } // while
                         TypeData *newType = srcType->clone();
                         if ( newType->kind == TypeData::AggregateInst ) {
@@ -699 +712 @@
                                         delete newType->aggInst->aggregate->aggregate->members;
                                         newType->aggInst->aggregate->aggregate->members = 0;
-                                }
-                        }
+                                } // if
+                        } // if
                         newType->forall = maybeClone( type->forall );
                         if ( ! o->type ) {
@@ -707 +720 @@
                                 addTypeToType( newType, o->type );
                                 delete newType;
-                        }
-                }
-        }
+                        } // if
+                } // if
+        } // if
         return o;
 }
@@ -731 +744 @@
                                 addTypeToType( newType, o->type );
                                 delete newType;
-                        }
-                }
-        }
+                        } // if
+                } // if
+        } // if
         return o;
 }
@@ -740 +753 @@
         if ( node != 0 ) {
                 set_link( node );
-        }
+        } // if
         return this;
 }
@@ -756 +769 @@
 }
 
-void buildList( const DeclarationNode *firstNode, std::list< Declaration* > &outputList ) {
+void buildList( const DeclarationNode *firstNode, std::list< Declaration * > &outputList ) {
         SemanticError errors;
-        std::back_insert_iterator< std::list< Declaration* > > out( outputList );
+        std::back_insert_iterator< std::list< Declaration *> > out( outputList );
         const DeclarationNode *cur = firstNode;
         while ( cur ) {
@@ -776 +789 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -783 +796 @@
 }
 
-void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType* > &outputList ) {
+void buildList( const DeclarationNode *firstNode, std::list< DeclarationWithType *> &outputList ) {
         SemanticError errors;
-        std::back_insert_iterator< std::list< DeclarationWithType* > > out( outputList );
+        std::back_insert_iterator< std::list< DeclarationWithType *> > out( outputList );
         const DeclarationNode *cur = firstNode;
         while ( cur ) {
@@ -799 +812 @@
                         Declaration *decl = cur->build();
                         if ( decl ) {
-                                if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( decl ) ) {
+                                if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType *>( decl ) ) {
                                         *out++ = dwt;
-                                } else if ( StructDecl *agg = dynamic_cast< StructDecl* >( decl ) ) {
+                                } else if ( StructDecl *agg = dynamic_cast< StructDecl *>( decl ) ) {
                                         StructInstType *inst = new StructInstType( Type::Qualifiers(), agg->get_name() );
-                                        *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
+                                        *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
                                         delete agg;
-                                } else if ( UnionDecl *agg = dynamic_cast< UnionDecl* >( decl ) ) {
+                                } else if ( UnionDecl *agg = dynamic_cast< UnionDecl *>( decl ) ) {
                                         UnionInstType *inst = new UnionInstType( Type::Qualifiers(), agg->get_name() );
-                                        *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
+                                        *out++ = new ObjectDecl( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
                                 } // if
                         } // if
@@ -813 +826 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -820 +833 @@
 }
 
-void buildTypeList( const DeclarationNode *firstNode, std::list< Type* > &outputList ) {
+void buildTypeList( const DeclarationNode *firstNode, std::list< Type *> &outputList ) {
         SemanticError errors;
-        std::back_insert_iterator< std::list< Type* > > out( outputList );
+        std::back_insert_iterator< std::list< Type *> > out( outputList );
         const DeclarationNode *cur = firstNode;
         while ( cur ) {
@@ -830 +843 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -839 +852 @@
 Declaration *DeclarationNode::build() const {
         if ( type ) {
-                Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) );
+                Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildFuncSpecifier( Inline ), buildFuncSpecifier( Noreturn ), linkage, maybeBuild< Initializer >(initializer) );
                 return newDecl;
         } // if
-        if ( ! buildInline() ) {
+        if ( ! buildFuncSpecifier( Inline ) && ! buildFuncSpecifier( Noreturn ) ) {
                 return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
         } // if
-        throw SemanticError( "invalid inline specification in declaration of ", this );
+        throw SemanticError( "invalid function specifier in declaration of ", this );
 }
 
@@ -882 +895 @@
 }
 
-Declaration::StorageClass DeclarationNode::buildStorageClass() const {
-        static const Declaration::StorageClass scMap[] = {  
-                Declaration::Extern,
-                Declaration::Static,
-                Declaration::Auto,
-                Declaration::Register,
-                Declaration::Inline,
-                Declaration::Fortran
-        };  
-  
-        Declaration::StorageClass ret = Declaration::NoStorageClass;
-        for ( std::list< StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
-                assert( unsigned( *i ) < sizeof( scMap ) / sizeof( scMap[0] ) );
-          if ( *i == Inline ) continue;
-          if ( ret != Declaration::NoStorageClass ) {
+DeclarationNode::StorageClass DeclarationNode::buildStorageClass() const {
+        DeclarationNode::StorageClass ret = DeclarationNode::NoStorageClass;
+        for ( std::list< DeclarationNode::StorageClass >::const_iterator i = storageClasses.begin(); i != storageClasses.end(); ++i ) {
+          if ( *i == DeclarationNode::Inline || *i == DeclarationNode::Noreturn ) continue; // ignore function specifiers
+          if ( ret != DeclarationNode::NoStorageClass ) {       // already have a valid storage class ?
                         throw SemanticError( "invalid combination of storage classes in declaration of ", this );
-                }
-                ret = scMap[ *i ];
-        }
+                } // if
+                ret = *i;
+        } // for
         return ret;
 }
 
-bool DeclarationNode::buildInline() const {
-        std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline );
-  if ( first == storageClasses.end() ) return false;
-        std::list< StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), Inline );
-  if ( next == storageClasses.end() ) return true;
-        throw SemanticError( "duplicate inline specification in declaration of ", this );
+bool DeclarationNode::buildFuncSpecifier( DeclarationNode::StorageClass key ) const {
+        std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), key );
+  if ( first == storageClasses.end() ) return false;    // not found
+        first = std::find( ++first, storageClasses.end(), key ); // found
+  if ( first == storageClasses.end() ) return true;             // not found again
+        throw SemanticError( "duplicate function specifier in declaration of ", this );
 }