Changes in src/Parser/DeclarationNode.cc [5b639ee:b6424d9]

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 : Mon Sep 12 21:03:18 2016
-// Update Count     : 491
+// Last Modified On : Sun Sep 11 09:24:11 2016
+// Update Count     : 438
 //
 
@@ -32 +32 @@
 // 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::qualifierName[] = { "const", "restrict", "volatile", "lvalue", "_Atomic", "NoQualifier" };
-const char *DeclarationNode::basicTypeName[] = { "void", "_Bool", "char", "int", "float", "double", "long double", "NoBasicType" };
-const char *DeclarationNode::complexTypeName[] = { "_Complex", "_Imaginary", "NoComplexType" };
-const char *DeclarationNode::signednessName[] = { "signed", "unsigned", "NoSignedness" };
-const char *DeclarationNode::lengthName[] = { "short", "long", "long long", "NoLength" };
+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::typeClassName[] = { "otype", "dtype", "ftype" };
+const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" };
 const char *DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
 
@@ -55 +53 @@
                 linkage( ::linkage ),
                 extension( false ) {
-        variable.tyClass = DeclarationNode::Otype;
+        variable.tyClass = DeclarationNode::Type;
         variable.assertions = nullptr;
 
@@ -190 +188 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->basictype = bt;
+        newnode->type->basic.typeSpec.push_back( bt );
         return newnode;
 } // DeclarationNode::newBasicType
 
-DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
+DeclarationNode * DeclarationNode::newModifier( Modifier mod ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->complextype = ct;
-        return newnode;
-} // DeclarationNode::newComplexType
-
-DeclarationNode * DeclarationNode::newSignedNess( Signedness sn ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->signedness = sn;
-        return newnode;
-} // DeclarationNode::newSignedNess
-
-DeclarationNode * DeclarationNode::newLength( Length lnth ) {
-        DeclarationNode *newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->length = lnth;
-        return newnode;
-} // DeclarationNode::newLength
+        newnode->type->basic.modifiers.push_back( mod );
+        return newnode;
+} // DeclarationNode::newModifier
 
 DeclarationNode * DeclarationNode::newFromTypedef( std::string *name ) {
@@ -404 +388 @@
 }
 
-void appendError( string & dst, const string & src ) {
-        if ( src.empty() ) return;
-        if ( dst.empty() ) { dst = src; return; }
-        dst += ", " + src;
-} // appendError
-
 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 < NoQualifier; i += 1 ) {    // find common qualifiers
-                        if ( qsrc[i] && qdst[i] ) {
-                                appendError( error, string( "duplicate " ) + DeclarationNode::qualifierName[i] );
+                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
@@ -424 +403 @@
 void DeclarationNode::checkStorageClasses( DeclarationNode *q ) {
         if ( storageClass != NoStorageClass && q->storageClass != NoStorageClass ) {
+                if ( ! error.empty() ) error += ", ";                   // separator
                 if ( storageClass == q->storageClass ) {                // duplicate qualifier
-                        appendError( error, string( "duplicate " ) + storageName[ storageClass ] );
+                        error += string( "duplicate " ) + storageName[ storageClass ];
                 } else {                                                                                // only one storage class
-                        appendError( error, string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ] );
-                        q->storageClass = storageClass;                         // FIX ERROR, prevent assertions from triggering
-                } // if
-        } // if
-        appendError( error, q->error );
+                        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;
+        isInline = isInline | q->isInline;
+        isNoreturn = isNoreturn | q->isNoreturn;
         // do not overwrite an existing value with NoStorageClass
         if ( q->storageClass != NoStorageClass ) {
@@ -499 +483 @@
                                 if ( src->kind != TypeData::Unknown ) {
                                         assert( src->kind == TypeData::Basic );
-
-                                        if ( dst->basictype == DeclarationNode::NoBasicType ) {
-                                                dst->basictype = src->basictype;
-                                        } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                                throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::basicTypeName[ src->basictype ] + " in type: ", src );
-
-                                        if ( dst->complextype == DeclarationNode::NoComplexType ) {
-                                                dst->complextype = src->complextype;
-                                        } else if ( src->complextype != DeclarationNode::NoComplexType )
-                                                throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::complexTypeName[ src->complextype ] + " in type: ", src );
-
-                                        if ( dst->signedness == DeclarationNode::NoSignedness ) {
-                                                dst->signedness = src->signedness;
-                                        } else if ( src->signedness != DeclarationNode::NoSignedness )
-                                                throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::signednessName[ src->signedness ] + " in type: ", src );
-
-                                        if ( dst->length == DeclarationNode::NoLength ) {
-                                                dst->length = src->length;
-                                        } else if ( dst->length == DeclarationNode::Long && src->length == DeclarationNode::Long ) {
-                                                dst->length = DeclarationNode::LongLong;
-                                        } else if ( src->length != DeclarationNode::NoLength )
-                                                throw SemanticError( std::string( "conflicting type specifier " ) + DeclarationNode::lengthName[ src->length ] + " in type: ", src );
+                                        dst->basic.modifiers.splice( dst->basic.modifiers.end(), src->basic.modifiers );
+                                        dst->basic.typeSpec.splice( dst->basic.typeSpec.end(), src->basic.typeSpec );
                                 } // if
                                 break;
@@ -911 +875 @@
         while ( cur ) {
                 try {
+///       if ( DeclarationNode *extr = cur->extractAggregate() ) {
+///     // handle the case where a structure declaration is contained within an object or type
+///     // declaration
+///     Declaration *decl = extr->build();
+///     if ( decl ) {
+///          *out++ = decl;
+///     }
+///       }
                         Declaration *decl = cur->build();
                         if ( decl ) {