node-gtk 1.0.0 → 2.1.0

package/src/value.cc

@@ -35,6 +35,21 @@ static void HashPointerToGIArgument (GIArgument *arg, GITypeInfo *type_info);
 
 static bool IsUint8Array (GITypeInfo *type_info);
 
+/* Accept both Number and BigInt for 64-bit / platform-dependent integer
+ * holders. Reading those types yields a BigInt (#323, #149), so a value
+ * round-tripped through JS arrives back here as a BigInt. */
+static gint64 V8ToInt64 (Local<Value> value) {
+    if (value->IsBigInt())
+        return value.As<v8::BigInt>()->Int64Value();
+    return Nan::To<int64_t> (value).ToChecked();
+}
+
+static guint64 V8ToUint64 (Local<Value> value) {
+    if (value->IsBigInt())
+        return value.As<v8::BigInt>()->Uint64Value();
+    return (guint64) Nan::To<int64_t> (value).ToChecked();
+}
+
 
 Local<Value> GIArgumentToV8(GITypeInfo *type_info, GIArgument *arg, long length, ResourceOwnership ownership) {
     GITypeTag type_tag = g_type_info_get_tag (type_info);
@@ -61,12 +76,13 @@ Local<Value> GIArgumentToV8(GITypeInfo *type_info, GIArgument *arg, long length,
     case GI_TYPE_TAG_DOUBLE:
         return New<Number> (arg->v_double);
 
-    /* For 64-bit integer types, use a float. When JS and V8 adopt
-     * bigger sized integer types, start using those instead. */
+    /* 64-bit integers are returned as BigInt so values above
+     * Number.MAX_SAFE_INTEGER keep full precision (#323, #149). The IN side
+     * accepts both Number and BigInt. */
     case GI_TYPE_TAG_INT64:
-        return New<Number> (arg->v_int64);
+        return v8::BigInt::New (Isolate::GetCurrent(), arg->v_int64);
     case GI_TYPE_TAG_UINT64:
-        return New<Number> (arg->v_uint64);
+        return v8::BigInt::NewFromUnsigned (Isolate::GetCurrent(), arg->v_uint64);
 
     case GI_TYPE_TAG_GTYPE: /* c++: gsize */
         return v8::BigInt::NewFromUnsigned(Isolate::GetCurrent(), arg->v_size);
@@ -212,6 +228,18 @@ Local<Value> GHashToV8 (GITypeInfo *type_info, GHashTable *hash_table) {
 
     Local<Object> object = New<Object>();
 
+    // A NULL table marshals to an empty object. This notably happens for
+    // *_out_uninitialized functions, which return FALSE and leave their (out)
+    // pointer untouched (i.e. NULL, as the slot is zero-initialized). The
+    // GList/GSList/C-array converters already tolerate NULL; without this
+    // guard g_hash_table_iter_init asserts and the iterator is left
+    // uninitialized (#400).
+    if (hash_table == NULL) {
+        g_base_info_unref(key_info);
+        g_base_info_unref(value_info);
+        return object;
+    }
+
     GHashTableIter iter;
     GIArgument key_arg;
     GIArgument value_arg;
@@ -287,6 +315,14 @@ static bool isZero(GIArgument &value, GITypeInfo *type_info) {
     }
 }
 
+static bool IsZeroMemory (const void *ptr, gsize size) {
+    const guint8 *bytes = (const guint8 *) ptr;
+    for (gsize i = 0; i < size; i++)
+        if (bytes[i] != 0)
+            return false;
+    return true;
+}
+
 Local<Value> ArrayToV8 (GITypeInfo *type_info, void* data, long length) {
 
     auto array = New<Array>();
@@ -299,6 +335,26 @@ Local<Value> ArrayToV8 (GITypeInfo *type_info, void* data, long length) {
     auto item_size = GetTypeSize (item_type_info);
     // auto item_transfer = transfer == GI_TRANSFER_CONTAINER ? GI_TRANSFER_NOTHING : transfer;
 
+    // Composite values (a struct/union/boxed passed by value, e.g. an array of
+    // GValue) are stored inline and may be larger than a GIArgument, so they
+    // must not be memcpy'd into one — that overflows the stack (#398). Detect
+    // them up front so the fill loop can read them in place instead.
+    bool element_is_value_struct = false;
+    bool element_is_gvalue = false;
+    if (g_type_info_get_tag (item_type_info) == GI_TYPE_TAG_INTERFACE
+            && !g_type_info_is_pointer (item_type_info)) {
+        GIBaseInfo *element_interface = g_type_info_get_interface (item_type_info);
+        GIInfoType  element_interface_type = g_base_info_get_type (element_interface);
+        if (element_interface_type == GI_INFO_TYPE_STRUCT
+                || element_interface_type == GI_INFO_TYPE_BOXED
+                || element_interface_type == GI_INFO_TYPE_UNION) {
+            element_is_value_struct = true;
+            element_is_gvalue =
+                g_registered_type_info_get_g_type (element_interface) == G_TYPE_VALUE;
+        }
+        g_base_info_unref (element_interface);
+    }
+
     switch (array_type) {
         case GI_ARRAY_TYPE_C:
             {
@@ -349,13 +405,27 @@ Local<Value> ArrayToV8 (GITypeInfo *type_info, void* data, long length) {
         if (length != -1 && i >= length)
             break;
 
-        void** pointer = (void**)((size_t)data + i * item_size);
-        memcpy(&value, pointer, item_size);
+        void* element_ptr = (void*)((size_t)data + i * item_size);
 
-        if (length == -1 && isZero(value, item_type_info))
-            break;
+        if (element_is_value_struct) {
+            // A zero-terminated array of values ends on an all-zero element.
+            if (length == -1 && IsZeroMemory(element_ptr, item_size))
+                break;
+
+            if (element_is_gvalue) {
+                Nan::Set(array, i, GValueToV8((GValue*) element_ptr));
+            } else {
+                value.v_pointer = element_ptr;
+                Nan::Set(array, i, GIArgumentToV8(item_type_info, &value));
+            }
+        } else {
+            memcpy(&value, element_ptr, item_size);
+
+            if (length == -1 && isZero(value, item_type_info))
+                break;
 
-        Nan::Set(array, i, GIArgumentToV8(item_type_info, &value));
+            Nan::Set(array, i, GIArgumentToV8(item_type_info, &value));
+        }
     }
 
 
@@ -450,6 +520,36 @@ GArray * V8ToGArray(GITypeInfo *type_info, Local<Value> value) {
     return g_array;
 }
 
+GPtrArray * V8ToGPtrArray(GITypeInfo *type_info, Local<Value> value) {
+    if (!value->IsArray()) {
+        Nan::ThrowTypeError("Expected an array.");
+        return NULL;
+    }
+
+    auto array = Local<Array>::Cast (TO_OBJECT (value));
+    int length = array->Length();
+
+    GITypeInfo *element_info = g_type_info_get_param_type (type_info, 0);
+    GPtrArray *ptr_array = g_ptr_array_sized_new (length);
+
+    for (int i = 0; i < length; i++) {
+        auto element = Nan::Get(array, i).ToLocalChecked();
+        GIArgument arg;
+
+        // A GPtrArray always stores its elements as pointers, so each element
+        // is converted to its pointer representation (e.g. g_strdup'd string,
+        // GObject/boxed pointer) and added directly.
+        if (V8ToGIArgument(element_info, &arg, element, false)) {
+            g_ptr_array_add (ptr_array, arg.v_pointer);
+        } else {
+            g_warning("V8ToGPtrArray: couldnt convert value at index %i", i);
+        }
+    }
+
+    g_base_info_unref (element_info);
+    return ptr_array;
+}
+
 static void *V8ArrayToCArray(GITypeInfo *type_info, Local<Value> value) {
     auto array = Local<Array>::Cast (TO_OBJECT (value));
     int length = array->Length();
@@ -458,6 +558,22 @@ static void *V8ArrayToCArray(GITypeInfo *type_info, Local<Value> value) {
     GITypeInfo* element_info = g_type_info_get_param_type (type_info, 0);
     gsize element_size = GetTypeSize(element_info);
 
+    // When the element is a struct/union/boxed passed by *value* (not a
+    // pointer), the C array stores the struct contents inline, so each
+    // element's bytes must be copied from the wrapped instance rather than
+    // copying the GIArgument (which only holds a pointer to it).
+    bool element_is_struct_by_value = false;
+    if (!g_type_info_is_pointer(element_info)
+            && g_type_info_get_tag(element_info) == GI_TYPE_TAG_INTERFACE) {
+        GIBaseInfo* interface_info = g_type_info_get_interface(element_info);
+        GIInfoType  interface_type = g_base_info_get_type(interface_info);
+        element_is_struct_by_value =
+               interface_type == GI_INFO_TYPE_STRUCT
+            || interface_type == GI_INFO_TYPE_BOXED
+            || interface_type == GI_INFO_TYPE_UNION;
+        g_base_info_unref(interface_info);
+    }
+
     void *result = g_malloc0(element_size * (length + (isZeroTerminated ? 1 : 0)));
 
     for (int i = 0; i < length; i++) {
@@ -467,7 +583,10 @@ static void *V8ArrayToCArray(GITypeInfo *type_info, Local<Value> value) {
 
         if (V8ToGIArgument(element_info, &arg, value, true)) {
             void* pointer = (void*)((size_t)result + i * element_size);
-            memcpy(pointer, &arg, element_size);
+            if (element_is_struct_by_value && arg.v_pointer != NULL)
+                memcpy(pointer, arg.v_pointer, element_size);
+            else
+                memcpy(pointer, &arg, element_size);
         } else {
             WARN("couldnt convert value: %s", *Nan::Utf8String(TO_STRING (value)));
         }
@@ -607,10 +726,15 @@ gpointer V8ToGHash (GITypeInfo *type_info, Local<Value> value) {
         case GI_TYPE_TAG_UINT16:
         case GI_TYPE_TAG_INT32:
         case GI_TYPE_TAG_UINT32:
-            hash_func  = g_int_hash;
-            equal_func = g_int_equal;
-            break;
         case GI_TYPE_TAG_GTYPE:
+            // The key is stored directly in the pointer via
+            // GINT_TO_POINTER/GSIZE_TO_POINTER (see GIArgumentToHashPointer),
+            // matching the GObject-introspection convention. g_int_hash and
+            // g_int64_hash dereference their argument as a pointer-to-integer,
+            // so they crash on these packed values — use g_direct_* instead.
+            hash_func  = g_direct_hash;
+            equal_func = g_direct_equal;
+            break;
         case GI_TYPE_TAG_INT64:
         case GI_TYPE_TAG_UINT64:
             hash_func  = g_int64_hash;
@@ -665,7 +789,9 @@ gpointer V8ToGHash (GITypeInfo *type_info, Local<Value> value) {
             goto item_error;
         }
 
-        g_hash_table_insert (hash_table, key_arg.v_pointer, GIArgumentToHashPointer (&value_arg, value_type_info));
+        g_hash_table_insert (hash_table,
+                GIArgumentToHashPointer (&key_arg, key_type_info),
+                GIArgumentToHashPointer (&value_arg, value_type_info));
 
         continue;
 
@@ -818,6 +944,8 @@ bool V8ToGIArgument(GITypeInfo *type_info, GIArgument *arg, Local<Value> value,
                 arg->v_pointer = V8ToGArray(type_info, value);
                 break;
             case GI_ARRAY_TYPE_PTR_ARRAY:
+                arg->v_pointer = V8ToGPtrArray(type_info, value);
+                break;
             default:
                 printf("%s", Util::ArrayTypeToString(array_type));
                 g_assert_not_reached ();
@@ -1356,9 +1484,15 @@ void FreeGIArgumentArray(GITypeInfo *type_info, GIArgument *arg, GITransfer tran
             }
         case GI_ARRAY_TYPE_ARRAY:
         case GI_ARRAY_TYPE_BYTE_ARRAY:
+            {
+                // Free the container struct, not `data`, which may have been
+                // reassigned to the inner buffer in the free-elements block.
+                g_array_free ((GArray*) arg->v_pointer, TRUE);
+                break;
+            }
         case GI_ARRAY_TYPE_PTR_ARRAY:
             {
-                g_array_free ((GArray*)data, TRUE);
+                g_ptr_array_free ((GPtrArray*) arg->v_pointer, TRUE);
                 break;
             }
         default:
@@ -1368,6 +1502,178 @@ void FreeGIArgumentArray(GITypeInfo *type_info, GIArgument *arg, GITransfer tran
     }
 }
 
+/*
+ * Transfer-container IN cleanup for GList/GSList/GHashTable.
+ *
+ * With transfer-container, the callee takes ownership of (and frees) the
+ * container structure but NOT its elements, which the caller still owns. By
+ * the time node-gtk runs its post-call cleanup the container has already been
+ * freed, so it can no longer be walked to reach the (owned) elements — doing
+ * so corrupts the heap (#399). Instead we snapshot the element pointers into a
+ * private structure *before* the call and free them from that snapshot after.
+ */
+
+struct CapturedContainer {
+    GList  *list;    // GLIST: copied node chain; GHASH: keys
+    GSList *slist;   // GSLIST: copied node chain
+    GList  *values;  // GHASH: values
+};
+
+bool IsTransferContainerInList (GITypeInfo *type_info, GITransfer transfer, GIDirection direction) {
+    if (direction != GI_DIRECTION_IN || transfer != GI_TRANSFER_CONTAINER)
+        return false;
+
+    switch (g_type_info_get_tag (type_info)) {
+        case GI_TYPE_TAG_GLIST:
+        case GI_TYPE_TAG_GSLIST:
+        case GI_TYPE_TAG_GHASH:
+            return true;
+        default:
+            return false;
+    }
+}
+
+gpointer CaptureTransferContainerElements (GITypeInfo *type_info, gpointer container) {
+    if (container == NULL)
+        return NULL;
+
+    CapturedContainer *captured = g_new0 (CapturedContainer, 1);
+
+    switch (g_type_info_get_tag (type_info)) {
+        case GI_TYPE_TAG_GLIST:
+            captured->list = g_list_copy ((GList *) container);
+            break;
+        case GI_TYPE_TAG_GSLIST:
+            captured->slist = g_slist_copy ((GSList *) container);
+            break;
+        case GI_TYPE_TAG_GHASH:
+            captured->list   = g_hash_table_get_keys ((GHashTable *) container);
+            captured->values = g_hash_table_get_values ((GHashTable *) container);
+            break;
+        default:
+            break;
+    }
+
+    return captured;
+}
+
+void FreeTransferContainerElements (GITypeInfo *type_info, gpointer captured_ptr) {
+    if (captured_ptr == NULL)
+        return;
+
+    CapturedContainer *captured = (CapturedContainer *) captured_ptr;
+    GITypeTag   type_tag = g_type_info_get_tag (type_info);
+    GITypeInfo *key_info = g_type_info_get_param_type (type_info, 0);
+    GIArgument  element;
+
+    if (type_tag == GI_TYPE_TAG_GSLIST) {
+        for (GSList *l = captured->slist; l != NULL; l = l->next) {
+            element.v_pointer = l->data;
+            FreeGIArgument (key_info, &element, GI_TRANSFER_EVERYTHING, GI_DIRECTION_OUT);
+        }
+        g_slist_free (captured->slist);
+    } else {
+        for (GList *l = captured->list; l != NULL; l = l->next) {
+            element.v_pointer = l->data;
+            FreeGIArgument (key_info, &element, GI_TRANSFER_EVERYTHING, GI_DIRECTION_OUT);
+        }
+        g_list_free (captured->list);
+    }
+    g_base_info_unref (key_info);
+
+    if (type_tag == GI_TYPE_TAG_GHASH) {
+        GITypeInfo *value_info = g_type_info_get_param_type (type_info, 1);
+        for (GList *l = captured->values; l != NULL; l = l->next) {
+            element.v_pointer = l->data;
+            FreeGIArgument (value_info, &element, GI_TRANSFER_EVERYTHING, GI_DIRECTION_OUT);
+        }
+        g_base_info_unref (value_info);
+        g_list_free (captured->values);
+    }
+
+    g_free (captured);
+}
+
+// Returns the boxed GType of a struct/union/boxed interface type, or
+// G_TYPE_INVALID if `type_info` isn't a registered boxed type.
+static GType BoxedGTypeOf (GITypeInfo *type_info) {
+    if (g_type_info_get_tag(type_info) != GI_TYPE_TAG_INTERFACE)
+        return G_TYPE_INVALID;
+
+    GIBaseInfo *interface_info = g_type_info_get_interface(type_info);
+    GIInfoType  interface_type = g_base_info_get_type(interface_info);
+    GType       gtype = G_TYPE_INVALID;
+
+    if (interface_type == GI_INFO_TYPE_BOXED
+            || interface_type == GI_INFO_TYPE_STRUCT
+            || interface_type == GI_INFO_TYPE_UNION) {
+        GType registered = g_registered_type_info_get_g_type(interface_info);
+        if (G_TYPE_IS_BOXED(registered))
+            gtype = registered;
+    }
+
+    g_base_info_unref(interface_info);
+    return gtype;
+}
+
+void CopyBoxedForTransferFullIn (GITypeInfo *type_info, GIArgument *arg, long length) {
+    if (arg->v_pointer == NULL)
+        return;
+
+    GITypeTag type_tag = g_type_info_get_tag(type_info);
+
+    // A single boxed argument passed by value/pointer.
+    if (type_tag == GI_TYPE_TAG_INTERFACE) {
+        GType gtype = BoxedGTypeOf(type_info);
+        if (gtype != G_TYPE_INVALID)
+            arg->v_pointer = g_boxed_copy(gtype, arg->v_pointer);
+        return;
+    }
+
+    // A C array of boxed pointers (e.g. GIMarshallingTestsBoxedStruct **).
+    if (type_tag == GI_TYPE_TAG_ARRAY
+            && g_type_info_get_array_type(type_info) == GI_ARRAY_TYPE_C
+            && length >= 0) {
+        GITypeInfo *element_info = g_type_info_get_param_type(type_info, 0);
+
+        if (g_type_info_is_pointer(element_info)) {
+            GType gtype = BoxedGTypeOf(element_info);
+            if (gtype != G_TYPE_INVALID) {
+                gpointer *elements = (gpointer *) arg->v_pointer;
+                for (long i = 0; i < length; i++)
+                    if (elements[i] != NULL)
+                        elements[i] = g_boxed_copy(gtype, elements[i]);
+            }
+        }
+
+        g_base_info_unref(element_info);
+    }
+}
+
+void RefObjectForTransferFullIn (GITypeInfo *type_info, GIArgument *arg) {
+    if (arg->v_pointer == NULL)
+        return;
+
+    if (g_type_info_get_tag(type_info) != GI_TYPE_TAG_INTERFACE)
+        return;
+
+    GIBaseInfo *iface = g_type_info_get_interface(type_info);
+    GIInfoType  itype = g_base_info_get_type(iface);
+
+    // The callee owns one reference after the call (transfer-full). node-gtk
+    // keeps only its toggle ref, so without this the callee would effectively
+    // "own" the toggle ref: the refcount never accounts for the new owner, no
+    // toggle-up fires, the wrapper stays weak, and once GC collects it the
+    // destroy callback finalizes the object while the callee still uses it
+    // (e.g. a controller passed to gtk_widget_add_controller). The G_IS_OBJECT
+    // guard skips boxed/fundamental interface types (handled elsewhere).
+    if ((itype == GI_INFO_TYPE_OBJECT || itype == GI_INFO_TYPE_INTERFACE)
+            && G_IS_OBJECT(arg->v_pointer))
+        g_object_ref(arg->v_pointer);
+
+    g_base_info_unref(iface);
+}
+
 
 /*
  * GValue conversion functions
@@ -1389,19 +1695,19 @@ bool CanConvertV8ToGValue(GValue *gvalue, Local<Value> value) {
     } else if (G_VALUE_HOLDS_UINT (gvalue)) {
         return value->IsNumber();
     } else if (G_VALUE_HOLDS_LONG (gvalue)) {
-        return value->IsNumber();
+        return value->IsNumber() || value->IsBigInt();
     } else if (G_VALUE_HOLDS_ULONG (gvalue)) {
-        return value->IsNumber();
+        return value->IsNumber() || value->IsBigInt();
     } else if (G_VALUE_HOLDS_INT64 (gvalue)) {
-        return value->IsNumber();
+        return value->IsNumber() || value->IsBigInt();
     } else if (G_VALUE_HOLDS_UINT64 (gvalue)) {
-        return value->IsNumber();
+        return value->IsNumber() || value->IsBigInt();
     } else if (G_VALUE_HOLDS_FLOAT (gvalue)) {
         return value->IsNumber();
     } else if (G_VALUE_HOLDS_DOUBLE (gvalue)) {
         return value->IsNumber();
     } else if (G_VALUE_HOLDS_GTYPE (gvalue)) {
-        return value->IsNumber();
+        return value->IsNumber() || value->IsBigInt();
     } else if (G_VALUE_HOLDS_ENUM (gvalue)) {
         return value->IsNumber();
     } else if (G_VALUE_HOLDS_FLAGS (gvalue)) {
@@ -1410,6 +1716,9 @@ bool CanConvertV8ToGValue(GValue *gvalue, Local<Value> value) {
         return value->IsString();
     } else if (G_VALUE_HOLDS_OBJECT (gvalue)) {
         return ValueIsInstanceOfGType(value, G_VALUE_TYPE (gvalue));
+    } else if (G_VALUE_HOLDS (gvalue, G_TYPE_STRV)) {
+        // GStrv is a boxed type, so this must come before G_VALUE_HOLDS_BOXED.
+        return value->IsArray();
     } else if (G_VALUE_HOLDS_BOXED (gvalue)) {
         return ValueIsInstanceOfGType(value, G_VALUE_TYPE (gvalue));
     } else if (G_VALUE_HOLDS_PARAM (gvalue)) {
@@ -1453,19 +1762,19 @@ bool V8ToGValue(GValue *gvalue, Local<Value> value, ResourceOwnership ownership)
     } else if (G_VALUE_HOLDS_UINT (gvalue)) {
         g_value_set_uint (gvalue, Nan::To<uint32_t> (value).ToChecked());
     } else if (G_VALUE_HOLDS_LONG (gvalue)) {
-        g_value_set_long (gvalue, Nan::To<int64_t> (value).ToChecked());
+        g_value_set_long (gvalue, V8ToInt64 (value));
     } else if (G_VALUE_HOLDS_ULONG (gvalue)) {
-        g_value_set_ulong (gvalue, Nan::To<uint32_t> (value).ToChecked());
+        g_value_set_ulong (gvalue, V8ToUint64 (value));
     } else if (G_VALUE_HOLDS_INT64 (gvalue)) {
-        g_value_set_int64 (gvalue, Nan::To<int64_t> (value).ToChecked());
+        g_value_set_int64 (gvalue, V8ToInt64 (value));
     } else if (G_VALUE_HOLDS_UINT64 (gvalue)) {
-        g_value_set_uint64 (gvalue, Nan::To<uint32_t> (value).ToChecked());
+        g_value_set_uint64 (gvalue, V8ToUint64 (value));
     } else if (G_VALUE_HOLDS_FLOAT (gvalue)) {
         g_value_set_float (gvalue, Nan::To<double> (value).ToChecked());
     } else if (G_VALUE_HOLDS_DOUBLE (gvalue)) {
         g_value_set_double (gvalue, Nan::To<double> (value).ToChecked());
     } else if (G_VALUE_HOLDS_GTYPE (gvalue)) {
-        g_value_set_gtype (gvalue, Nan::To<int64_t> (value).ToChecked());
+        g_value_set_gtype (gvalue, V8ToUint64 (value));
     } else if (G_VALUE_HOLDS_ENUM (gvalue)) {
         g_value_set_enum (gvalue, Nan::To<int32_t> (value).ToChecked());
     } else if (G_VALUE_HOLDS_FLAGS (gvalue)) {
@@ -1482,6 +1791,16 @@ bool V8ToGValue(GValue *gvalue, Local<Value> value, ResourceOwnership ownership)
             return false;
         }
         g_value_set_object (gvalue, GObjectFromWrapper (value));
+    } else if (G_VALUE_HOLDS (gvalue, G_TYPE_STRV)) {
+        // GStrv is a boxed type, so this must come before G_VALUE_HOLDS_BOXED.
+        Local<Array> array = Local<Array>::Cast(TO_OBJECT (value));
+        int length = array->Length();
+        char **strv = g_new0 (char *, length + 1);
+        for (int i = 0; i < length; i++) {
+            Nan::Utf8String element (Nan::Get(array, i).ToLocalChecked());
+            strv[i] = g_strdup (*element);
+        }
+        g_value_take_boxed (gvalue, strv);
     } else if (G_VALUE_HOLDS_BOXED (gvalue)) {
         if (!ValueIsInstanceOfGType(value, G_VALUE_TYPE (gvalue))) {
             Throw::CannotConvertGType("boxed", G_VALUE_TYPE (gvalue));
@@ -1521,19 +1840,23 @@ Local<Value> GValueToV8(const GValue *gvalue, ResourceOwnership ownership) {
     } else if (G_VALUE_HOLDS_UINT (gvalue)) {
         return New<v8::Uint32>(g_value_get_uint (gvalue));
     } else if (G_VALUE_HOLDS_LONG (gvalue)) {
-        return New<Number>(g_value_get_long (gvalue));
+        /* glong/gulong are platform-dependent (64-bit on LP64), so marshal as
+         * BigInt for full precision and consistent behavior (#323, #149). */
+        return v8::BigInt::New(Isolate::GetCurrent(), g_value_get_long (gvalue));
     } else if (G_VALUE_HOLDS_ULONG (gvalue)) {
-        return New<Number>(g_value_get_ulong (gvalue));
+        return v8::BigInt::NewFromUnsigned(Isolate::GetCurrent(), g_value_get_ulong (gvalue));
     } else if (G_VALUE_HOLDS_INT64 (gvalue)) {
-        return New<Number>(g_value_get_int64 (gvalue));
+        return v8::BigInt::New(Isolate::GetCurrent(), g_value_get_int64 (gvalue));
     } else if (G_VALUE_HOLDS_UINT64 (gvalue)) {
-        return New<Number>(g_value_get_uint64 (gvalue));
+        return v8::BigInt::NewFromUnsigned(Isolate::GetCurrent(), g_value_get_uint64 (gvalue));
     } else if (G_VALUE_HOLDS_FLOAT (gvalue)) {
         return New<Number>(g_value_get_float (gvalue));
     } else if (G_VALUE_HOLDS_DOUBLE (gvalue)) {
         return New<Number>(g_value_get_double (gvalue));
     } else if (G_VALUE_HOLDS_GTYPE (gvalue)) {
-        return New<Number>(g_value_get_gtype (gvalue));
+        // A GType is a gsize; marshal as BigInt to match the GIArgument path
+        // and gi.getGType() (#323, #149).
+        return v8::BigInt::NewFromUnsigned(Isolate::GetCurrent(), g_value_get_gtype (gvalue));
     } else if (G_VALUE_HOLDS_ENUM (gvalue)) {
         return New<Integer>(g_value_get_enum (gvalue));
     } else if (G_VALUE_HOLDS_FLAGS (gvalue)) {
@@ -1548,6 +1871,15 @@ Local<Value> GValueToV8(const GValue *gvalue, ResourceOwnership ownership) {
             return Nan::EmptyString();
     } else if (G_VALUE_HOLDS_OBJECT (gvalue)) {
         return WrapperFromGObject (G_OBJECT (g_value_get_object (gvalue)));
+    } else if (G_VALUE_HOLDS (gvalue, G_TYPE_STRV)) {
+        // GStrv is a boxed type, so this must come before G_VALUE_HOLDS_BOXED.
+        char **strv = (char **) g_value_get_boxed (gvalue);
+        Local<Array> array = Nan::New<Array>();
+        if (strv != NULL) {
+            for (guint i = 0; strv[i] != NULL; i++)
+                Nan::Set(array, i, New<String>(strv[i]).ToLocalChecked());
+        }
+        return array;
     } else if (G_VALUE_HOLDS_BOXED (gvalue)) {
         GType gtype = G_VALUE_TYPE (gvalue);
         GIBaseInfo *info = g_irepository_find_by_gtype(NULL, gtype);
@@ -1566,7 +1898,13 @@ Local<Value> GValueToV8(const GValue *gvalue, ResourceOwnership ownership) {
     } else if (G_VALUE_HOLDS_VARIANT (gvalue)) {
         ERROR("Unsuported type: variant");
     } else {
-        ERROR("%s", G_VALUE_TYPE_NAME(gvalue));
+        // Don't abort the whole process on a GValue type we can't convert
+        // (e.g. GStreamer's GstValueArray / GstValueList, #389). Warn and
+        // return null so the caller stays alive.
+        g_warning("GValueToV8: unhandled GValue type '%s'; returning null. "
+                  "Please report this at https://github.com/romgrk/node-gtk/issues",
+                  G_VALUE_TYPE_NAME (gvalue));
+        return Nan::Null();
     }
 }
 

package/src/value.h

@@ -30,6 +30,28 @@ bool         V8ToGIArgument (GITypeInfo *type_info, GIArgument *argument, Local<
 bool         V8ToOutGIArgument(GITypeInfo *type_info, GIArgument *arg, Local<Value> value, bool may_be_null);
 void         FreeGIArgument (GITypeInfo *type_info, GIArgument *argument, GITransfer transfer = GI_TRANSFER_EVERYTHING, GIDirection direction = GI_DIRECTION_OUT);
 void         FreeGIArgumentArray (GITypeInfo *type_info, GIArgument *arg, GITransfer transfer = GI_TRANSFER_EVERYTHING, GIDirection direction = GI_DIRECTION_OUT, long length = -1);
+
+// For a transfer-container IN GList/GSList/GHashTable, the callee frees the
+// container structure itself, so node-gtk cannot walk it afterwards to free
+// the (caller-owned) elements. These capture the element pointers *before*
+// the call so they can be freed *after* it. See #399.
+bool         IsTransferContainerInList (GITypeInfo *type_info, GITransfer transfer, GIDirection direction);
+gpointer     CaptureTransferContainerElements (GITypeInfo *type_info, gpointer container);
+void         FreeTransferContainerElements (GITypeInfo *type_info, gpointer captured);
+
+// For a transfer-full IN boxed argument (or a C array of boxed pointers) the
+// callee frees the passed memory, but the JS wrapper still owns its own copy,
+// which would then be double-freed when the wrapper is finalized. Replace each
+// such pointer with a g_boxed_copy so only the copy is handed to the callee.
+// See #409.
+void         CopyBoxedForTransferFullIn (GITypeInfo *type_info, GIArgument *arg, long length);
+
+// For a transfer-full IN GObject argument the callee takes ownership of one
+// reference. node-gtk only holds a toggle ref on the wrapper, so add the
+// reference the callee expects — otherwise the object is finalized out from
+// under the callee once the wrapper is GC'd. See #439.
+void         RefObjectForTransferFullIn (GITypeInfo *type_info, GIArgument *arg);
+
 bool         CanConvertV8ToGIArgument (GITypeInfo *type_info, Local<Value> value, bool may_be_null);
 
 bool         V8ToGValue(GValue *gvalue, Local<Value> value, ResourceOwnership ownership = kNone);