Changeset af60383 for src/Parser/TypeData.cc

Timestamp:

Mar 5, 2024, 10:17:17 AM (4 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

f6e8c67

Parents:

44adf1b

Message:

Moved a field and functions from DeclarationNode? to TypeData?. Trying to make the line between them cleaner.

File:

• src/Parser/TypeData.cc (modified) (1 diff)

src/Parser/TypeData.cc

@@ -476 +476 @@
         } // switch
         assert(false);
+}
+
+
+TypeData * TypeData::getLastBase() {
+        TypeData * cur = this;
+        while ( cur->base ) cur = cur->base;
+        return cur;
+}
+
+void TypeData::setLastBase( TypeData * newBase ) {
+        getLastBase()->base = newBase;
+}
+
+// Takes ownership of src.
+static void addQualifiersToType( TypeData * dst, TypeData * src ) {
+        if ( dst->base ) {
+                addQualifiersToType( dst->base, src );
+        } else if ( dst->kind == TypeData::Function ) {
+                dst->base = src;
+                src = nullptr;
+    } else {
+                dst->qualifiers |= src->qualifiers;
+                delete src;
+        } // if
+}
+
+// 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 );
+                } else {
+                        rtype->aggregate.params = ltype->forall;
+                }
+                ltype->forall = nullptr;
+        }
+
+        addQualifiersToType( rtype, ltype );
+        return rtype;
+}
+
+// Helper for addType and cloneBaseType.
+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
+                src->forall = nullptr;
+        } // if
+        if ( dst->base ) {
+                addTypeToType( dst->base, src );
+                return;
+        }
+        switch ( dst->kind ) {
+        case TypeData::Unknown:
+                src->qualifiers |= dst->qualifiers;
+                // LEAKS dst?
+                dst = src;
+                src = nullptr;
+                break;
+        case TypeData::Basic:
+                dst->qualifiers |= src->qualifiers;
+                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 ) {
+                                SemanticError( yylloc, "multiple declaration types \"%s\" and \"%s\".",
+                                        DeclarationNode::basicTypeNames[ dst->basictype ],
+                                        DeclarationNode::basicTypeNames[ src->basictype ] );
+                        }
+                        if ( dst->complextype == DeclarationNode::NoComplexType ) {
+                                dst->complextype = src->complextype;
+                        } else if ( src->complextype != DeclarationNode::NoComplexType ) {
+                                SemanticError( yylloc, "multiple declaration types \"%s\" and \"%s\".",
+                                        DeclarationNode::complexTypeNames[ src->complextype ],
+                                        DeclarationNode::complexTypeNames[ src->complextype ] );
+                        }
+                        if ( dst->signedness == DeclarationNode::NoSignedness ) {
+                                dst->signedness = src->signedness;
+                        } else if ( src->signedness != DeclarationNode::NoSignedness ) {
+                                SemanticError( yylloc, "conflicting type specifier \"%s\" and \"%s\".",
+                                        DeclarationNode::signednessNames[ dst->signedness ],
+                                        DeclarationNode::signednessNames[ src->signedness ] );
+                        }
+                        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 ) {
+                                SemanticError( yylloc, "conflicting type specifier \"%s\" and \"%s\".",
+                                        DeclarationNode::lengthNames[ dst->length ],
+                                        DeclarationNode::lengthNames[ src->length ] );
+                        }
+                } // if
+                break;
+        default:
+                switch ( src->kind ) {
+                case TypeData::Aggregate:
+                case TypeData::Enum:
+                        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
+                        src->forall = nullptr;
+                        dst->base = src;
+                        src = nullptr;
+                } // switch
+        } // 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;
+        } else {
+                if ( ltype->kind == TypeData::Aggregate || ltype->kind == TypeData::Enum ) {
+                        // Hide type information aggregate instances.
+                        rtype = new TypeData( TypeData::AggregateInst );
+                        rtype->aggInst.aggregate = ltype;
+                        rtype->aggInst.aggregate->aggregate.attributes.swap( attributes ); // change ownership
+                        if ( ltype->kind == TypeData::Aggregate ) {
+                                rtype->aggInst.hoistType = ltype->aggregate.body;
+                                rtype->aggInst.params = maybeCopy( ltype->aggregate.actuals );
+                        } else {
+                                rtype->aggInst.hoistType = ltype->enumeration.body;
+                        } // if
+                        rtype->qualifiers |= ltype->qualifiers;
+                } else {
+                        rtype = ltype;
+                } // if
+                return rtype;
+        } // if
+}
+
+// Takes ownership of both arguments, gives ownership of return value.
+TypeData * cloneBaseType( TypeData * type, TypeData * other ) {
+        TypeData * newType = type->getLastBase()->clone();
+        if ( newType->kind == TypeData::AggregateInst ) {
+                // don't duplicate members
+                if ( newType->aggInst.aggregate->kind == TypeData::Enum ) {
+                        delete newType->aggInst.aggregate->enumeration.constants;
+                        newType->aggInst.aggregate->enumeration.constants = nullptr;
+                        newType->aggInst.aggregate->enumeration.body = false;
+                } else {
+                        assert( newType->aggInst.aggregate->kind == TypeData::Aggregate );
+                        delete newType->aggInst.aggregate->aggregate.fields;
+                        newType->aggInst.aggregate->aggregate.fields = nullptr;
+                        newType->aggInst.aggregate->aggregate.body = false;
+                } // if
+                // don't hoist twice
+                newType->aggInst.hoistType = false;
+        } // if
+        newType->forall = maybeCopy( type->forall );
+
+        if ( other ) {
+                addTypeToType( other, newType );
+                delete newType;
+                return other;
+        } // if
+        return newType;
+}
+
+TypeData * makeNewBase( TypeData * type ) {
+        switch ( type->kind ) {
+        case TypeData::Aggregate:
+        case TypeData::Enum: {
+                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
 }