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

File:

• src/Parser/DeclarationNode.cc (modified) (7 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 : Fri Sep  9 23:21:47 2016
-// Update Count     : 402
+// Last Modified On : Mon Aug 29 22:30:56 2016
+// Update Count     : 327
 //
 
@@ -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;
 }
 
@@ -392 +393 @@
 
         if ( (qsrc & qdst).any() ) {                                            // common bits between qualifier masks ?
-                for ( int i = 0; i < NoOfQualifier; i += 1 ) {  // find common qualifiers
-                        if ( qsrc[i] & qdst[i] ) {
-                                error += string(error.empty() ? "" : ", ") + "duplicate " + DeclarationNode::qualifierName[i];
+                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
@@ -436 +442 @@
                 storageClass = q->storageClass;
         } else if ( q->storageClass != NoStorageClass ) {
-                if ( storageClass == q->storageClass ) {
-                        q->error += string( "duplicate " ) + storageName[ storageClass ];
-                } else {                                                                                // can only have one storage class
-                        q->error += string( "multiple " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ];
-                } // if
-        } // if
-        if ( ! q->error.empty() ) {
-                error += (! error.empty() ? ", " : "") + q->error;
-        } // if
-        return this;
-} // DeclarationNode::copyStorageClasses
+                q->error = "invalid combination of storage classes in declaration of ";
+        } // if
+        if ( error.empty() ) error = q->error;
+        return this;
+}
 
 static void addTypeToType( TypeData *&src, TypeData *&dst ) {
@@ -908 +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 ) {
@@ -922 +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 );
 }
 
@@ -971 +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 //