Changes in src/Virtual/ExpandCasts.cc [b91bfde:6dba8755]

File:

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

src/Virtual/ExpandCasts.cc

@@ -32 +32 @@
 namespace Virtual {
 
-static bool is_prefix( const std::string & prefix, const std::string& entire ) {
-        size_t const p_size = prefix.size();
-        return (p_size < entire.size() && prefix == entire.substr(0, p_size));
-}
-
-static bool is_type_id_object( const ObjectDecl * objectDecl ) {
-        const std::string & objectName = objectDecl->name;
-        return is_prefix( "__cfatid_", objectName );
-}
-
         // Indented until the new ast code gets added.
 
@@ -76 +66 @@
         };
 
+        /* Currently virtual depends on the rather brittle name matching between
+         * a (strict/explicate) virtual type, its vtable type and the vtable
+         * instance.
+         * A stronger implementation, would probably keep track of those triads
+         * and use that information to create better error messages.
+         */
+
+        namespace {
+
+        std::string get_vtable_name( std::string const & name ) {
+                return name + "_vtable";
+        }
+
+        std::string get_vtable_inst_name( std::string const & name ) {
+                return std::string("_") + get_vtable_name( name ) + "_instance";
+        }
+
+        std::string get_vtable_name_root( std::string const & name ) {
+                return name.substr(0, name.size() - 7 );
+        }
+
+        std::string get_vtable_inst_name_root( std::string const & name ) {
+                return get_vtable_name_root( name.substr(1, name.size() - 10 ) );
+        }
+
+        bool is_vtable_inst_name( std::string const & name ) {
+                return 17 < name.size() &&
+                        name == get_vtable_inst_name( get_vtable_inst_name_root( name ) );
+        }
+
+        } // namespace
+
         class VirtualCastCore {
-                CastExpr * cast_to_type_id( Expression * expr, int level_of_indirection ) {
+                Type * pointer_to_pvt(int level_of_indirection) {
                         Type * type = new StructInstType(
                                 Type::Qualifiers( Type::Const ), pvt_decl );
@@ -83 +105 @@
                                 type = new PointerType( noQualifiers, type );
                         }
-                        return new CastExpr( expr, type );
+                        return type;
                 }
 
@@ -119 +141 @@
 
         void VirtualCastCore::premutate( ObjectDecl * objectDecl ) {
-                if ( is_type_id_object( objectDecl ) ) {
-                        // Multiple definitions should be fine because of linkonce.
-                        indexer.insert( objectDecl );
+                if ( is_vtable_inst_name( objectDecl->get_name() ) ) {
+                        if ( ObjectDecl * existing = indexer.insert( objectDecl ) ) {
+                                std::string msg = "Repeated instance of virtual table, original found at: ";
+                                msg += existing->location.filename;
+                                msg += ":" + toString( existing->location.first_line );
+                                SemanticError( objectDecl->location, msg );
+                        }
                 }
         }
@@ -144 +170 @@
         }
 
-        /// Get the base type from a pointer or reference.
-        const Type * getBaseType( const Type * type ) {
-                if ( auto target = dynamic_cast<const PointerType *>( type ) ) {
-                        return target->base;
-                } else if ( auto target = dynamic_cast<const ReferenceType *>( type ) ) {
-                        return target->base;
+        /// Get the virtual table type used in a virtual cast.
+        Type * getVirtualTableType( const VirtualCastExpr * castExpr ) {
+                const Type * objectType;
+                if ( auto target = dynamic_cast<const PointerType *>( castExpr->result ) ) {
+                        objectType = target->base;
+                } else if ( auto target = dynamic_cast<const ReferenceType *>( castExpr->result ) ) {
+                        objectType = target->base;
                 } else {
-                        return nullptr;
-                }
-        }
-
-        /* Attempt to follow the "head" field of the structure to get the...
-         * Returns nullptr on error, otherwise owner must free returned node.
-         */
-        StructInstType * followHeadPointerType(
-                        const StructInstType * oldType,
-                        const std::string& fieldName,
-                        const CodeLocation& errorLocation ) {
-
-                // First section of the function is all about trying to fill this variable in.
-                StructInstType * newType = nullptr;
-                {
-                        const StructDecl * oldDecl = oldType->baseStruct;
-                        assert( oldDecl );
-
-                        // Helper function for throwing semantic errors.
-                        auto throwError = [&fieldName, &errorLocation, &oldDecl](const std::string& message) {
-                                const std::string& context = "While following head pointer of " +
-                                        oldDecl->name + " named '" + fieldName + "': ";
-                                SemanticError( errorLocation, context + message );
-                        };
-
-                        if ( oldDecl->members.empty() ) {
-                                throwError( "Type has no fields." );
-                        }
-                        const Declaration * memberDecl = oldDecl->members.front();
+                        castError( castExpr, "Virtual cast type must be a pointer or reference type." );
+                }
+                assert( objectType );
+
+                const StructInstType * structType = dynamic_cast<const StructInstType *>( objectType );
+                if ( nullptr == structType ) {
+                        castError( castExpr, "Virtual cast type must refer to a structure type." );
+                }
+                const StructDecl * structDecl = structType->baseStruct;
+                assert( structDecl );
+
+                const ObjectDecl * fieldDecl = nullptr;
+                if ( 0 < structDecl->members.size() ) {
+                        const Declaration * memberDecl = structDecl->members.front();
                         assert( memberDecl );
-                        const ObjectDecl * fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
-                        assert( fieldDecl );
-                        if ( fieldName != fieldDecl->name ) {
-                                throwError( "Head field did not have expected name." );
-                        }
-
-                        const Type * fieldType = fieldDecl->type;
-                        if ( nullptr == fieldType ) {
-                                throwError( "Could not get head field." );
-                        }
-                        const PointerType * ptrType = dynamic_cast<const PointerType *>( fieldType );
-                        if ( nullptr == ptrType ) {
-                                throwError( "First field is not a pointer type." );
-                        }
-                        assert( ptrType->base );
-                        newType = dynamic_cast<StructInstType *>( ptrType->base );
-                        if ( nullptr == newType ) {
-                                throwError( "First field does not point to a structure type." );
-                        }
-                }
-
-                // Now we can look into copying it.
-                newType = newType->clone();
-                if ( ! oldType->parameters.empty() ) {
-                        deleteAll( newType->parameters );
-                        newType->parameters.clear();
-                        cloneAll( oldType->parameters, newType->parameters );
-                }
-                return newType;
-        }
-
-        /// Get the type-id type from a virtual type.
-        StructInstType * getTypeIdType( const Type * type, const CodeLocation& errorLocation ) {
-                const StructInstType * typeInst = dynamic_cast<const StructInstType *>( type );
-                if ( nullptr == typeInst ) {
-                        return nullptr;
-                }
-                StructInstType * tableInst =
-                        followHeadPointerType( typeInst, "virtual_table", errorLocation );
-                if ( nullptr == tableInst ) {
-                        return nullptr;
-                }
-                StructInstType * typeIdInst =
-                        followHeadPointerType( tableInst, "__cfavir_typeid", errorLocation );
-                delete tableInst;
-                return typeIdInst;
+                        fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
+                        if ( fieldDecl && fieldDecl->name != "virtual_table" ) {
+                                fieldDecl = nullptr;
+                        }
+                }
+                if ( nullptr == fieldDecl ) {
+                        castError( castExpr, "Virtual cast type must have a leading virtual_table field." );
+                }
+                const PointerType * fieldType = dynamic_cast<const PointerType *>( fieldDecl->type );
+                if ( nullptr == fieldType ) {
+                        castError( castExpr, "Virtual cast type virtual_table field is not a pointer." );
+                }
+                assert( fieldType->base );
+                auto virtualStructType = dynamic_cast<const StructInstType *>( fieldType->base );
+                assert( virtualStructType );
+
+                // Here is the type, but if it is polymorphic it will have lost information.
+                // (Always a clone so that it may always be deleted.)
+                StructInstType * virtualType = virtualStructType->clone();
+                if ( ! structType->parameters.empty() ) {
+                        deleteAll( virtualType->parameters );
+                        virtualType->parameters.clear();
+                        cloneAll( structType->parameters, virtualType->parameters );
+                }
+                return virtualType;
         }
 
@@ -237 +228 @@
                 assert( pvt_decl );
 
-                const Type * base_type = getBaseType( castExpr->result );
-                if ( nullptr == base_type ) {
-                        castError( castExpr, "Virtual cast target must be a pointer or reference type." );
-                }
-                const Type * type_id_type = getTypeIdType( base_type, castLocation( castExpr ) );
-                if ( nullptr == type_id_type ) {
-                        castError( castExpr, "Ill formed virtual cast target type." );
-                }
-                ObjectDecl * type_id = indexer.lookup( type_id_type );
-                delete type_id_type;
-                if ( nullptr == type_id ) {
-                        castError( castExpr, "Virtual cast does not target a virtual type." );
+                const Type * vtable_type = getVirtualTableType( castExpr );
+                ObjectDecl * table = indexer.lookup( vtable_type );
+                if ( nullptr == table ) {
+                        SemanticError( castLocation( castExpr ),
+                                "Could not find virtual table instance." );
                 }
 
                 Expression * result = new CastExpr(
                         new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
-                                cast_to_type_id( new AddressExpr( new VariableExpr( type_id ) ), 1 ),
-                                cast_to_type_id( castExpr->get_arg(), 2 ),
+                                        new CastExpr(
+                                                new AddressExpr( new VariableExpr( table ) ),
+                                                pointer_to_pvt(1)
+                                        ),
+                                        new CastExpr(
+                                                castExpr->get_arg(),
+                                                pointer_to_pvt(2)
+                                        )
                         } ),
                         castExpr->get_result()->clone()
@@ -262 +252 @@
                 castExpr->set_result( nullptr );
                 delete castExpr;
+                delete vtable_type;
                 return result;
         }