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

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 : Wed Jun 24 15:29:19 2015
-// Update Count     : 86
+// Last Modified On : Thu May 21 09:28:54 2015
+// Update Count     : 13
 //
 
@@ -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::aggregateName[] = { "struct", "union", "context" };
+const char *DeclarationNode::modifierName[] = { "signed", "unsigned", "short", "long" };
+const char *DeclarationNode::tyConName[] = { "struct", "union", "context" };
 const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" };
 
@@ -69 +63 @@
 }
 
+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 ) << " ";
-        } // if
-
-        printEnums( storageClasses.begin(), storageClasses.end(), DeclarationNode::storageName, os );
+        }
+
+        printEnums( storageClasses.begin(), storageClasses.end(), storageClassName, 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;
@@ -105 +109 @@
         if ( hasEllipsis ) {
                 os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
-        } // if
+        }
 }
 
@@ -119 +123 @@
         if ( body ) {
                 newnode->type->function->hasBody = true;
-        } // if
+        }
 
         if ( ret ) {
@@ -125 +129 @@
                 ret->type = 0;
                 delete ret;
-        } // if
+        }
 
         return newnode;
@@ -137 +141 @@
 }
 
-DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
+DeclarationNode *DeclarationNode::newStorageClass( StorageClass sc ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->storageClasses.push_back( sc );
@@ -157 +161 @@
 }
 
-DeclarationNode *DeclarationNode::newForall( DeclarationNode *forall ) {
+DeclarationNode *DeclarationNode::newForall( DeclarationNode* forall ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Unknown );
@@ -164 +168 @@
 }
 
-DeclarationNode *DeclarationNode::newFromTypedef( std::string *name ) {
+DeclarationNode *DeclarationNode::newFromTypedef( std::string* name ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::SymbolicInst );
@@ -173 +177 @@
 }
 
-DeclarationNode *DeclarationNode::newAggregate( Aggregate kind, std::string *name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) {
+DeclarationNode *DeclarationNode::newAggregate( TyCon kind, std::string* name, DeclarationNode *formals, ExpressionNode *actuals, DeclarationNode *fields ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Aggregate );
@@ -180 +184 @@
         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;
@@ -202 +198 @@
         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 );
@@ -222 +210 @@
 }
 
-DeclarationNode *DeclarationNode::newName( std::string *name ) {
+DeclarationNode *DeclarationNode::newName( std::string* name ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->name = assign_strptr( name );
@@ -228 +216 @@
 }
 
-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 );
@@ -237 +225 @@
 }
 
-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 );
@@ -343 +331 @@
                         } else {
                                 dst->forall = src->forall;
-                        } // if
+                        }
                         src->forall = 0;
-                } // if
+                }
                 if ( dst->base ) {
                         addQualifiersToType( src, dst->base );
@@ -353 +341 @@
                 } else {
                         dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
-                } // if
-        } // if
+                }
+        }
 }
           
@@ -363 +351 @@
                         if ( ! type ) {
                                 type = new TypeData;
-                        } // if
+                        }
                         addQualifiersToType( q->type, type );
                         if ( q->type && q->type->forall ) {
@@ -369 +357 @@
                                         type->forall->appendList( q->type->forall );
                                 } else {
-                                        if ( type->kind == TypeData::Aggregate ) {
-                                                type->aggregate->params = q->type->forall;
-                                        } else {
-                                                type->forall = q->type->forall;
-                                        } // if
-                                } // if
+                                        type->forall = q->type->forall;
+                                }
                                 q->type->forall = 0;
-                        } // if
-                } // if
-        } // if
+                        }
+                }
+        }
         delete q;
         return this;
@@ -395 +379 @@
                         } else {
                                 dst->forall = src->forall;
-                        } // if
+                        }
                         src->forall = 0;
-                } // if
+                }
                 if ( dst->base ) {
                         addTypeToType( src, dst->base );
@@ -414 +398 @@
                                         dst->basic->modifiers.splice( dst->basic->modifiers.end(), src->basic->modifiers );
                                         dst->basic->typeSpec.splice( dst->basic->typeSpec.end(), src->basic->typeSpec );
-                                } // if
+                                }
                                 break;
 
@@ -425 +409 @@
                                         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;
@@ -435 +419 @@
                                         } else {
                                                 dst->forall = src->forall;
-                                        } // if
+                                        }
                                         src->forall = 0;
                                         dst->base = src;
                                         src = 0;
-                                } // switch
-                        } // switch
-                } // if
-        } // if
+                                }
+                        }
+                }
+        }
 }
 
@@ -455 +439 @@
                                         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;
@@ -483 +467 @@
 }
 
-DeclarationNode *DeclarationNode::addAssertions( DeclarationNode *assertions ) {
+DeclarationNode *DeclarationNode::addAssertions( DeclarationNode* assertions ) {
         assert( type );
         switch ( type->kind ) {
@@ -491 +475 @@
                 } else {
                         type->symbolic->assertions = assertions;
-                } // if
+                }
                 break;
+        
           case TypeData::Variable:
                 if ( type->variable->assertions ) {
@@ -498 +483 @@
                 } 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;
@@ -540 +526 @@
 }
 
-static void setBase( TypeData *&type, TypeData *newType ) {
+static void
+setBase( TypeData *&type, TypeData *newType ) {
         if ( type ) {
                 TypeData *prevBase = type;
@@ -547 +534 @@
                         prevBase = curBase;
                         curBase = curBase->base;
-                } // while
+                }
                 prevBase->base = newType;
         } else {
                 type = newType;
-        } // if
+        }
 }
 
@@ -560 +547 @@
                 p->type = 0;
                 delete p;
-        } // if
+        }
         return this;
 }
@@ -570 +557 @@
                 a->type = 0;
                 delete a;
-        } // if
+        }
         return this;
 }
@@ -585 +572 @@
                                 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;
@@ -591 +578 @@
                           default:
                                 p->type->base = type;
-                        } // switch
+                        }
                         type = 0;
-                } // if
+                }
                 delete this;
                 return p;
         } else {
                 return this;
-        } // if
+        }
 }
 
@@ -606 +593 @@
         while ( cur->base ) {
                 cur = cur->base;
-        } // while
+        }
         return cur;
 }
@@ -622 +609 @@
                                 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
+        }
 }
 
@@ -650 +637 @@
                 } else {
                         type->function->idList = ids;
-                } // if
+                }
                 return type;
         } else {
@@ -656 +643 @@
                 newtype->function->idList = ids;
                 return newtype;
-        } // if
+        }
 }
         
@@ -675 +662 @@
         while ( srcType->base ) {
                 srcType = srcType->base;
-        } // while
+        }
         newnode->type = maybeClone( srcType );
         if ( newnode->type->kind == TypeData::AggregateInst ) {
@@ -686 +673 @@
                         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;
@@ -701 +688 @@
                         while ( srcType->base ) {
                                 srcType = srcType->base;
-                        } // while
+                        }
                         TypeData *newType = srcType->clone();
                         if ( newType->kind == TypeData::AggregateInst ) {
@@ -712 +699 @@
                                         delete newType->aggInst->aggregate->aggregate->members;
                                         newType->aggInst->aggregate->aggregate->members = 0;
-                                } // if
-                        } // if
+                                }
+                        }
                         newType->forall = maybeClone( type->forall );
                         if ( ! o->type ) {
@@ -720 +707 @@
                                 addTypeToType( newType, o->type );
                                 delete newType;
-                        } // if
-                } // if
-        } // if
+                        }
+                }
+        }
         return o;
 }
@@ -744 +731 @@
                                 addTypeToType( newType, o->type );
                                 delete newType;
-                        } // if
-                } // if
-        } // if
+                        }
+                }
+        }
         return o;
 }
@@ -753 +740 @@
         if ( node != 0 ) {
                 set_link( node );
-        } // if
+        }
         return this;
 }
@@ -769 +756 @@
 }
 
-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 ) {
@@ -789 +776 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -796 +783 @@
 }
 
-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 ) {
@@ -812 +799 @@
                         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( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
+                                        *out++ = new ObjectDecl( "", Declaration::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( "", DeclarationNode::NoStorageClass, linkage, 0, inst, 0 );
+                                        *out++ = new ObjectDecl( "", Declaration::NoStorageClass, linkage, 0, inst, 0 );
                                 } // if
                         } // if
@@ -826 +813 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -833 +820 @@
 }
 
-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 ) {
@@ -843 +830 @@
                         errors.append( e );
                 } // try
-                cur = dynamic_cast< DeclarationNode *>( cur->get_link() );
+                cur = dynamic_cast< DeclarationNode* >( cur->get_link() );
         } // while
         if ( ! errors.isEmpty() ) {
@@ -852 +839 @@
 Declaration *DeclarationNode::build() const {
         if ( type ) {
-                Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildFuncSpecifier( Inline ), buildFuncSpecifier( Noreturn ), linkage, maybeBuild< Initializer >(initializer) );
+                Declaration *newDecl = type->buildDecl( name, buildStorageClass(), maybeBuild< Expression >( bitfieldWidth ), buildInline(), linkage, maybeBuild< Initializer >(initializer) );
                 return newDecl;
         } // if
-        if ( ! buildFuncSpecifier( Inline ) && ! buildFuncSpecifier( Noreturn ) ) {
+        if ( ! buildInline() ) {
                 return new ObjectDecl( name, buildStorageClass(), linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) );
         } // if
-        throw SemanticError( "invalid function specifier in declaration of ", this );
+        throw SemanticError( "invalid inline specification in declaration of ", this );
 }
 
@@ -895 +882 @@
 }
 
-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 ?
+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 ) {
                         throw SemanticError( "invalid combination of storage classes in declaration of ", this );
-                } // if
-                ret = *i;
-        } // for
+                }
+                ret = scMap[ *i ];
+        }
         return ret;
 }
 
-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 );
+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 );
 }