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

File:

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

src/Virtual/ExpandCasts.cc

@@ -10 +10 @@
 // Created On       : Mon Jul 24 13:59:00 2017
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Jul 31 10:29:00 2020
-// Update Count     : 4
+// Last Modified On : Tus Aug  2 14:59:00 2017
+// Update Count     : 1
 //
 
@@ -18 +18 @@
 #include <cassert>                 // for assert, assertf
 #include <iterator>                // for back_inserter, inserter
+#include <map>                     // for map, _Rb_tree_iterator, map<>::ite...
 #include <string>                  // for string, allocator, operator==, ope...
+#include <utility>                 // for pair
 
 #include "Common/PassVisitor.h"    // for PassVisitor
-#include "Common/ScopedMap.h"      // for ScopedMap
 #include "Common/SemanticError.h"  // for SemanticError
-#include "SymTab/Mangler.h"        // for mangleType
 #include "SynTree/Declaration.h"   // for ObjectDecl, StructDecl, FunctionDecl
 #include "SynTree/Expression.h"    // for VirtualCastExpr, CastExpr, Address...
@@ -32 +32 @@
 namespace Virtual {
 
-        // Indented until the new ast code gets added.
-
-        /// Maps virtual table types the instance for that type.
-        class VirtualTableMap final {
-                ScopedMap<std::string, ObjectDecl *> vtable_instances;
-        public:
-                void enterScope() {
-                        vtable_instances.beginScope();
-                }
-                void leaveScope() {
-                        vtable_instances.endScope();
-                }
-
-                ObjectDecl * insert( ObjectDecl * vtableDecl ) {
-                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableDecl->type );
-                        ObjectDecl *& value = vtable_instances[ mangledName ];
-                        if ( value ) {
-                                if ( vtableDecl->storageClasses.is_extern ) {
-                                        return nullptr;
-                                } else if ( ! value->storageClasses.is_extern ) {
-                                        return value;
-                                }
-                        }
-                        value = vtableDecl;
-                        return nullptr;
-                }
-
-                ObjectDecl * lookup( const Type * vtableType ) {
-                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableType );
-                        const auto it = vtable_instances.find( mangledName );
-                        return ( vtable_instances.end() == it ) ? nullptr : it->second;
-                }
-        };
-
         /* Currently virtual depends on the rather brittle name matching between
          * a (strict/explicate) virtual type, its vtable type and the vtable
@@ -72 +38 @@
          * and use that information to create better error messages.
          */
-
-        namespace {
 
         std::string get_vtable_name( std::string const & name ) {
@@ -91 +55 @@
         }
 
+        bool is_vtable_name( std::string const & name ) {
+                return (name.substr( name.size() - 7 ) == "_vtable" );
+        }
+
         bool is_vtable_inst_name( std::string const & name ) {
                 return 17 < name.size() &&
@@ -96 +64 @@
         }
 
-        } // namespace
+        class VirtualCastCore {
+        std::map<std::string, ObjectDecl *> vtable_instances;
+        FunctionDecl *vcast_decl;
+        StructDecl *pvt_decl;
 
-        class VirtualCastCore {
                 Type * pointer_to_pvt(int level_of_indirection) {
                         Type * type = new StructInstType(
@@ -110 +80 @@
         public:
                 VirtualCastCore() :
-                        indexer(), vcast_decl( nullptr ), pvt_decl( nullptr )
+                        vtable_instances(), vcast_decl( nullptr ), pvt_decl( nullptr )
                 {}
 
@@ -118 +88 @@
 
                 Expression * postmutate( VirtualCastExpr * castExpr );
-
-                VirtualTableMap indexer;
-        private:
-                FunctionDecl *vcast_decl;
-                StructDecl *pvt_decl;
         };
 
@@ -142 +107 @@
         void VirtualCastCore::premutate( ObjectDecl * 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 );
-                        }
+                        vtable_instances[objectDecl->get_name()] = objectDecl;
                 }
         }
 
-        namespace {
-
-        /// Better error locations for generated casts.
-        CodeLocation castLocation( const VirtualCastExpr * castExpr ) {
-                if ( castExpr->location.isSet() ) {
-                        return castExpr->location;
-                } else if ( castExpr->arg->location.isSet() ) {
-                        return castExpr->arg->location;
-                } else if ( castExpr->result->location.isSet() ) {
-                        return castExpr->result->location;
-                } else {
-                        return CodeLocation();
-                }
-        }
-
-        [[noreturn]] void castError( const VirtualCastExpr * castExpr, std::string const & message ) {
-                SemanticError( castLocation( castExpr ), message );
-        }
-
-        /// 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 {
-                        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 );
-                        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;
-        }
-
-        } // namespace
-
         Expression * VirtualCastCore::postmutate( VirtualCastExpr * castExpr ) {
-                assertf( castExpr->result, "Virtual Cast target not found before expansion." );
+                assertf( castExpr->get_result(), "Virtual Cast target not found before expansion." );
 
                 assert( vcast_decl );
                 assert( pvt_decl );
 
-                const Type * vtable_type = getVirtualTableType( castExpr );
-                ObjectDecl * table = indexer.lookup( vtable_type );
-                if ( nullptr == table ) {
-                        SemanticError( castLocation( castExpr ),
-                                "Could not find virtual table instance." );
+                // May only cast to a pointer or reference type.
+                // A earlier validation should give a syntax error, this is
+                // just to make sure errors don't creep during translation.
+                // Move to helper with more detailed error messages.
+                PointerType * target_type =
+                        dynamic_cast<PointerType *>( castExpr->get_result() );
+                assert( target_type );
+
+                StructInstType * target_struct =
+                        dynamic_cast<StructInstType *>( target_type->get_base() );
+                assert( target_struct );
+
+                StructDecl * target_decl = target_struct->get_baseStruct();
+
+                std::map<std::string, ObjectDecl *>::iterator found =
+                        vtable_instances.find(
+                                get_vtable_inst_name( target_decl->get_name() ) );
+                if ( vtable_instances.end() == found ) {
+                        assertf( false, "virtual table instance not found." );
                 }
+                ObjectDecl * table = found->second;
 
                 Expression * result = new CastExpr(
+                        //new ApplicationExpr(
+                                //new AddressExpr( new VariableExpr( vcast_decl ) ),
+                                //new CastExpr( new VariableExpr( vcast_decl ),
+                                //      new PointerType( noQualifiers,
+                                //              vcast_decl->get_type()->clone()
+                                //              )
+                                //      ),
                         new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
                                         new CastExpr(
@@ -252 +163 @@
                 castExpr->set_result( nullptr );
                 delete castExpr;
-                delete vtable_type;
                 return result;
         }