Changeset fd782b2 for src/Parser/DeclarationNode.cc

Timestamp:

Sep 15, 2016, 10:55:52 AM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

aa8f9df

Parents:

f006f01 (diff), 1eba452 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into tuples

Conflicts:

src/Parser/ParseNode.h

File:

• src/Parser/DeclarationNode.cc (modified) (8 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 : 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",  };
@@ -389 +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 ?
+        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] ) {
-                                error += string(error.empty() ? "" : ", ") + "duplicate " + DeclarationNode::qualifierName[i];
+                                if ( ! error.empty() ) error += ", ";   // separator
+                                error += string( "duplicate " ) + DeclarationNode::qualifierName[i];
                         } // if
                 } // for
         } // 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 ) {
@@ -429 +459 @@
         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 ) {
-                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
 
 static void addTypeToType( TypeData *&src, TypeData *&dst ) {
@@ -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 ) {