[[ ForeignCallbacks ]] Implement basic version of C callable LCB closures.

runrevmark · runrevmark · commit 78cfcd30fca1 · 2015-06-17T16:54:02.000+01:00
Code to compute the FFI layout type for handler types has been moved into MCHandlerTypeInfo.

Additionally, an MCHandlerGetFunctionPtr API has been added which attempts to create and then
return a C function pointer which will execute the HandlerRef.

In order to ensure that the Handler value and its closure are not released it is important to
keep the handler value in a variable for the lifetime the function pointer is required.
diff --git a/libfoundation/include/foundation.h b/libfoundation/include/foundation.h
@@ -1637,7 +1637,10 @@ MC_DLLEXPORT MCHandlerTypeFieldMode MCHandlerTypeInfoGetParameterMode(MCTypeInfo
 
 // Return the type of the index'th parameter.
 MC_DLLEXPORT MCTypeInfoRef MCHandlerTypeInfoGetParameterType(MCTypeInfoRef typeinfo, uindex_t index);
-
+    
+// Returns the 'native' layout ptr (an ffi_cif) for the handler type
+MC_DLLEXPORT bool MCHandlerTypeInfoGetLayoutType(MCTypeInfoRef typeinfo, int abi, void*& r_cif);
+    
 //////////
 
 MC_DLLEXPORT bool MCErrorTypeInfoCreate(MCNameRef domain, MCStringRef message, MCTypeInfoRef& r_typeinfo);
@@ -2605,6 +2608,8 @@ MC_DLLEXPORT const MCHandlerCallbacks *MCHandlerGetCallbacks(MCHandlerRef handle
     
 MC_DLLEXPORT bool MCHandlerInvoke(MCHandlerRef handler, MCValueRef *arguments, uindex_t argument_count, MCValueRef& r_value);
 MC_DLLEXPORT /*copy*/ MCErrorRef MCHandlerTryToInvokeWithList(MCHandlerRef handler, MCProperListRef& x_arguments, MCValueRef& r_value);
+    
+MC_DLLEXPORT bool MCHandlerGetFunctionPtr(MCHandlerRef handler, void*& r_func_ptr);
 
 ////////////////////////////////////////////////////////////////////////////////
 //
diff --git a/libfoundation/src/foundation-handler.cpp b/libfoundation/src/foundation-handler.cpp
@@ -17,6 +17,8 @@
 #include <foundation.h>
 #include <foundation-auto.h>
 
+#include <ffi.h>
+
 #include "foundation-private.h"
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -33,6 +35,7 @@ bool MCHandlerCreate(MCTypeInfoRef p_typeinfo, const MCHandlerCallbacks *p_callb
     MCMemoryCopy(MCHandlerGetContext(self), p_context, p_callbacks -> size);
     
     self -> typeinfo = MCValueRetain(p_typeinfo);
+    self -> function_ptr = nil;
     self -> callbacks = p_callbacks;
     
     r_handler = self;
@@ -90,10 +93,141 @@ const MCHandlerCallbacks *MCHandlerGetCallbacks(MCHandlerRef self)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+static void __exec_closure(ffi_cif *cif, void *ret, void **args, void *user_data)
+{
+    MCHandlerRef t_handler;
+    t_handler = (MCHandlerRef)user_data;
+    
+    MCTypeInfoRef t_signature;
+    t_signature = t_handler -> typeinfo;
+    
+    uindex_t t_arity;
+    t_arity = MCHandlerTypeInfoGetParameterCount(t_signature);
+    
+    MCValueRef t_value_result;
+    MCValueRef t_value_args[16];
+    uindex_t t_arg_index;
+    t_arg_index = 0;
+    t_value_result = nil;
+    for(t_arg_index = 0; t_arg_index < t_arity; t_arg_index++)
+    {
+        MCHandlerTypeFieldMode t_mode;
+        t_mode = MCHandlerTypeInfoGetParameterMode(t_signature, t_arg_index);
+        
+        MCTypeInfoRef t_type;
+        t_type = MCHandlerTypeInfoGetParameterType(t_signature, t_arg_index);
+        
+        if (t_mode != kMCHandlerTypeFieldModeIn)
+            abort();
+        
+        MCResolvedTypeInfo t_resolved_type;
+        if (!MCTypeInfoResolve(t_type, t_resolved_type))
+        {
+            MCErrorThrowGeneric(nil);
+            goto error_exit;
+        }
+        
+        if (MCTypeInfoIsForeign(t_resolved_type . type))
+        {
+            const MCForeignTypeDescriptor *t_descriptor;
+            t_descriptor = MCForeignTypeInfoGetDescriptor(t_resolved_type . type);
+            if (t_descriptor -> defined != nil &&
+                !t_descriptor -> defined(args[t_arg_index]))
+                t_value_args[t_arg_index] = MCValueRetain(kMCNull);
+            else
+            {
+                if (t_descriptor -> bridgetype != kMCNullTypeInfo)
+                {
+                    if (!t_descriptor -> doimport(args[t_arg_index], false, t_value_args[t_arg_index]))
+                        goto error_exit;
+                }
+                else
+                {
+                    if (!MCForeignValueCreateAndRelease(t_resolved_type . named_type, args[t_arg_index], (MCForeignValueRef&)t_value_args[t_arg_index]))
+                        goto error_exit;
+                }
+            }
+        }
+        else
+        {
+            t_value_args[t_arg_index] = MCValueRetain((MCValueRef)args[t_arg_index]);
+        }
+    }
+    
+    if (!MCHandlerInvoke(t_handler, t_value_args, t_arity, t_value_result))
+        goto error_exit;
+    
+    MCTypeInfoRef t_return_type;
+    t_return_type = MCHandlerTypeInfoGetReturnType(t_signature);
+    
+    MCResolvedTypeInfo t_resolved_return_type;
+    t_return_type = MCHandlerTypeInfoGetReturnType(t_signature);
+    if (!MCTypeInfoResolve(t_return_type, t_resolved_return_type))
+    {
+        MCErrorThrowGeneric(nil);
+        goto error_exit;
+    }
+    
+    if (t_resolved_return_type . named_type != kMCNullTypeInfo)
+    {
+        if (MCTypeInfoIsForeign(t_resolved_return_type . type))
+        {
+            const MCForeignTypeDescriptor *t_descriptor;
+            t_descriptor = MCForeignTypeInfoGetDescriptor(t_resolved_return_type . type);
+            if (!t_descriptor -> doexport(t_value_result, true, ret))
+                goto error_exit;
+        }
+        else
+        {
+            *(MCValueRef *)ret = t_value_result;
+            t_value_result = nil;
+        }
+    }
+    
+    return;
+    
+error_exit:
+    if (t_value_result != nil)
+        MCValueRelease(t_value_result);
+    for(uindex_t i = 0; i < t_arg_index; i++)
+        MCValueRelease(t_value_args[i]);
+}
+
+bool MCHandlerGetFunctionPtr(MCHandlerRef self, void*& r_function_ptr)
+{
+    if (self -> function_ptr != nil)
+    {
+        r_function_ptr = self -> function_ptr;
+        return true;
+    }
+    
+    ffi_cif *t_cif;
+    if (!MCHandlerTypeInfoGetLayoutType(self -> typeinfo, (int)FFI_DEFAULT_ABI, (void*&)t_cif))
+        return false;
+    
+    self -> closure = ffi_closure_alloc(sizeof(ffi_closure), &self -> function_ptr);
+    if (self -> closure == nil)
+        return MCErrorThrowOutOfMemory();
+    
+    if (ffi_prep_closure_loc((ffi_closure *)self -> closure, t_cif, __exec_closure, self, self -> function_ptr) != FFI_OK)
+    {
+        ffi_closure_free(self -> closure);
+        self -> closure = nil;
+        return MCErrorThrowGeneric(nil);
+    }
+    
+    r_function_ptr = self -> function_ptr;
+    return true;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 void __MCHandlerDestroy(__MCHandler *self)
 {
     if (self -> callbacks -> release != nil)
         self -> callbacks -> release(MCHandlerGetContext(self));
+    if (self -> function_ptr != nil)
+        ffi_closure_free(self -> function_ptr);
 }
 
 hash_t __MCHandlerHash(__MCHandler *self)
diff --git a/libfoundation/src/foundation-private.h b/libfoundation/src/foundation-private.h
@@ -65,6 +65,13 @@ enum
     kMCTypeInfoTypeIsForeign = 251,
 };
 
+struct MCHandlerTypeLayout
+{
+    MCHandlerTypeLayout *next;
+    int abi;
+    char cif[1];
+};
+
 struct __MCTypeInfo: public __MCValue
 {
     union
@@ -89,6 +96,8 @@ struct __MCTypeInfo: public __MCValue
             MCHandlerTypeFieldInfo *fields;
             uindex_t field_count;
             MCTypeInfoRef return_type;
+            void **layout_args;
+            MCHandlerTypeLayout *layouts;
         } handler;
         struct
         {
@@ -421,6 +430,8 @@ struct __MCHandler: public __MCValue
 {
     MCTypeInfoRef typeinfo;
     const MCHandlerCallbacks *callbacks;
+    void *closure;
+    void *function_ptr;
     char context[1];
 };
 
diff --git a/libfoundation/src/foundation-typeinfo.cpp b/libfoundation/src/foundation-typeinfo.cpp
@@ -721,6 +721,9 @@ bool MCHandlerTypeInfoCreate(const MCHandlerTypeFieldInfo *p_fields, index_t p_f
     
     self -> handler . return_type = MCValueRetain(p_return_type);
     
+    self -> handler . layout_args= nil;
+    self -> handler . layouts = nil;
+    
     if (MCValueInterAndRelease(self, r_typeinfo))
         return true;
     
@@ -771,6 +774,103 @@ MCTypeInfoRef MCHandlerTypeInfoGetParameterType(MCTypeInfoRef unresolved_self, u
     return self -> handler . fields[p_index] . type;
 }
 
+bool MCHandlerTypeInfoGetLayoutType(MCTypeInfoRef unresolved_self, int p_abi, void*& r_cif)
+{
+    MCTypeInfoRef self;
+    self = __MCTypeInfoResolve(unresolved_self);
+    
+    MCAssert((self -> flags & kMCTypeInfoTypeCodeMask) == kMCValueTypeCodeHandler);
+    
+    // If a layout for the given ABI already exists, then return it.
+    for(MCHandlerTypeLayout *t_layout = self -> handler . layouts; t_layout != nil; t_layout = t_layout -> next)
+        if (t_layout -> abi == p_abi)
+        {
+            r_cif = &t_layout -> cif;
+            return true;
+        }
+    
+    // If we haven't computed the layout args yet, do so.
+    if (self -> handler . layout_args == nil)
+    {
+        MCTypeInfoRef t_return_type;
+        t_return_type = self -> handler . return_type;
+        
+        MCResolvedTypeInfo t_resolved_return_type;
+        if (!MCTypeInfoResolve(t_return_type, t_resolved_return_type))
+            return MCErrorThrowGeneric(nil);
+        
+        ffi_type *t_ffi_return_type;
+        if (t_return_type != kMCNullTypeInfo)
+        {
+            if (MCTypeInfoIsForeign(t_resolved_return_type . type))
+                t_ffi_return_type = (ffi_type *)MCForeignTypeInfoGetLayoutType(t_resolved_return_type . type);
+            else
+                t_ffi_return_type = &ffi_type_pointer;
+        }
+        else
+            t_ffi_return_type = &ffi_type_void;
+
+        uindex_t t_arity;
+        t_arity = self -> handler . field_count;
+        
+        ffi_type **t_ffi_arg_types;
+        if (!MCMemoryNewArray(t_arity + 1, t_ffi_arg_types))
+            return false;
+        
+        t_ffi_arg_types[0] = t_ffi_return_type;
+        
+        bool t_success;
+        t_success = true;
+        for(uindex_t i = 0; t_success && i < t_arity; i++)
+        {
+            MCTypeInfoRef t_type;
+            MCHandlerTypeFieldMode t_mode;
+            t_type = self -> handler . fields[i] . type;
+            t_mode = self -> handler . fields[i] . mode;
+            
+            MCResolvedTypeInfo t_resolved_type;
+            if (!MCTypeInfoResolve(t_type, t_resolved_type))
+            {
+                t_success = false;
+                break;
+            }
+            
+            if (t_mode == kMCHandlerTypeFieldModeIn)
+            {
+                if (MCTypeInfoIsForeign(t_resolved_type . type))
+                    t_ffi_arg_types[i + 1] = (ffi_type *)MCForeignTypeInfoGetLayoutType(t_resolved_type . type);
+                else
+                    t_ffi_arg_types[i + 1] = &ffi_type_pointer;
+            }
+            else
+                t_ffi_arg_types[i + 1] = &ffi_type_pointer;
+        }
+
+        if (!t_success)
+            return MCErrorThrowGeneric(nil);
+        
+        self -> handler . layout_args = (void **)t_ffi_arg_types;
+    }
+    
+    // Now we must create a new layout object.
+    MCHandlerTypeLayout *t_layout;
+    if (!MCMemoryAllocate(sizeof(MCHandlerTypeLayout) + sizeof(ffi_cif), t_layout))
+        return false;
+    
+    if (ffi_prep_cif((ffi_cif *)&t_layout -> cif, (ffi_abi)p_abi, self -> handler . field_count, (ffi_type *)self -> handler . layout_args[0], (ffi_type **)(self -> handler . layout_args + 1)) != FFI_OK)
+    {
+        MCMemoryDeallocate(t_layout);
+        return MCErrorThrowGeneric(nil);
+    }
+    
+    t_layout -> next = self -> handler . layouts;
+    self -> handler . layouts = t_layout;
+    
+    r_cif = &t_layout -> cif;
+    
+    return true;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 bool MCErrorTypeInfoCreate(MCNameRef p_domain, MCStringRef p_message, MCTypeInfoRef& r_typeinfo)
@@ -954,6 +1054,14 @@ void __MCTypeInfoDestroy(__MCTypeInfo *self)
         }
         MCValueRelease(self -> handler . return_type);
         MCMemoryDeleteArray(self -> handler . fields);
+        MCMemoryDeleteArray(self -> handler . layout_args);
+        while(self -> handler . layouts != nil)
+        {
+            MCHandlerTypeLayout *t_layout;
+            t_layout = self -> handler . layouts;
+            self -> handler . layouts = self -> handler . layouts -> next;
+            MCMemoryDeallocate(t_layout);
+        }
     }
     else if (t_ext_typecode == kMCValueTypeCodeError)
     {
diff --git a/libscript/src/script-instance.cpp b/libscript/src/script-instance.cpp
diff --git a/libscript/src/script-module.cpp b/libscript/src/script-module.cpp
