node-gtk 0.10.0 → 0.12.0

package/src/value.cc

@@ -68,8 +68,8 @@ Local<Value> GIArgumentToV8(GITypeInfo *type_info, GIArgument *arg, long length,
     case GI_TYPE_TAG_UINT64:
         return New<Number> (arg->v_uint64);
 
-    case GI_TYPE_TAG_GTYPE: /* c++: gulong */
-        return v8::BigInt::NewFromUnsigned(Isolate::GetCurrent(), arg->v_ulong);
+    case GI_TYPE_TAG_GTYPE: /* c++: gsize */
+        return v8::BigInt::NewFromUnsigned(Isolate::GetCurrent(), arg->v_size);
 
     case GI_TYPE_TAG_UNICHAR:
         {
@@ -238,6 +238,55 @@ Local<Value> GErrorToV8 (GITypeInfo *type_info, GError *err) {
     return obj;
 }
 
+template<typename T>
+static bool isZero(void* value) {
+    return *(reinterpret_cast<T*>(value)) == 0;
+}
+
+static bool isZero(GIArgument &value, GITypeInfo *type_info) {
+    GITypeTag type_tag = g_type_info_get_tag (type_info);
+
+    switch (type_tag) {
+        case GI_TYPE_TAG_BOOLEAN:
+            ERROR("Boolean zero-terminated array not supported");
+            return false;
+        case GI_TYPE_TAG_INT8:
+            return isZero<gint8>(&value);
+        case GI_TYPE_TAG_UINT8:
+            return isZero<guint8>(&value);
+        case GI_TYPE_TAG_INT16:
+            return isZero<gint16>(&value);
+        case GI_TYPE_TAG_UINT16:
+            return isZero<guint16>(&value);
+        case GI_TYPE_TAG_INT32:
+            return isZero<gint32>(&value);
+        case GI_TYPE_TAG_UINT32:
+            return isZero<guint32>(&value);
+        case GI_TYPE_TAG_INT64:
+            return isZero<gint64>(&value);
+        case GI_TYPE_TAG_UINT64:
+            return isZero<guint64>(&value);
+        case GI_TYPE_TAG_FLOAT:
+            return isZero<float>(&value);
+        case GI_TYPE_TAG_DOUBLE:
+            return isZero<double>(&value);
+        case GI_TYPE_TAG_UNICHAR:
+            return isZero<gunichar>(&value);
+
+        case GI_TYPE_TAG_GTYPE:
+        case GI_TYPE_TAG_INTERFACE:
+        case GI_TYPE_TAG_ARRAY:
+        case GI_TYPE_TAG_VOID:
+        case GI_TYPE_TAG_UTF8:
+        case GI_TYPE_TAG_FILENAME:
+        case GI_TYPE_TAG_GLIST:
+        case GI_TYPE_TAG_GSLIST:
+        case GI_TYPE_TAG_GHASH:
+        case GI_TYPE_TAG_ERROR:
+            return isZero<gpointer>(&value);
+    }
+}
+
 Local<Value> ArrayToV8 (GITypeInfo *type_info, void* data, long length) {
 
     auto array = New<Array>();
@@ -253,20 +302,15 @@ Local<Value> ArrayToV8 (GITypeInfo *type_info, void* data, long length) {
     switch (array_type) {
         case GI_ARRAY_TYPE_C:
             {
-                if (length == -1) {
-                    if (g_type_info_is_zero_terminated (type_info)) {
-                        length = g_strv_length ((gchar **)data);
-                    }
-                    else {
-                        length = g_type_info_get_array_fixed_size (type_info);
-                        if (G_UNLIKELY (length == -1)) {
-                            g_critical ("Unable to determine array length for %p", data);
-                            length = 0;
-                            break;
-                        }
+                if (length == -1 && !g_type_info_is_zero_terminated (type_info)) {
+                    length = g_type_info_get_array_fixed_size (type_info);
+                    if (G_UNLIKELY (length == -1)) {
+                        g_critical ("Unable to determine array length for %p", data);
+                        length = 0;
+                        break;
                     }
                 }
-                g_assert (length >= 0);
+                // length remains -1 for zero-terminated array.
                 break;
             }
         case GI_ARRAY_TYPE_ARRAY:
@@ -301,9 +345,16 @@ Local<Value> ArrayToV8 (GITypeInfo *type_info, void* data, long length) {
 
     GIArgument value;
 
-    for (int i = 0; i < length; i++) {
-        void** pointer = (void**)((ulong)data + i * item_size);
+    for (int i = 0; ; i++) {
+        if (length != -1 && i >= length)
+            break;
+
+        void** pointer = (void**)((size_t)data + i * item_size);
         memcpy(&value, pointer, item_size);
+
+        if (length == -1 && isZero(value, item_type_info))
+            break;
+
         Nan::Set(array, i, GIArgumentToV8(item_type_info, &value));
     }
 
@@ -407,7 +458,7 @@ 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);
 
-    void *result = malloc(element_size * (length + (isZeroTerminated ? 1 : 0)));
+    void *result = g_malloc0(element_size * (length + (isZeroTerminated ? 1 : 0)));
 
     for (int i = 0; i < length; i++) {
         auto value = Nan::Get(array, i).ToLocalChecked();
@@ -415,7 +466,7 @@ static void *V8ArrayToCArray(GITypeInfo *type_info, Local<Value> value) {
         GIArgument arg;
 
         if (V8ToGIArgument(element_info, &arg, value, true)) {
-            void* pointer = (void*)((ulong)result + i * element_size);
+            void* pointer = (void*)((size_t)result + i * element_size);
             memcpy(pointer, &arg, element_size);
         } else {
             WARN("couldnt convert value: %s", *Nan::Utf8String(TO_STRING (value)));
@@ -423,7 +474,10 @@ static void *V8ArrayToCArray(GITypeInfo *type_info, Local<Value> value) {
     }
 
     if (isZeroTerminated) {
-        void* pointer = (void*)((ulong)result + length * element_size);
+        // TODO:
+        // Since g_malloc0 above already zeros the memory
+        // it's better to assert the last element is zero
+        void* pointer = (void*)((size_t)result + length * element_size);
         memset(pointer, 0, element_size);
     }
 
@@ -439,12 +493,15 @@ static void *V8TypedArrayToCArray(GITypeInfo *type_info, Local<Value> value) {
     GITypeInfo* element_info = g_type_info_get_param_type (type_info, 0);
     gsize element_size = GetTypeSize(element_info);
 
-    void *result = malloc(element_size * (length + (isZeroTerminated ? 1 : 0)));
+    void *result = g_malloc0(element_size * (length + (isZeroTerminated ? 1 : 0)));
 
     array->CopyContents(result, length);
 
     if (isZeroTerminated) {
-        void* pointer = (void*)((ulong)result + length * element_size);
+        // TODO:
+        // Since g_malloc0 above already zeros the memory
+        // it's better to assert the last element is zero
+        void* pointer = (void*)((size_t)result + length * element_size);
         memset(pointer, 0, element_size);
     }
 
@@ -597,14 +654,14 @@ gpointer V8ToGHash (GITypeInfo *type_info, Local<Value> value) {
         if (!V8ToGIArgument(key_type_info, &key_arg, key, false)) {
             char* message = g_strdup_printf("Couldn't convert key '%s'", *Nan::Utf8String(key));
             Nan::ThrowError(message);
-            free(message);
+            g_free(message);
             goto item_error;
         }
 
         if (!V8ToGIArgument(value_type_info, &value_arg, value, false)) {
             char* message = g_strdup_printf("Couldn't convert value for key '%s'", *Nan::Utf8String(key));
             Nan::ThrowError(message);
-            free(message);
+            g_free(message);
             goto item_error;
         }
 
@@ -628,6 +685,8 @@ item_error:
 bool V8ToGIArgument(GIBaseInfo *gi_info, GIArgument *arg, Local<Value> value) {
     GIInfoType type = g_base_info_get_type (gi_info);
 
+    memset(arg, 0, sizeof(GIArgument));
+
     switch (type) {
     case GI_INFO_TYPE_BOXED:
     case GI_INFO_TYPE_STRUCT:
@@ -665,6 +724,8 @@ bool V8ToGIArgument(GIBaseInfo *gi_info, GIArgument *arg, Local<Value> value) {
 bool V8ToGIArgument(GITypeInfo *type_info, GIArgument *arg, Local<Value> value, bool may_be_null) {
     GITypeTag type_tag = g_type_info_get_tag (type_info);
 
+    memset(arg, 0, sizeof(GIArgument));
+
     if (value->IsUndefined () || value->IsNull ()) {
         arg->v_pointer = NULL;
 
@@ -697,7 +758,10 @@ bool V8ToGIArgument(GITypeInfo *type_info, GIArgument *arg, Local<Value> value,
         arg->v_int = Nan::To<int32_t> (value).ToChecked();
         break;
     case GI_TYPE_TAG_INT64:
-        arg->v_int64 = Nan::To<int64_t> (value).ToChecked();
+        if (value->IsBigInt())
+            arg->v_int64 = value.As<v8::BigInt>()->Int64Value();
+        else
+            arg->v_int64 = Nan::To<int64_t> (value).ToChecked();
         break;
     case GI_TYPE_TAG_UINT8:
         arg->v_uint8 = Nan::To<uint32_t> (value).ToChecked();
@@ -709,7 +773,10 @@ bool V8ToGIArgument(GITypeInfo *type_info, GIArgument *arg, Local<Value> value,
         arg->v_uint = Nan::To<uint32_t> (value).ToChecked();
         break;
     case GI_TYPE_TAG_UINT64:
-        arg->v_uint64 = Nan::To<int64_t> (value).ToChecked();
+        if (value->IsBigInt())
+            arg->v_uint64 = value.As<v8::BigInt>()->Uint64Value();
+        else
+            arg->v_uint64 = Nan::To<int64_t> (value).ToChecked();
         break;
     case GI_TYPE_TAG_FLOAT:
         arg->v_float = Nan::To<double> (value).ToChecked();
@@ -719,9 +786,9 @@ bool V8ToGIArgument(GITypeInfo *type_info, GIArgument *arg, Local<Value> value,
         break;
     case GI_TYPE_TAG_GTYPE:
         if (value->IsBigInt())
-            arg->v_ulong = value.As<v8::BigInt>()->Uint64Value();
+            arg->v_size = value.As<v8::BigInt>()->Uint64Value();
         else
-            arg->v_ulong = Nan::To<int64_t> (value).ToChecked();
+            arg->v_size = Nan::To<int64_t> (value).ToChecked();
         break;
 
     case GI_TYPE_TAG_UTF8:
@@ -835,7 +902,10 @@ bool V8ToOutGIArgument(GITypeInfo *type_info, GIArgument *arg, Local<Value> valu
         *(gint*)arg->v_pointer = Nan::To<int32_t> (value).ToChecked();
         break;
     case GI_TYPE_TAG_INT64:
-        *(gint64*)arg->v_pointer = Nan::To<int64_t> (value).ToChecked();
+        if (value->IsBigInt())
+            *(gint64*)arg->v_pointer = value.As<v8::BigInt>()->Int64Value();
+        else
+            *(gint64*)arg->v_pointer = Nan::To<int64_t> (value).ToChecked();
         break;
     case GI_TYPE_TAG_UINT8:
         *(guint8*)arg->v_pointer = Nan::To<uint32_t> (value).ToChecked();
@@ -847,7 +917,10 @@ bool V8ToOutGIArgument(GITypeInfo *type_info, GIArgument *arg, Local<Value> valu
         *(guint*)arg->v_pointer = Nan::To<uint32_t> (value).ToChecked();
         break;
     case GI_TYPE_TAG_UINT64:
-        *(guint64*)arg->v_pointer = Nan::To<int64_t> (value).ToChecked();
+        if (value->IsBigInt())
+            *(guint64*)arg->v_pointer = value.As<v8::BigInt>()->Uint64Value();
+        else
+            *(guint64*)arg->v_pointer = Nan::To<int64_t> (value).ToChecked();
         break;
     case GI_TYPE_TAG_FLOAT:
         *(gfloat*)arg->v_pointer = Nan::To<double> (value).ToChecked();
@@ -857,9 +930,9 @@ bool V8ToOutGIArgument(GITypeInfo *type_info, GIArgument *arg, Local<Value> valu
         break;
     case GI_TYPE_TAG_GTYPE:
         if (value->IsBigInt())
-            *(gulong*)arg->v_pointer = value.As<v8::BigInt>()->Uint64Value();
+            *(gsize*)arg->v_pointer = value.As<v8::BigInt>()->Uint64Value();
         else
-            *(gulong*)arg->v_pointer = Nan::To<int64_t> (value).ToChecked();
+            *(gsize*)arg->v_pointer = Nan::To<int64_t> (value).ToChecked();
         break;
 
     case GI_TYPE_TAG_UTF8:
@@ -913,15 +986,15 @@ bool CanConvertV8ToGIArgument(GITypeInfo *type_info, Local<Value> value, bool ma
     case GI_TYPE_TAG_INT8:
     case GI_TYPE_TAG_INT16:
     case GI_TYPE_TAG_INT32:
-    case GI_TYPE_TAG_INT64:
     case GI_TYPE_TAG_UINT8:
     case GI_TYPE_TAG_UINT16:
     case GI_TYPE_TAG_UINT32:
-    case GI_TYPE_TAG_UINT64:
     case GI_TYPE_TAG_FLOAT:
     case GI_TYPE_TAG_DOUBLE:
         return value->IsNumber ();
 
+    case GI_TYPE_TAG_INT64:
+    case GI_TYPE_TAG_UINT64:
     case GI_TYPE_TAG_GTYPE:
         return value->IsNumber () || value->IsBigInt ();
 
@@ -1251,7 +1324,7 @@ void FreeGIArgumentArray(GITypeInfo *type_info, GIArgument *arg, GITransfer tran
 
         for (int i = 0; i < length; i++) {
             GIArgument item;
-            memcpy (&item, (void*)((ulong)data + element_size * i), sizeof (GIArgument));
+            memcpy (&item, (void*)((size_t)data + element_size * i), sizeof (GIArgument));
             FreeGIArgument (element_info, &item, item_transfer, direction);
         }
 
@@ -1270,7 +1343,7 @@ void FreeGIArgumentArray(GITypeInfo *type_info, GIArgument *arg, GITransfer tran
     switch (array_type) {
         case GI_ARRAY_TYPE_C:
             {
-                free(data);
+                g_free (data);
                 break;
             }
         case GI_ARRAY_TYPE_ARRAY:

package/src/value.h

@@ -26,7 +26,7 @@ void         FreeGIArgument (GITypeInfo *type_info, GIArgument *argument, GITran
 void         FreeGIArgumentArray (GITypeInfo *type_info, GIArgument *arg, GITransfer transfer = GI_TRANSFER_EVERYTHING, GIDirection direction = GI_DIRECTION_OUT, long length = -1);
 bool         CanConvertV8ToGIArgument (GITypeInfo *type_info, Local<Value> value, bool may_be_null);
 
-bool         V8ToGValue(GValue *gvalue, Local<Value> value, bool mustCopy = false) __attribute__((warn_unused_result));
+bool         V8ToGValue(GValue *gvalue, Local<Value> value, bool mustCopy = false);
 Local<Value> GValueToV8(const GValue *gvalue, bool mustCopy = false);
 bool         CanConvertV8ToGValue(GValue *gvalue, Local<Value> value);