Changes in src/Concurrency/Keywords.cc [43cedfb1:8edbe40]

File:

• src/Concurrency/Keywords.cc (modified) (10 diffs)

src/Concurrency/Keywords.cc

@@ -42 +42 @@
 
 namespace Concurrency {
+        inline static std::string getTypeIdName( std::string const & exception_name ) {
+                return exception_name.empty() ? std::string() : Virtual::typeIdType( exception_name );
+        }
         inline static std::string getVTableName( std::string const & exception_name ) {
-                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
+                return exception_name.empty() ? std::string() : Virtual::vtableTypeName( exception_name );
         }
 
@@ -75 +78 @@
                   type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
                   context_error( context_error ), exception_name( exception_name ),
+                  typeid_name( getTypeIdName( exception_name ) ),
                   vtable_name( getVTableName( exception_name ) ),
                   needs_main( needs_main ), cast_target( cast_target ) {}
@@ -84 +88 @@
 
                 void handle( StructDecl * );
+                void addTypeId( StructDecl * );
                 void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
@@ -99 +104 @@
                 const std::string context_error;
                 const std::string exception_name;
+                const std::string typeid_name;
                 const std::string vtable_name;
                 bool needs_main;
@@ -106 +112 @@
                 FunctionDecl * dtor_decl = nullptr;
                 StructDecl * except_decl = nullptr;
+                StructDecl * typeid_decl = nullptr;
                 StructDecl * vtable_decl = nullptr;
         };
@@ -393 +400 @@
                         except_decl = decl;
                 }
+                else if ( !typeid_decl && typeid_name == decl->name && decl->body ) {
+                        typeid_decl = decl;
+                }
                 else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
                         vtable_decl = decl;
@@ -404 +414 @@
                 if ( type_decl && isDestructorFor( decl, type_decl ) )
                         dtor_decl = decl;
-                else if ( vtable_name.empty() )
-                        ;
-                else if( !decl->has_body() )
+                else if ( vtable_name.empty() || !decl->has_body() )
                         ;
                 else if ( auto param = isMainFor( decl, cast_target ) ) {
@@ -418 +426 @@
                         std::list< Expression * > poly_args = { new TypeExpr( struct_type->clone() ) };
                         ObjectDecl * vtable_object = Virtual::makeVtableInstance(
+                                "_default_vtable_object_declaration",
                                 vtable_decl->makeInst( poly_args ), struct_type, nullptr );
                         declsToAddAfter.push_back( vtable_object );
+                        declsToAddAfter.push_back(
+                                new ObjectDecl(
+                                        Virtual::concurrentDefaultVTableName(),
+                                        Type::Const,
+                                        LinkageSpec::Cforall,
+                                        /* bitfieldWidth */ nullptr,
+                                        new ReferenceType( Type::Const, vtable_object->type->clone() ),
+                                        new SingleInit( new VariableExpr( vtable_object ) )
+                                )
+                        );
                         declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
                                 vtable_object, except_decl->makeInst( std::move( poly_args ) )
@@ -448 +467 @@
                 if( !dtor_decl ) SemanticError( decl, context_error );
 
-                addVtableForward( decl );
+                if ( !exception_name.empty() ) {
+                        if( !typeid_decl ) SemanticError( decl, context_error );
+                        if( !vtable_decl ) SemanticError( decl, context_error );
+
+                        addTypeId( decl );
+                        addVtableForward( decl );
+                }
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
@@ -454 +479 @@
         }
 
+        void ConcurrentSueKeyword::addTypeId( StructDecl * decl ) {
+                assert( typeid_decl );
+                StructInstType typeid_type( Type::Const, typeid_decl );
+                typeid_type.parameters.push_back( new TypeExpr(
+                        new StructInstType( noQualifiers, decl )
+                        ) );
+                declsToAddBefore.push_back( Virtual::makeTypeIdInstance( &typeid_type ) );
+        }
+
         void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
-                if ( vtable_decl ) {
-                        std::list< Expression * > poly_args = {
-                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
-                        };
-                        declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
-                                vtable_decl->makeInst( poly_args ),
-                                except_decl->makeInst( poly_args )
-                        ) );
-                        declsToAddBefore.push_back( Virtual::makeVtableForward(
-                                vtable_decl->makeInst( move( poly_args ) ) ) );
-                // Its only an error if we want a vtable and don't have one.
-                } else if ( ! vtable_name.empty() ) {
-                        SemanticError( decl, context_error );
-                }
+                assert( vtable_decl );
+                std::list< Expression * > poly_args = {
+                        new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                };
+                declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
+                        vtable_decl->makeInst( poly_args ),
+                        except_decl->makeInst( poly_args )
+                ) );
+                ObjectDecl * vtable_object = Virtual::makeVtableForward(
+                        "_default_vtable_object_declaration",
+                        vtable_decl->makeInst( move( poly_args ) ) );
+                declsToAddBefore.push_back( vtable_object );
+                declsToAddBefore.push_back(
+                        new ObjectDecl(
+                                Virtual::concurrentDefaultVTableName(),
+                                Type::Const,
+                                LinkageSpec::Cforall,
+                                /* bitfieldWidth */ nullptr,
+                                new ReferenceType( Type::Const, vtable_object->type->clone() ),
+                                /* init */ nullptr
+                        )
+                );
         }