Changeset 4a72fef

Timestamp:

Apr 4, 2024, 11:33:08 AM (4 weeks ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

1cfe640

Parents:

2d82999

Message:

General clean-up in the parser. Removed the commented DeclarationNode::name and added some helper functions to remove duplicate code.

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (6 diffs)
• DeclarationNode.h (modified) (1 diff)
• ParseNode.h (modified) (1 diff)
• TypeData.cc (modified) (6 diffs)

src/Parser/DeclarationNode.cc

@@ -53 +53 @@
         linkage( ::linkage ) {
 
-//      variable.name = nullptr;
         variable.tyClass = ast::TypeDecl::NUMBER_OF_KINDS;
         variable.assertions = nullptr;
@@ -65 +64 @@
         delete name;
 
-//      delete variable.name;
         delete variable.assertions;
         delete variable.initializer;
 
-//      delete type;
+        delete type;
         delete bitfieldWidth;
 
@@ -100 +98 @@
         newnode->error = error;
 
-//      newnode->variable.name = variable.name ? new string( *variable.name ) : nullptr;
         newnode->variable.tyClass = variable.tyClass;
         newnode->variable.assertions = maybeCopy( variable.assertions );
@@ -584 +581 @@
 DeclarationNode * DeclarationNode::addAssertions( DeclarationNode * assertions ) {
         if ( variable.tyClass != ast::TypeDecl::NUMBER_OF_KINDS ) {
-                if ( variable.assertions ) {
-                        variable.assertions->set_last( assertions );
-                } else {
-                        variable.assertions = assertions;
-                } // if
+                extend( variable.assertions, assertions );
                 return this;
         } // if
 
         assert( type );
-        switch ( type->kind ) {
-        case TypeData::Symbolic:
-                if ( type->symbolic.assertions ) {
-                        type->symbolic.assertions->set_last( assertions );
-                } else {
-                        type->symbolic.assertions = assertions;
-                } // if
-                break;
-        default:
-                assert( false );
-        } // switch
+        assert( TypeData::Symbolic == type->kind );
+        extend( type->symbolic.assertions, assertions );
 
         return this;
@@ -688 +672 @@
 
 DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) {
-        if ( p ) {
-                assert( p->type->kind == TypeData::Pointer || p->type->kind == TypeData::Reference );
-                if ( type ) {
-                        p->type->base = makeNewBase( type );
-                        type = nullptr;
-                } // if
-                delete this;
-                return p;
-        } else {
-                return this;
-        } // if
+        if ( !p ) return this;
+        assert( p->type->kind == TypeData::Pointer || p->type->kind == TypeData::Reference );
+        if ( type ) {
+                p->type->base = makeNewBase( type );
+                type = nullptr;
+        } // if
+        delete this;
+        return p;
 }
 
 DeclarationNode * DeclarationNode::addNewArray( DeclarationNode * a ) {
-        if ( ! a ) return this;
+        if ( !a ) return this;
         assert( a->type->kind == TypeData::Array );
         if ( type ) {
@@ -774 +755 @@
                         if ( ret->kind == TypeData::Aggregate ) {
                                 newnode->attributes.swap( ret->aggregate.attributes );
-                        } // if 
+                        } // if
                         return newnode;
                 } // if

src/Parser/DeclarationNode.h

@@ -99 +99 @@
 
         struct Variable_t {
-//              const std::string * name;
                 ast::TypeDecl::Kind tyClass;
                 DeclarationNode * assertions;

src/Parser/ParseNode.h

@@ -82 +82 @@
 };
 
+template<typename Node>
+void extend( Node *& list, Node * value ) {
+        if ( list ) {
+                extend( list->next, value );
+        } else {
+                list = value;
+        }
+}
+
 // Must harmonize with OperName.
 enum class OperKinds {

src/Parser/TypeData.cc

@@ -475 +475 @@
 
 
+// Wrap an aggregate up in an instance. Takes and gives ownership.
+static TypeData * makeInstance( TypeData * type ) {
+        assert( TypeData::Aggregate == type->kind );
+        TypeData * out = new TypeData( TypeData::AggregateInst );
+        out->aggInst.aggregate = type;
+        out->aggInst.params = maybeCopy( type->aggregate.actuals );
+        out->aggInst.hoistType = type->aggregate.body;
+        out->qualifiers |= type->qualifiers;
+        return out;
+}
+
+
 TypeData * build_type_qualifier( ast::CV::Qualifiers tq ) {
         TypeData * type = new TypeData;
@@ -566 +578 @@
 TypeData * addQualifiers( TypeData * ltype, TypeData * rtype ) {
         if ( ltype->forall ) {
-                if ( rtype->forall ) {
-                        rtype->forall->set_last( ltype->forall );
-                } else if ( TypeData::Aggregate != rtype->kind ) {
-                        rtype->forall = ltype->forall;
-                } else if ( rtype->aggregate.params ) {
-                        rtype->aggregate.params->set_last( ltype->forall );
+                if ( rtype->forall || TypeData::Aggregate != rtype->kind ) {
+                        extend( rtype->forall, ltype->forall );
                 } else {
-                        rtype->aggregate.params = ltype->forall;
+                        extend( rtype->aggregate.params, ltype->forall );
                 }
                 ltype->forall = nullptr;
@@ -585 +593 @@
 static void addTypeToType( TypeData *& dst, TypeData *& src ) {
         if ( src->forall && dst->kind == TypeData::Function ) {
-                if ( dst->forall ) {
-                        dst->forall->set_last( src->forall );
-                } else {
-                        dst->forall = src->forall;
-                } // if
+                extend( dst->forall, src->forall );
                 src->forall = nullptr;
         } // if
@@ -641 +645 @@
                 break;
         default:
-                switch ( src->kind ) {
-                case TypeData::Aggregate:
-                        dst->base = new TypeData( TypeData::AggregateInst );
-                        dst->base->aggInst.aggregate = src;
-                        if ( src->kind == TypeData::Aggregate ) {
-                                dst->base->aggInst.params = maybeCopy( src->aggregate.actuals );
-                        } // if
-                        dst->base->qualifiers |= src->qualifiers;
-                        src = nullptr;
-                        break;
-                default:
-                        if ( dst->forall ) {
-                                dst->forall->set_last( src->forall );
-                        } else {
-                                dst->forall = src->forall;
-                        } // if
+                if ( TypeData::Aggregate == src->kind ) {
+                        dst->base = makeInstance( src );
+                } else {
+                        extend( dst->forall, src->forall );
                         src->forall = nullptr;
                         dst->base = src;
-                        src = nullptr;
-                } // switch
+                }
+                src = nullptr;
         } // switch
 }
@@ -668 +660 @@
         if ( rtype ) {
                 addTypeToType( rtype, ltype );
-                return rtype;
+        } else if ( ltype->kind == TypeData::Aggregate ) {
+                // Hide type information aggregate instances.
+                rtype = makeInstance( ltype );
+                rtype->aggInst.aggregate->aggregate.attributes.swap( attributes );
         } else {
-                if ( ltype->kind == TypeData::Aggregate ) {
-                        // Hide type information aggregate instances.
-                        rtype = new TypeData( TypeData::AggregateInst );
-                        rtype->aggInst.aggregate = ltype;
-                        rtype->aggInst.aggregate->aggregate.attributes.swap( attributes ); // change ownership
-                        rtype->aggInst.hoistType = ltype->aggregate.body;
-                        rtype->aggInst.params = maybeCopy( ltype->aggregate.actuals );
-                        rtype->qualifiers |= ltype->qualifiers;
-                } else {
-                        rtype = ltype;
-                } // if
-                return rtype;
+                rtype = ltype;
         } // if
+        return rtype;
 }
 
@@ -713 +698 @@
 
 TypeData * makeNewBase( TypeData * type ) {
-        switch ( type->kind ) {
-        case TypeData::Aggregate: {
-                TypeData * out = new TypeData( TypeData::AggregateInst );
-                out->aggInst.aggregate = type;
-                if ( TypeData::Aggregate == type->kind ) {
-                        out->aggInst.params = maybeCopy( type->aggregate.actuals );
-                }
-                out->qualifiers |= type->qualifiers;
-                return out;
-        }
-        default:
-                return type;
-        } // switch
+        return ( TypeData::Aggregate == type->kind ) ? makeInstance( type ) : type;
 }