Changes in src/Parser/DeclarationNode.cc [68cd1ce:59db689]

File:

• src/Parser/DeclarationNode.cc (modified) (41 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 : Sat Jun 13 08:02:03 2015
-// Update Count     : 58
+// Last Modified On : Sat Jun  6 23:29:13 2015
+// Update Count     : 23
 //
 
@@ -21 +21 @@
 
 #include "TypeData.h"
-
-#include "SynTree/Declaration.h"
 #include "SynTree/Expression.h"
 
+
 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" };
 
@@ -65 +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, ' ' );
@@ -71 +79 @@
         } 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 ";
                 bitfieldWidth->printOneLine( os );
-        } // if
+        }
 
         if ( initializer != 0 ) {
                 os << endl << string( indent + 2, ' ' ) << "with initializer ";
                 initializer->printOneLine( os );
-        } // if
+        }
 
         os << endl;
@@ -101 +109 @@
         if ( hasEllipsis ) {
                 os << string( indent, ' ' )  << "and a variable number of other arguments" << endl;
-        } // if
+        }
 }
 
@@ -115 +123 @@
         if ( body ) {
                 newnode->type->function->hasBody = true;
-        } // if
+        }
 
         if ( ret ) {
@@ -121 +129 @@
                 ret->type = 0;
                 delete ret;
-        } // if
+        }
 
         return newnode;
@@ -133 +141 @@
 }
 
-DeclarationNode *DeclarationNode::newStorageClass( DeclarationNode::StorageClass sc ) {
+DeclarationNode *DeclarationNode::newStorageClass( StorageClass sc ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->storageClasses.push_back( sc );
@@ -169 +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 );
@@ -176 +184 @@
         if ( newnode->type->aggregate->name == "" ) {
                 newnode->type->aggregate->name = DeclarationNode::anonymous.newName();
-        } // if
+        }
         newnode->type->aggregate->params = formals;
         newnode->type->aggregate->actuals = actuals;
@@ -190 +198 @@
         if ( newnode->type->enumeration->name == "" ) {
                 newnode->type->enumeration->name = DeclarationNode::anonymous.newName();
-        } // if
+        }
         newnode->type->enumeration->constants = constants;
         return newnode;
@@ -323 +331 @@
                         } else {
                                 dst->forall = src->forall;
-                        } // if
+                        }
                         src->forall = 0;
-                } // if
+                }
                 if ( dst->base ) {
                         addQualifiersToType( src, dst->base );
@@ -333 +341 @@
                 } else {
                         dst->qualifiers.splice( dst->qualifiers.end(), src->qualifiers );
-                } // if
-        } // if
+                }
+        }
 }
           
@@ -343 +351 @@
                         if ( ! type ) {
                                 type = new TypeData;
-                        } // if
+                        }
                         addQualifiersToType( q->type, type );
                         if ( q->type && q->type->forall ) {
@@ -349 +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;
@@ -375 +379 @@
                         } else {
                                 dst->forall = src->forall;
-                        } // if
+                        }
                         src->forall = 0;
-                } // if
+                }
                 if ( dst->base ) {
                         addTypeToType( src, dst->base );
@@ -394 +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;
 
@@ -405 +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;
@@ -415 +419 @@
                                         } else {
                                                 dst->forall = src->forall;
-                                        } // if
+                                        }
                                         src->forall = 0;
                                         dst->base = src;
                                         src = 0;
-                                } // switch
-                        } // switch
-                } // if
-        } // if
+                                }
+                        }
+                }
+        }
 }
 
@@ -435 +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;
@@ -471 +475 @@
                 } else {
                         type->symbolic->assertions = assertions;
-                } // if
+                }
                 break;
+        
           case TypeData::Variable:
                 if ( type->variable->assertions ) {
@@ -478 +483 @@
                 } else {
                         type->variable->assertions = assertions;
-                } // if
+                }
                 break;
+        
           default:
                 assert( false );
-        } // switch
+        }
         
         return this;
@@ -520 +526 @@
 }
 
-static void setBase( TypeData *&type, TypeData *newType ) {
+static void
+setBase( TypeData *&type, TypeData *newType ) {
         if ( type ) {
                 TypeData *prevBase = type;
@@ -527 +534 @@
                         prevBase = curBase;
                         curBase = curBase->base;
-                } // while
+                }
                 prevBase->base = newType;
         } else {
                 type = newType;
-        } // if
+        }
 }
 
@@ -540 +547 @@
                 p->type = 0;
                 delete p;
-        } // if
+        }
         return this;
 }
@@ -550 +557 @@
                 a->type = 0;
                 delete a;
-        } // if
+        }
         return this;
 }
@@ -565 +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;
@@ -571 +578 @@
                           default:
                                 p->type->base = type;
-                        } // switch
+                        }
                         type = 0;
-                } // if
+                }
                 delete this;
                 return p;
         } else {
                 return this;
-        } // if
+        }
 }
 
@@ -586 +593 @@
         while ( cur->base ) {
                 cur = cur->base;
-        } // while
+        }
         return cur;
 }
@@ -602 +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
+        }
 }
 
@@ -630 +637 @@
                 } else {
                         type->function->idList = ids;
-                } // if
+                }
                 return type;
         } else {
@@ -636 +643 @@
                 newtype->function->idList = ids;
                 return newtype;
-        } // if
+        }
 }
         
@@ -655 +662 @@
         while ( srcType->base ) {
                 srcType = srcType->base;
-        } // while
+        }
         newnode->type = maybeClone( srcType );
         if ( newnode->type->kind == TypeData::AggregateInst ) {
@@ -666 +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;
@@ -681 +688 @@
                         while ( srcType->base ) {
                                 srcType = srcType->base;
-                        } // while
+                        }
                         TypeData *newType = srcType->clone();
                         if ( newType->kind == TypeData::AggregateInst ) {
@@ -692 +699 @@
                                         delete newType->aggInst->aggregate->aggregate->members;
                                         newType->aggInst->aggregate->aggregate->members = 0;
-                                } // if
-                        } // if
+                                }
+                        }
                         newType->forall = maybeClone( type->forall );
                         if ( ! o->type ) {
@@ -700 +707 @@
                                 addTypeToType( newType, o->type );
                                 delete newType;
-                        } // if
-                } // if
-        } // if
+                        }
+                }
+        }
         return o;
 }
@@ -724 +731 @@
                                 addTypeToType( newType, o->type );
                                 delete newType;
-                        } // if
-                } // if
-        } // if
+                        }
+                }
+        }
         return o;
 }
@@ -733 +740 @@
         if ( node != 0 ) {
                 set_link( node );
-        } // if
+        }
         return this;
 }
@@ -796 +803 @@
                                 } 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 ) ) {
                                         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
@@ -875 +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::buildInline() const {
-        std::list< DeclarationNode::StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), DeclarationNode::Inline );
+        std::list< StorageClass >::const_iterator first = std::find( storageClasses.begin(), storageClasses.end(), Inline );
   if ( first == storageClasses.end() ) return false;
-        std::list< DeclarationNode::StorageClass >::const_iterator next = std::find( ++first, storageClasses.end(), DeclarationNode::Inline );
+        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 );