Changes in / [d3a49864:cb98d9d]

Location:

src/Parser

Files:

• DeclarationNode.cc (modified) (9 diffs)
• DeclarationNode.h (modified) (2 diffs)
• ParseNode.h (modified) (1 diff)
• TypeData.cc (modified) (5 diffs)
• parser.yy (modified) (1 diff)

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 );
@@ -228 +225 @@
 } // DeclarationNode::newEnumValueGeneric
 
-DeclarationNode * DeclarationNode::newEnumInLine( const string name ) {
-        DeclarationNode * newnode = newName( new std::string(name) );
+DeclarationNode * DeclarationNode::newEnumInLine( const std::string * name ) {
+        DeclarationNode * newnode = newName( name );
         newnode->enumInLine = true;
         return newnode;
@@ -460 +457 @@
                 SemanticWarning( yylloc, Warning::BadQualifiersZeroOne, TypeData::builtinTypeNames[builtin] );
         } // if
-        type = ::addQualifiers( q->type, type );
+        type = ::addQualifiers( type, q->type );
         q->type = nullptr;
 
@@ -473 +470 @@
         copySpecifiers( o, copyattr );
         if ( o->type ) {
-                type = ::addType( o->type, type, o->attributes );
+                type = ::addType( type, o->type, o->attributes );
                 o->type = nullptr;
         } // if
@@ -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

@@ -30 +30 @@
         static DeclarationNode * newEnumConstant( const std::string * name, ExpressionNode * constant );
         static DeclarationNode * newEnumValueGeneric( const std::string * name, InitializerNode * init );
-        static DeclarationNode * newEnumInLine( const std::string name );
+        static DeclarationNode * newEnumInLine( const std::string * name );
         static DeclarationNode * newName( const std::string * );
         static DeclarationNode * newTypeParam( ast::TypeDecl::Kind, const std::string * );
@@ -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;
@@ -564 +576 @@
 
 // Takes ownership of all arguments, gives ownership of return value.
-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 );
+TypeData * addQualifiers( TypeData * dst, TypeData * src ) {
+        if ( src->forall ) {
+                if ( dst->forall || TypeData::Aggregate != dst->kind ) {
+                        extend( dst->forall, src->forall );
                 } else {
-                        rtype->aggregate.params = ltype->forall;
+                        extend( dst->aggregate.params, src->forall );
                 }
-                ltype->forall = nullptr;
+                src->forall = nullptr;
         }
 
-        addQualifiersToType( rtype, ltype );
-        return rtype;
+        addQualifiersToType( dst, src );
+        return dst;
 }
 
@@ -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
 }
 
 // Takes ownership of all arguments, gives ownership of return value.
-TypeData * addType( TypeData * ltype, TypeData * rtype, std::vector<ast::ptr<ast::Attribute>> & attributes ) {
-        if ( rtype ) {
-                addTypeToType( rtype, ltype );
-                return rtype;
+TypeData * addType( TypeData * dst, TypeData * src, std::vector<ast::ptr<ast::Attribute>> & attributes ) {
+        if ( dst ) {
+                addTypeToType( dst, src );
+        } else if ( src->kind == TypeData::Aggregate ) {
+                // Hide type information aggregate instances.
+                dst = makeInstance( src );
+                dst->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;
+                dst = src;
         } // if
-}
-
-TypeData * addType( TypeData * ltype, TypeData * rtype ) {
+        return dst;
+}
+
+TypeData * addType( TypeData * dst, TypeData * src ) {
         std::vector<ast::ptr<ast::Attribute>> attributes;
-        return addType( ltype, rtype, attributes );
+        return addType( dst, src, attributes );
 }
 
@@ -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;
 }
 

src/Parser/parser.yy

@@ -2815 +2815 @@
                 { $$ = DeclarationNode::newEnumValueGeneric( $2, $3 ); }
         | INLINE type_name
-                { $$ = DeclarationNode::newEnumInLine( *$2->symbolic.name ); }
+                {
+                        $$ = DeclarationNode::newEnumInLine( $2->symbolic.name );
+                        $2->symbolic.name = nullptr;
+                        delete $2;
+                }
         | enumerator_list ',' visible_hide_opt identifier_or_type_name enumerator_value_opt
                 { $$ = $1->set_last( DeclarationNode::newEnumValueGeneric( $4, $5 ) ); }