Changes in src/Virtual/Tables.cc [69c5c00:1c01c58]

File:

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

src/Virtual/Tables.cc

@@ -14 +14 @@
 //
 
-#include <SynTree/Attribute.h>
 #include <SynTree/Declaration.h>
 #include <SynTree/Expression.h>
-#include <SynTree/Statement.h>
 #include <SynTree/Type.h>
 
@@ -40 +38 @@
 }
 
+// Fuse base polymorphic declaration and forall arguments into a new type.
+static StructInstType * vtableInstType(
+                StructDecl * polyDecl, std::list< Expression * > && parameters ) {
+        assert( parameters.size() == polyDecl->parameters.size() );
+        StructInstType * type = new StructInstType(
+                        Type::Qualifiers( /* Type::Const */ ), polyDecl );
+        type->parameters = std::move( parameters );
+        return type;
+}
+
 static ObjectDecl * makeVtableDeclaration(
                 StructInstType * type, Initializer * init ) {
@@ -58 +66 @@
 
 ObjectDecl * makeVtableForward( StructInstType * type ) {
-        assert( type );
         return makeVtableDeclaration( type, nullptr );
 }
 
+ObjectDecl * makeVtableForward(
+                StructDecl * polyDecl, std::list< Expression * > && parameters ) {
+        return makeVtableForward( vtableInstType( polyDecl, std::move( parameters ) ) );
+}
+
 ObjectDecl * makeVtableInstance(
-                StructInstType * vtableType, Type * objectType, Initializer * init ) {
-        assert( vtableType );
-        assert( objectType );
+                StructInstType * vtableType, Type * vobject_type, Initializer * init ) {
         StructDecl * vtableStruct = vtableType->baseStruct;
         // Build the initialization
@@ -82 +92 @@
                                                 new SingleInit( new AddressExpr( new NameExpr( parentInstance ) ) ) );
                         } else if ( std::string( "size" ) == field->name ) {
-                                inits.push_back( new SingleInit( new SizeofExpr( objectType->clone() ) ) );
+                                inits.push_back( new SingleInit( new SizeofExpr( vobject_type->clone() ) ) );
                         } else if ( std::string( "align" ) == field->name ) {
-                                inits.push_back( new SingleInit( new AlignofExpr( objectType->clone() ) ) );
+                                inits.push_back( new SingleInit( new AlignofExpr( vobject_type->clone() ) ) );
                         } else {
                                 inits.push_back( new SingleInit( new NameExpr( field->name ) ) );
@@ -98 +108 @@
 }
 
-namespace {
-        std::string const functionName = "get_exception_vtable";
-}
-
-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
-        );
-}
-
-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;
+ObjectDecl * makeVtableInstance(
+                StructDecl * polyDecl, std::list< Expression * > && parameters,
+                Type * vobject, Initializer * init ) {
+        return makeVtableInstance(
+                vtableInstType( polyDecl, std::move( parameters ) ), vobject, init );
 }