Changeset 5b639ee for src/Parser/DeclarationNode.cc

Timestamp:

Sep 12, 2016, 9:52:12 PM (8 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

101e0bd

Parents:

b6424d9

Message:

more refactoring of parser code

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 : Sun Sep 11 09:24:11 2016
-// Update Count     : 438
+// Last Modified On : Mon Sep 12 21:03:18 2016
+// Update Count     : 491
 //
 
@@ -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" };
-const char *DeclarationNode::basicTypeName[] = { "char", "int", "float", "double", "void", "_Bool", "_Complex", "_Imaginary",  };
-const char *DeclarationNode::modifierName[]  = { "signed", "unsigned", "short", "long" };
+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::aggregateName[] = { "struct", "union", "context" };
-const char *DeclarationNode::typeClassName[] = { "type", "dtype", "ftype" };
+const char *DeclarationNode::typeClassName[] = { "otype", "dtype", "ftype" };
 const char *DeclarationNode::builtinTypeName[] = { "__builtin_va_list" };
 
@@ -53 +55 @@
                 linkage( ::linkage ),
                 extension( false ) {
-        variable.tyClass = DeclarationNode::Type;
+        variable.tyClass = DeclarationNode::Otype;
         variable.assertions = nullptr;
 
@@ -188 +190 @@
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->basic.typeSpec.push_back( bt );
+        newnode->type->basictype = bt;
         return newnode;
 } // DeclarationNode::newBasicType
 
-DeclarationNode * DeclarationNode::newModifier( Modifier mod ) {
+DeclarationNode * DeclarationNode::newComplexType( ComplexType ct ) {
         DeclarationNode *newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Basic );
-        newnode->type->basic.modifiers.push_back( mod );
-        return newnode;
-} // DeclarationNode::newModifier
+        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
 
 DeclarationNode * DeclarationNode::newFromTypedef( std::string *name ) {
@@ -388 +404 @@
 }
 
+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 < NoOfQualifier; i += 1 ) {  // find common qualifiers
-                        if ( qsrc[i] & qdst[i] ) {
-                                if ( ! error.empty() ) error += ", ";   // separator
-                                error += string( "duplicate " ) + DeclarationNode::qualifierName[i];
+                for ( int i = 0; i < NoQualifier; i += 1 ) {    // find common qualifiers
+                        if ( qsrc[i] && qdst[i] ) {
+                                appendError( error, string( "duplicate " ) + DeclarationNode::qualifierName[i] );
                         } // if
                 } // for
@@ -403 +424 @@
 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 ];
+                        appendError( 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
+                        appendError( error, string( "conflicting " ) + storageName[ storageClass ] + " & " + storageName[ q->storageClass ] );
+                        q->storageClass = storageClass;                         // FIX ERROR, prevent assertions from triggering
+                } // if
+        } // if
+        appendError( error, q->error );
 } // 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 ) {
@@ -483 +499 @@
                                 if ( src->kind != TypeData::Unknown ) {
                                         assert( src->kind == TypeData::Basic );
-                                        dst->basic.modifiers.splice( dst->basic.modifiers.end(), src->basic.modifiers );
-                                        dst->basic.typeSpec.splice( dst->basic.typeSpec.end(), src->basic.typeSpec );
+
+                                        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 );
                                 } // if
                                 break;
@@ -875 +911 @@
         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 ) {