Changes in src/Virtual/Tables.cc [c6b4432:4f6dda0]

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 {
@@ -60 +65 @@
         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
+        );
 }
 
@@ -79 +101 @@
 }
 
+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,
@@ -84 +111 @@
         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 );
 }
 
@@ -156 +224 @@
 }
 
+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,
@@ -183 +284 @@
 }
 
+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,
@@ -196 +309 @@
 }
 
+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
+        );
+}
+
 ast::ObjectDecl * makeTypeIdInstance(
                 CodeLocation const & location,