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

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 : Sun Sep 11 09:24:11 2016
-// Update Count     : 438
+// Last Modified On : Mon Aug 29 22:30:56 2016
+// Update Count     : 327
 //
 
@@ -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", "NoStorageClass" };
+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",  };
@@ -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 ) {
+DeclarationNode::DeclarationNode()
+                : type( 0 )
+                , storageClass( NoStorageClass )
+                , isInline( false )
+                , isNoreturn( false )
+                , bitfieldWidth( 0 )
+                , initializer( 0 )
+                , hasEllipsis( false )
+                , linkage( ::linkage )
+                , extension( false )
+                , error() {
+        attr.expr = nullptr;
+        attr.type = nullptr;
+
         variable.tyClass = DeclarationNode::Type;
         variable.assertions = nullptr;
-
-        attr.expr = nullptr;
-        attr.type = nullptr;
 }
 
@@ -389 +390 @@
 
 void DeclarationNode::checkQualifiers( const TypeData *src, const TypeData *dst ) {
-        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];
+        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;
                         } // 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 ) {
-                checkStorageClasses( q );
-                copyStorageClasses( q );
+                copyStorageClasses(q);
                 if ( q->type ) {
                         if ( ! type ) {
@@ -457 +433 @@
         } // 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;
 }
@@ -516 +504 @@
 DeclarationNode *DeclarationNode::addType( DeclarationNode *o ) {
         if ( o ) {
-                checkStorageClasses( o );
                 copyStorageClasses( o );
                 if ( o->type ) {
@@ -764 +751 @@
         } // if
         newnode->type->forall = maybeClone( type->forall );
-        assert( storageClass == NoStorageClass );
         newnode->copyStorageClasses( this );
         newnode->name = assign_strptr( newName );
@@ -805 +791 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = maybeClone( type );
-        assert( storageClass == NoStorageClass );
         newnode->copyStorageClasses( this );
         newnode->name = assign_strptr( newName );
@@ -813 +798 @@
 DeclarationNode *DeclarationNode::cloneType( DeclarationNode *o ) {
         if ( o ) {
-                assert( storageClass == NoStorageClass );
                 o->copyStorageClasses( this );
                 if ( type ) {
@@ -924 +908 @@
 
 Declaration *DeclarationNode::build() const {
-        if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this );
+        if ( ! error.empty() ) throw SemanticError( error, this );
         if ( type ) {
                 if ( type->kind == TypeData::Variable ) {
@@ -938 +922 @@
                 return (new ObjectDecl( name, storageClass, linkage, maybeBuild< Expression >( bitfieldWidth ), 0, maybeBuild< Initializer >( initializer ) ))->set_extension( extension );
         } // if
-        throw SemanticError( "invalid function specifier ", this );
+        throw SemanticError( "invalid function specifier in declaration of ", this );
 }
 
@@ -987 +971 @@
 }
 
+// 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 //