Changes in src/Parser/DeclarationNode.cc [28307be:b6424d9]

File:

• src/Parser/DeclarationNode.cc (modified) (12 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 : Mon Aug 29 22:30:56 2016
-// Update Count     : 327
+// Last Modified On : Sun Sep 11 09:24:11 2016
+// Update Count     : 438
 //
 
@@ -31 +31 @@
 
 // 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::storageName[] = { "extern", "static", "auto", "register", "inline", "fortran", "_Noreturn", "_Thread_local", "NoStorageClass" };
 const char *DeclarationNode::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic" };
 const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary",  };
@@ -43 +43 @@
 extern LinkageSpec::Spec linkage;                                               // defined in parser.yy
 
-DeclarationNode::DeclarationNode()
-                : type( 0 )
-                , storageClass( NoStorageClass )
-                , isInline( false )
-                , isNoreturn( false )
-                , bitfieldWidth( 0 )
-                , initializer( 0 )
-                , hasEllipsis( false )
-                , linkage( ::linkage )
-                , extension( false )
-                , error() {
+DeclarationNode::DeclarationNode() :
+                type( 0 ),
+                storageClass( NoStorageClass ),
+                isInline( false ),
+                isNoreturn( false ),
+                bitfieldWidth( 0 ),
+                initializer( 0 ),
+                hasEllipsis( false ),
+                linkage( ::linkage ),
+                extension( false ) {
+        variable.tyClass = DeclarationNode::Type;
+        variable.assertions = nullptr;
+
         attr.expr = nullptr;
         attr.type = nullptr;
-
-        variable.tyClass = DeclarationNode::Type;
-        variable.assertions = nullptr;
 }
 
@@ -390 +389 @@
 
 void DeclarationNode::checkQualifiers( const TypeData *src, const TypeData *dst ) {
-        TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers;
-
-        if ( (qsrc & qdst).any() ) {                                            // common bits between qualifier masks ?
-                error = "duplicate qualifier ";
-                int j = 0;                                                                              // separator detector
-                for ( int i = 0; i < DeclarationNode::NoOfQualifier; i += 1 ) {
-                        if ( qsrc[i] & qdst[i] ) {                                      // find specific qualifiers in common
-                                if ( j > 0 ) error += ", ";
-                                error += DeclarationNode::qualifierName[i];
-                                j += 1;
+        TypeData::Qualifiers qsrc = src->qualifiers, qdst = dst->qualifiers; // optimization
+
+        if ( (qsrc & qdst).any() ) {                                            // common qualifier ?
+                for ( int i = 0; i < NoOfQualifier; i += 1 ) {  // find common qualifiers
+                        if ( qsrc[i] & qdst[i] ) {
+                                if ( ! error.empty() ) error += ", ";   // separator
+                                error += string( "duplicate " ) + DeclarationNode::qualifierName[i];
                         } // if
                 } // for
-                error += " in declaration of ";
         } // if
 } // DeclarationNode::checkQualifiers
+
+void DeclarationNode::checkStorageClasses( DeclarationNode *q ) {
+        if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
+                if ( ! error.empty() ) error += ", ";                   // separator
+                if ( storageClass == q->storageClass ) {                // duplicate qualifier
+                        error += string( "duplicate " ) + storageName[ storageClass ];
+                } else {                                                                                // only one storage class
+                        error += string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ];
+                        q->storageClass = storageClass;                         // FIX ERROR
+                } // if
+                if ( ! q->error.empty() ) error += ", " + q->error;     // separator
+        } else {
+                if ( ! error.empty() ) {
+                        if ( ! q->error.empty() ) error += ", " + q->error; // separator
+                } else if ( ! q->error.empty() ) error += q->error;
+        } // if
+} // DeclarationNode::copyStorageClasses
+
+DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
+        isInline = isInline | q->isInline;
+        isNoreturn = isNoreturn | q->isNoreturn;
+        // do not overwrite an existing value with NoStorageClass
+        if ( q->storageClass != NoStorageClass ) {
+                assert( storageClass == NoStorageClass || storageClass == q->storageClass );
+                storageClass = q->storageClass;
+        } // if
+        return this;
+} // DeclarationNode::copyStorageClasses
 
 DeclarationNode *DeclarationNode::addQualifiers( DeclarationNode *q ) {
         if ( q ) {
-                copyStorageClasses(q);
+                checkStorageClasses( q );
+                copyStorageClasses( q );
                 if ( q->type ) {
                         if ( ! type ) {
@@ -433 +457 @@
         } // if
         delete q;
-        return this;
-}
-
-DeclarationNode *DeclarationNode::copyStorageClasses( DeclarationNode *q ) {
-        isInline = isInline || q->isInline;
-        isNoreturn = isNoreturn || q->isNoreturn;
-        if ( storageClass == NoStorageClass ) {
-                storageClass = q->storageClass;
-        } else if ( q->storageClass != NoStorageClass ) {
-                q->error = "invalid combination of storage classes in declaration of ";
-        } // if
-        if ( error.empty() ) error = q->error;
         return this;
 }
@@ -504 +516 @@
 DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
         if ( o ) {
+                checkStorageClasses( o );
                 copyStorageClasses( o );
                 if ( o->type ) {
@@ -751 +764 @@
         } // if
         newnode->type->forall = maybeClone( type->forall );
+        assert( storageClass == NoStorageClass );
         newnode->copyStorageClasses( this );
         newnode->name = assign_strptr( newName );
@@ -791 +805 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
+        assert( storageClass == NoStorageClass );
         newnode->copyStorageClasses( this );
         newnode->name = assign_strptr( newName );
@@ -798 +813 @@
 DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
         if ( o ) {
+                assert( storageClass == NoStorageClass );
                 o->copyStorageClasses( this );
                 if ( type ) {
@@ -908 +924 @@
 
 Declaration *DeclarationNode::build() const {
-        if ( ! error.empty() ) throw SemanticError( error, this );
+        if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this );
         if ( type ) {
                 if ( type->kind == TypeData::Variable ) {
@@ -922 +938 @@
                 return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
         } // if
-        throw SemanticError( "invalid function specifier in declaration of ", this );
+        throw SemanticError( "invalid function specifier ", this );
 }
 
@@ -971 +987 @@
 }
 
-// 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 );
-//              } // if
-//              ret = *i;
-//      } // for
-//      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 );
-// }
-
 // Local Variables: //
 // tab-width: 4 //