node-gtk 0.14.0 → 2.0.0

package/src/debug.cc

@@ -10,6 +10,7 @@
 #include "type.h"
 
 #include <cstdio>
+#include <cinttypes>
 
 namespace GNodeJS {
 
@@ -245,16 +246,16 @@ void print_gtype (GType type) {
 void print_type (GType type) {
     GType t = type;
     while(!G_TYPE_IS_FUNDAMENTAL(type) && t != 0) {
-        printf("\t\x1b[92m -> %s \t (%lu)\x1b[0m\n", g_type_name(t), t);
+        printf("\t\x1b[92m -> %s \t (%" PRIuPTR ")\x1b[0m\n", g_type_name(t), (uintptr_t)t);
         t = g_type_parent(t);
     }
 }
 
 void print_klass (void * klass) {
     printf("\x1b[38;5;202m");
-    printf("klass: %s  (type: %lu )",
+    printf("klass: %s  (type: %" PRIuPTR " )",
             G_OBJECT_CLASS_NAME (klass),
-            G_OBJECT_CLASS_TYPE (klass) );
+            (uintptr_t)G_OBJECT_CLASS_TYPE (klass) );
     printf("\x1b[0m\n");
 }
 

package/src/function.cc

@@ -55,7 +55,9 @@ static void* AllocateArgument (GIBaseInfo *arg_info) {
 
     GIBaseInfo* base_info = g_type_info_get_interface (&arg_type);
     size_t size = Boxed::GetSize (base_info);
-    void* pointer = g_malloc0(size);
+    GType gtype = g_registered_type_info_get_g_type (base_info);
+    // Match g_boxed_free's allocator for registered boxed types (#290, #213).
+    void* pointer = AllocateBoxed(gtype, size);
 
     g_base_info_unref(base_info);
     return pointer;
@@ -67,6 +69,35 @@ static bool IsMethod (GIBaseInfo *info) {
             (flags & GI_FUNCTION_IS_CONSTRUCTOR) == 0);
 }
 
+static bool EndsWith (const char *str, const char *suffix) {
+    size_t str_len = strlen (str);
+    size_t suffix_len = strlen (suffix);
+    return str_len >= suffix_len && strcmp (str + str_len - suffix_len, suffix) == 0;
+}
+
+/* True for an instance method that deallocates the instance itself — a *_free
+ * or *_unref on a boxed/struct/union. node-gtk's wrapper owns the memory and
+ * frees it on GC, so after such a call the wrapper must disown it or GC will
+ * double-free (#429). Restricted to boxed-like containers: GObject lifetime is
+ * handled separately, and gtk_widget_destroy() etc. don't free the wrapper. */
+static bool FreesInstance (GIFunctionInfo *info) {
+    if (!IsMethod (info))
+        return false;
+
+    const char *symbol = g_function_info_get_symbol (info);
+    if (symbol == NULL || !(EndsWith (symbol, "_free") || EndsWith (symbol, "_unref")))
+        return false;
+
+    GIBaseInfo *container = g_base_info_get_container (info);
+    if (container == NULL)
+        return false;
+
+    GIInfoType type = g_base_info_get_type (container);
+    return type == GI_INFO_TYPE_STRUCT
+        || type == GI_INFO_TYPE_UNION
+        || type == GI_INFO_TYPE_BOXED;
+}
+
 static bool ShouldSkipReturn(GIBaseInfo *info, GITypeInfo *return_type) {
     return g_type_info_get_tag(return_type) == GI_TYPE_TAG_VOID
         || g_callable_info_skip_return(info) == TRUE;
@@ -134,6 +165,7 @@ bool FunctionInfo::Init() {
 
     is_method = IsMethod(info);
     can_throw = g_callable_info_can_throw_gerror (info);
+    frees_instance = FreesInstance(info);
 
     n_callable_args = g_callable_info_get_n_args (info);
     n_total_args = n_callable_args;
@@ -208,14 +240,14 @@ bool FunctionInfo::Init() {
                     if (closure_i >= 0 && closure_i < n_callable_args)
                         call_parameters[closure_i].type = ParameterType::kSKIP;
 
-                    if (destroy_i < i) {
+                    if (destroy_i >= 0 && destroy_i < i) {
                         if (IsDirectionIn(call_parameters[destroy_i].direction))
                             n_in_args--;
                         if (IsDirectionOut(call_parameters[destroy_i].direction))
                             n_out_args--;
                     }
 
-                    if (closure_i < i) {
+                    if (closure_i >= 0 && closure_i < i) {
                         if (IsDirectionIn(call_parameters[closure_i].direction))
                             n_in_args--;
                         if (IsDirectionOut(call_parameters[closure_i].direction))
@@ -335,7 +367,7 @@ Local<Value> FunctionCall (
 
     if (func->is_method) {
         GIBaseInfo *container = g_base_info_get_container (gi_info);
-        V8ToGIArgument(container, &total_arg_values[0], info.This());
+        V8ToGIArgumentInterface(container, &total_arg_values[0], info.This());
         callable_arg_values = &total_arg_values[1];
     } else {
         callable_arg_values = &total_arg_values[0];
@@ -388,16 +420,16 @@ Local<Value> FunctionCall (
         }
         else if (param.type == ParameterType::kCALLBACK) {
             Callback *callback;
-            ffi_closure *closure;
+            gpointer callable; /* executable trampoline address (see Callback) */
 
             if (info[in_arg]->IsNullOrUndefined()) {
-                closure  = nullptr;
+                callable = nullptr;
                 callback = nullptr;
             } else {
                 GICallableInfo *callback_info = g_type_info_get_interface (&type_info);
                 GIScopeType scope_type = g_arg_info_get_scope(&arg_info);
                 callback = new Callback(info[in_arg].As<Function>(), callback_info, scope_type);
-                closure = callback->closure;
+                callable = callback->native_address;
                 g_base_info_unref (callback_info);
             }
 
@@ -414,7 +446,7 @@ Local<Value> FunctionCall (
                 callable_arg_values[closure_i].v_pointer = callback;
             }
 
-            callable_arg_values[i].v_pointer = closure;
+            callable_arg_values[i].v_pointer = callable;
             func->call_parameters[i].data.v_pointer = callback;
         }
 
@@ -440,6 +472,22 @@ Local<Value> FunctionCall (
                     param.data.v_pointer = callable_arg_values[i].v_pointer;
                     callable_arg_values[i].v_pointer = &param.data;
                 }
+                // For a transfer-container IN GList/GSList/GHashTable the callee
+                // frees the container; snapshot the (caller-owned) element
+                // pointers now so they can be freed after the call (#399).
+                else if (IsTransferContainerInList(&type_info,
+                            g_arg_info_get_ownership_transfer(&arg_info), direction)) {
+                    param.data = {};
+                    param.data.v_pointer = CaptureTransferContainerElements(
+                            &type_info, callable_arg_values[i].v_pointer);
+                }
+                // For a transfer-full IN boxed (or array of boxed) the callee
+                // frees the memory; hand it a copy so the JS wrapper's own
+                // memory isn't double-freed when it's finalized (#409).
+                else if (direction == GI_DIRECTION_IN
+                        && g_arg_info_get_ownership_transfer(&arg_info) == GI_TRANSFER_EVERYTHING) {
+                    CopyBoxedForTransferFullIn(&type_info, &callable_arg_values[i], param.length);
+                }
             }
 
             in_arg++;
@@ -488,24 +536,29 @@ Local<Value> FunctionCall (
             Nan::ThrowError(error_stack->message);
             g_error_free(error_stack);
         }
+
+        /*
+        * Fifth, free the return value and arguments
+        */
+
+        if (!use_return_value)
+            FreeGIArgument(&return_type, &return_value_stack, return_transfer);
+
     } else if (!use_return_value) {
-        jsReturnValue = func->GetReturnValue (
+
+        // Value transferred to jsReturnValue
+        jsReturnValue = func->JsReturnValue (
                 info.This(),
                 &return_type,
-                use_return_value ? return_value : &return_value_stack,
-                callable_arg_values);
+                &return_value_stack,
+                callable_arg_values,
+                return_transfer);
     } else {
+
+        // Value returned in return_value
         jsReturnValue = Nan::Undefined();
     }
 
-
-    /*
-     * Fifth, free the return value and arguments
-     */
-
-    if (!use_return_value)
-        FreeGIArgument(&return_type, &return_value_stack, return_transfer);
-
     for (int i = 0; i < func->n_callable_args; i++) {
         GIArgInfo  arg_info = {};
         GITypeInfo arg_type;
@@ -533,6 +586,11 @@ Local<Value> FunctionCall (
                 delete callback;
             }
         }
+        else if (IsTransferContainerInList (&arg_type, transfer, direction)) {
+            // The callee already freed the container structure; free only the
+            // captured (caller-owned) elements, never the freed container (#399).
+            FreeTransferContainerElements (&arg_type, param.data.v_pointer);
+        }
         else {
             if (direction == GI_DIRECTION_INOUT || (direction == GI_DIRECTION_OUT && !g_arg_info_is_caller_allocates (&arg_info)))
                 FreeGIArgument (&arg_type, (GIArgument*)arg_value.v_pointer, transfer, direction);
@@ -541,6 +599,11 @@ Local<Value> FunctionCall (
         }
     }
 
+    // If this method freed the instance, drop node-gtk's ownership of it so the
+    // GC finalizer won't free it a second time (#429).
+    if (func->frees_instance && !didThrow)
+        DisownBoxed (info.This());
+
     #ifndef __linux__
         delete[] total_arg_values;
     #endif
@@ -553,11 +616,12 @@ Local<Value> FunctionCall (
  * Creates the JS return value from the C arguments list
  * @returns the JS return value
  */
-Local<Value> FunctionInfo::GetReturnValue (
+Local<Value> FunctionInfo::JsReturnValue (
         Local<Value> self,
         GITypeInfo* return_type,
         GIArgument* return_value,
-        GIArgument* callable_arg_values) {
+        GIArgument* callable_arg_values,
+        GITransfer return_transfer) {
 
     Local<Value> jsReturnValue;
     int jsReturnIndex = 0;
@@ -591,7 +655,10 @@ Local<Value> FunctionInfo::GetReturnValue (
         // When a method returns the instance itself, skip the conversion and just return the
         // existent wrapper
         bool isReturningSelf = is_method && PointerFromWrapper(self) == return_value->v_pointer;
-        ADD_RETURN (isReturningSelf ? self : GIArgumentToV8 (return_type, return_value, length))
+        ADD_RETURN (isReturningSelf ? self :
+            GIArgumentToV8 (
+                return_type, return_value, length,
+                return_transfer == GI_TRANSFER_EVERYTHING ? kTransfer : kNone))
     }
 
     for (int i = 0; i < n_callable_args; i++) {
@@ -630,13 +697,15 @@ Local<Value> FunctionInfo::GetReturnValue (
                 ADD_RETURN (result)
 
             } else if (param.type == ParameterType::kNORMAL) {
+                GITransfer transfer = g_arg_info_get_ownership_transfer(&arg_info);
+                ResourceOwnership ownership = transfer == GI_TRANSFER_EVERYTHING ? kTransfer : kNone;
 
                 if (IsPointerType(&arg_type) && g_arg_info_is_caller_allocates(&arg_info)) {
                     void *pointer = &arg_value.v_pointer;
-                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) pointer))
+                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) pointer, -1, ownership))
                 }
                 else {
-                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) arg_value.v_pointer))
+                    ADD_RETURN (GIArgumentToV8(&arg_type, (GIArgument*) arg_value.v_pointer, -1, ownership))
                 }
             }
         }
@@ -647,19 +716,6 @@ Local<Value> FunctionInfo::GetReturnValue (
     return jsReturnValue;
 }
 
-/**
- * Frees the C return value
- * @param return_value the return value pointer
- */
-void FunctionInfo::FreeReturnValue (GIArgument *return_value) {
-    GITypeInfo return_type;
-    g_callable_info_load_return_type(info, &return_type);
-    GITransfer return_transfer = g_callable_info_get_caller_owns(info);
-
-    FreeGIArgument(&return_type, return_value, return_transfer);
-}
-
-
 
 Local<Function> MakeFunction(GIBaseInfo *info) {
     FunctionInfo *func = new FunctionInfo(info);
@@ -673,8 +729,8 @@ Local<Function> MakeFunction(GIBaseInfo *info) {
     auto fn = Nan::GetFunction (tpl).ToLocalChecked();
     fn->SetName(name);
 
-    Persistent<FunctionTemplate> persistent(Isolate::GetCurrent(), tpl);
-    persistent.SetWeak(func, FunctionDestroyed, WeakCallbackType::kParameter);
+    func->persistent = new Nan::Persistent<FunctionTemplate>(tpl);
+    func->persistent->SetWeak(func, FunctionDestroyed, WeakCallbackType::kParameter);
 
     return fn;
 }
@@ -691,8 +747,9 @@ void FunctionInvoker(const Nan::FunctionCallbackInfo<Value> &info) {
     Callback::AsyncFree();
 }
 
-void FunctionDestroyed(const v8::WeakCallbackInfo<FunctionInfo> &data) {
+void FunctionDestroyed(const Nan::WeakCallbackInfo<FunctionInfo> &data) {
     FunctionInfo *func = data.GetParameter ();
+    delete func->persistent;
     delete func;
 }
 

package/src/function.h

@@ -33,6 +33,7 @@ struct FunctionInfo {
 
     bool is_method;
     bool can_throw;
+    bool frees_instance; /* a *_free/*_unref method that deallocates the instance (#429) */
 
     int n_callable_args;
     int n_total_args;
@@ -40,14 +41,14 @@ struct FunctionInfo {
     int n_in_args;
 
     Parameter* call_parameters;
+    Nan::Persistent<FunctionTemplate> *persistent;
 
     FunctionInfo(GIBaseInfo* info);
     ~FunctionInfo();
 
     bool Init();
     bool TypeCheck (const Nan::FunctionCallbackInfo<Value> &info);
-    Local<Value> GetReturnValue (Local<Value> self, GITypeInfo* return_type, GIArgument* return_value, GIArgument* callable_arg_values);
-    void FreeReturnValue (GIArgument *return_value);
+    Local<Value> JsReturnValue (Local<Value> self, GITypeInfo* return_type, GIArgument* return_value, GIArgument* callable_arg_values, GITransfer return_transfer);
 };
 
 bool IsDestroyNotify (GIBaseInfo *info);
@@ -55,7 +56,7 @@ bool IsDestroyNotify (GIBaseInfo *info);
 Local<Value> FunctionCall (FunctionInfo *func, const Nan::FunctionCallbackInfo<Value> &info, GIArgument *return_value = NULL, GError **error = NULL);
 
 void FunctionInvoker (const Nan::FunctionCallbackInfo<Value> &info);
-void FunctionDestroyed (const v8::WeakCallbackInfo<FunctionInfo> &data);
+void FunctionDestroyed (const Nan::WeakCallbackInfo<FunctionInfo> &data);
 
 Local<Function>      MakeFunction (GIBaseInfo *base_info);
 

package/src/gi.cc

@@ -208,6 +208,49 @@ NAN_METHOD(ObjectPropertySetter) {
         RETURN(success.ToLocalChecked());
 }
 
+// All members of a C union live at offset 0. Some GLib versions (the
+// regression fixed in 2.86.1 — glib#3745) emit a bogus 0xffff offset for union
+// field members in the compiled typelib, so g_field_info_get_field /
+// g_field_info_set_field would read/write far out of bounds and crash. Detect
+// union fields so they can be accessed directly at offset 0 instead (#376).
+static bool FieldIsInUnion (GIFieldInfo *field) {
+    GIBaseInfo *container = g_base_info_get_container (field);
+    return container != NULL
+        && g_base_info_get_type (container) == GI_INFO_TYPE_UNION;
+}
+
+// Whether a field type is a simple (non-pointer) C value that can be read or
+// written by copying its bytes — mirrors what g_field_info_get/set_field
+// accept. Pointer-backed types (strings, nested structs, arrays, ...) return
+// false and are rejected, as before.
+static bool IsSimpleFieldType (GITypeInfo *type_info) {
+    switch (g_type_info_get_tag (type_info)) {
+        case GI_TYPE_TAG_BOOLEAN:
+        case GI_TYPE_TAG_INT8:
+        case GI_TYPE_TAG_UINT8:
+        case GI_TYPE_TAG_INT16:
+        case GI_TYPE_TAG_UINT16:
+        case GI_TYPE_TAG_INT32:
+        case GI_TYPE_TAG_UINT32:
+        case GI_TYPE_TAG_INT64:
+        case GI_TYPE_TAG_UINT64:
+        case GI_TYPE_TAG_FLOAT:
+        case GI_TYPE_TAG_DOUBLE:
+        case GI_TYPE_TAG_UNICHAR:
+        case GI_TYPE_TAG_GTYPE:
+            return true;
+        case GI_TYPE_TAG_INTERFACE: {
+            GIBaseInfo *iface = g_type_info_get_interface (type_info);
+            GIInfoType  itype = g_base_info_get_type (iface);
+            bool simple = (itype == GI_INFO_TYPE_ENUM || itype == GI_INFO_TYPE_FLAGS);
+            g_base_info_unref (iface);
+            return simple;
+        }
+        default:
+            return false;
+    }
+}
+
 NAN_METHOD(StructFieldSetter) {
     Local<Object> boxedWrapper = info[0].As<Object>();
     Local<Object> fieldInfo    = info[1].As<Object>();
@@ -231,6 +274,17 @@ NAN_METHOD(StructFieldSetter) {
 
         RETURN (Nan::Undefined());
 
+    } else if (FieldIsInUnion(field)) {
+
+        // Union members are at offset 0; write directly to avoid the bogus
+        // introspected offset (glib#3745, #376).
+        if (IsSimpleFieldType(field_type)) {
+            memcpy(boxed, &arg, GNodeJS::GetTypeSize(field_type));
+        } else {
+            Nan::ThrowError("Unable to set field (complex types not allowed)");
+            RETURN (Nan::Undefined());
+        }
+
     } else {
 
         if (g_field_info_set_field(field, boxed, &arg) == FALSE) {
@@ -283,9 +337,22 @@ NAN_METHOD(StructFieldGetter) {
     }
 
     GIArgument value;
-    bool mustCopy = true;
+    GNodeJS::ResourceOwnership ownership = GNodeJS::kCopy;
     BaseInfo typeInfo = g_field_info_get_type(*fieldInfo);
 
+    if (FieldIsInUnion(*fieldInfo)) {
+        // Union members are at offset 0; read directly to avoid the bogus
+        // introspected offset (glib#3745, #376).
+        if (!IsSimpleFieldType(*typeInfo)) {
+            Nan::ThrowError("Converting non-primitive fields is not allowed");
+            return;
+        }
+        memset(&value, 0, sizeof(value));
+        memcpy(&value, boxed, GNodeJS::GetTypeSize(*typeInfo));
+        RETURN(GNodeJS::GIArgumentToV8(*typeInfo, &value, -1, ownership));
+        return;
+    }
+
     if (!g_field_info_get_field(*fieldInfo, boxed, &value)) {
         /* If g_field_info_get_field() failed, this is a non-primitive type */
 
@@ -300,13 +367,13 @@ NAN_METHOD(StructFieldGetter) {
         // auto offset = g_field_info_get_offset(*fieldInfo);
         // auto fieldPtr = G_STRUCT_MEMBER_P(boxed, offset);
         // value.v_pointer = fieldPtr;
-        // mustCopy = false;
+        // ownership = kNone;
 
         Nan::ThrowError("Converting non-primitive fields is not allowed");
         return;
     }
 
-    RETURN(GNodeJS::GIArgumentToV8(*typeInfo, &value, -1, mustCopy));
+    RETURN(GNodeJS::GIArgumentToV8(*typeInfo, &value, -1, ownership));
 }
 
 NAN_METHOD(StartLoop) {