Changeset c6b4432 for src/Virtual/Tables.cc

Timestamp:

Nov 8, 2023, 2:01:11 PM (6 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

3e4bf0d, f5ec35a

Parents:

790d835

Message:

Remove BaseSyntaxNode? and clean-up.

File:

• src/Virtual/Tables.cc (modified) (7 diffs)

src/Virtual/Tables.cc

@@ -21 +21 @@
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
-#include <SynTree/Attribute.h>
-#include <SynTree/Declaration.h>
-#include <SynTree/Expression.h>
-#include <SynTree/Statement.h>
-#include <SynTree/Type.h>
 
 namespace Virtual {
@@ -65 +60 @@
         return 17 < name.size() && '_' == name[0] &&
                 std::string("_vtable_instance") == name.substr(1, name.size() - 17);
-}
-
-static ObjectDecl * makeVtableDeclaration(
-                std::string const & name,
-                StructInstType * type, Initializer * init ) {
-        Type::StorageClasses storage = noStorageClasses;
-        if ( nullptr == init ) {
-                storage.is_extern = true;
-        }
-        return new ObjectDecl(
-                name,
-                storage,
-                LinkageSpec::Cforall,
-                nullptr,
-                type,
-                init
-        );
 }
 
@@ -101 +79 @@
 }
 
-ObjectDecl * makeVtableForward( std::string const & name, StructInstType * type ) {
-        assert( type );
-        return makeVtableDeclaration( name, type, nullptr );
-}
-
 ast::ObjectDecl * makeVtableForward(
                 CodeLocation const & location, std::string const & name,
@@ -111 +84 @@
         assert( vtableType );
         return makeVtableDeclaration( location, name, vtableType, nullptr );
-}
-
-ObjectDecl * makeVtableInstance(
-                std::string const & name, StructInstType * vtableType,
-                Type * objectType, Initializer * init ) {
-        assert( vtableType );
-        assert( objectType );
-        StructDecl * vtableStruct = vtableType->baseStruct;
-        // Build the initialization
-        if ( nullptr == init ) {
-                std::list< Initializer * > inits;
-
-                // This is going to have to be run before the resolver to connect expressions.
-                for ( auto field : vtableStruct->members ) {
-                        if ( std::string( "parent" ) == field->name ) {
-                                // This will not work with polymorphic state.
-                                auto oField = strict_dynamic_cast< ObjectDecl * >( field );
-                                auto fieldType = strict_dynamic_cast< PointerType * >( oField->type );
-                                auto parentType = strict_dynamic_cast< StructInstType * >( fieldType->base );
-                                std::string const & parentInstance = instanceName( parentType->name );
-                                inits.push_back(
-                                                new SingleInit( new AddressExpr( new NameExpr( parentInstance ) ) ) );
-                        } else if ( std::string( "__cfavir_typeid" ) == field->name ) {
-                                std::string const & baseType = baseTypeName( vtableType->name );
-                                std::string const & typeId = typeIdName( baseType );
-                                inits.push_back( new SingleInit( new AddressExpr( new NameExpr( typeId ) ) ) );
-                        } else if ( std::string( "size" ) == field->name ) {
-                                inits.push_back( new SingleInit( new SizeofExpr( objectType->clone() ) ) );
-                        } else if ( std::string( "align" ) == field->name ) {
-                                inits.push_back( new SingleInit( new AlignofExpr( objectType->clone() ) ) );
-                        } else {
-                                inits.push_back( new SingleInit( new NameExpr( field->name ) ) );
-                        }
-                }
-                init = new ListInit( inits );
-        // This should initialize everything except the parent pointer, the
-        // size-of and align-of fields. These should be inserted.
-        } else {
-                assert(false);
-        }
-        return makeVtableDeclaration( name, vtableType, init );
 }
 
@@ -224 +156 @@
 }
 
-FunctionDecl * makeGetExceptionForward(
-                Type * vtableType, Type * exceptType ) {
-        assert( vtableType );
-        assert( exceptType );
-        FunctionType * type = new FunctionType( noQualifiers, false );
-        vtableType->tq.is_const = true;
-        type->returnVals.push_back( new ObjectDecl(
-                "_retvalue",
-                noStorageClasses,
-                LinkageSpec::Cforall,
-                nullptr,
-                new ReferenceType( noQualifiers, vtableType ),
-                nullptr,
-                { new Attribute("unused") }
-        ) );
-        type->parameters.push_back( new ObjectDecl(
-                "__unused",
-                noStorageClasses,
-                LinkageSpec::Cforall,
-                nullptr,
-                new PointerType( noQualifiers, exceptType ),
-                nullptr,
-                { new Attribute("unused") }
-        ) );
-        return new FunctionDecl(
-                functionName,
-                noStorageClasses,
-                LinkageSpec::Cforall,
-                type,
-                nullptr
-        );
-}
-
 ast::FunctionDecl * makeGetExceptionForward(
                 CodeLocation const & location,
@@ -284 +183 @@
 }
 
-FunctionDecl * makeGetExceptionFunction(
-                ObjectDecl * vtableInstance, Type * exceptType ) {
-        assert( vtableInstance );
-        assert( exceptType );
-        FunctionDecl * func = makeGetExceptionForward(
-                vtableInstance->type->clone(), exceptType );
-        func->statements = new CompoundStmt( {
-                new ReturnStmt( new VariableExpr( vtableInstance ) ),
-        } );
-        return func;
-}
-
 ast::FunctionDecl * makeGetExceptionFunction(
                 CodeLocation const & location,
@@ -307 +194 @@
         } );
         return func;
-}
-
-ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType ) {
-        assert( typeIdType );
-        StructInstType * type = typeIdType->clone();
-        type->tq.is_const = true;
-        std::string const & typeid_name = typeIdTypeToInstance( typeIdType->name );
-        return new ObjectDecl(
-                typeid_name,
-                noStorageClasses,
-                LinkageSpec::Cforall,
-                /* bitfieldWidth */ nullptr,
-                type,
-                new ListInit( { new SingleInit(
-                        new AddressExpr( new NameExpr( "__cfatid_exception_t" ) )
-                        ) } ),
-                { new Attribute( "cfa_linkonce", {} ) },
-                noFuncSpecifiers
-        );
 }