glib2 3.2.1-x64-mingw32 → 3.2.2-x64-mingw32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3ad2bb40467fdb746b57e896811337537e43d9e8
-  data.tar.gz: 9a4cdc46a388b198018e9537aa83a5c92a62871a
+SHA256:
+  metadata.gz: a30cb5cdb6ea56a83411b1153ec6aa3c040bfc8a82ef96de5712f25e78b12d59
+  data.tar.gz: e12becec0b227d8eee635547e871d02bc8fdd3e2c30f30fea1514b074be63f5d
 SHA512:
-  metadata.gz: ca0a38bd38bdeb88317fc229b2c8ad97f70d99c6c8561a37f3452ae21b8aa0ece16671c25d130a258111f493757e1cde8715f8675ad5e4a163c324e865565a11
-  data.tar.gz: d0453b3f0470d6e961d3ae45d8f9d773869edf2a7a2e5073d9530ef1b6c9b786b2e43b889e0ef053d800a711dbebcde8635d8c12273c05533c4e6aa1e00b3fa6
+  metadata.gz: 5badafc5c3affb7fc15edd91abe8bca23874e8c93620369587892efb5cb468a726cf9e1dbf09862b08134c79352af652282fa92bf74af52e9b039b7f1fe45683
+  data.tar.gz: f5c0443f32e8162a2670b3c136a7d1b1c1f5dec99868cd0bb01d265baf6015f146e883ba944520a33d91ba38fb6908aba041a1e8170abb7fddf1c1085a4d5dd5

data/Rakefile

@@ -1,6 +1,6 @@
 # -*- ruby -*-
 #
-# Copyright (C) 2011-2017  Ruby-GNOME2 Project Team
+# Copyright (C) 2011-2018  Ruby-GNOME2 Project Team
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -88,12 +88,13 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib",
       :download_site => :gnome,
       :label => "GLib",
-      :version => "2.54.1",
+      :version => "2.56.0",
       :compression_method => "xz",
       :windows => {
         :need_autoreconf => true,
         :patches => [
           "glib-2.54.1-add-missing-exeext.diff",
+          "glib-2.56.0-add-missing-weekday-full-is-locale.patch",
         ],
         :built_file => "bin/libglib-2.0-0.dll",
       },
@@ -126,25 +127,26 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "libtasn1",
       :download_site => :gnu,
       :label => "Libtasn1",
-      :version => "4.12",
+      :version => "4.13",
       :windows => {
         :built_file => "bin/libtasn1-6.dll",
       },
     },
     {
-      :name => "libidn",
+      :name => "libidn2",
       :download_site => :gnu,
-      :label => "Libidn",
-      :version => "1.33",
+      :download_name => "libidn",
+      :label => "Libidn2",
+      :version => "2.0.4",
       :windows => {
-        :built_file => "bin/libidn-11.dll",
+        :built_file => "bin/libidn2-0.dll",
       },
     },
     {
-      :name => "p11-kit",
-      :download_base_url => "https://p11-glue.freedesktop.org/releases",
+      :name => "p11-glue/p11-kit",
+      :download_site => :github,
       :label => "p11-kit",
-      :version => "0.23.2",
+      :version => "0.23.3",
       :windows => {
         :built_file => "bin/libp11-kit-0.dll",
       },
@@ -171,13 +173,12 @@ package_task = GNOME2::Rake::PackageTask.new do |package|
       :name => "glib-networking",
       :download_site => :gnome,
       :label => "glib-networking",
-      :version => "2.54.0",
+      :version => "2.56.0",
       :compression_method => "xz",
       :windows => {
-        :configure_args => [
-          "--without-libproxy",
-          "--without-gnome-proxy",
-          "--without-ca-certificates",
+        :meson_args => [
+          "-Dlibproxy_support=false",
+          "-Dgnome_proxy_support=false",
         ],
         :built_file => "lib/gio/modules/libgiognutls.dll",
       },

data/ext/glib2/glib2.def

@@ -39,6 +39,9 @@ EXPORTS
 	rbgobj_rvalue_to_gvalue
 	rbgobj_initialize_gvalue
 	rbgobj_initialize_object
+	rbgobj_class_info_lookup
+	rbgobj_class_info_lookup_by_gtype
+	rbgobj_class_info_define
 	rbgobj_lookup_class
 	rbgobj_lookup_class_by_gtype
 	rbgobj_gtype_to_ruby_class

data/ext/glib2/rbglib-bytes.c

@@ -66,6 +66,7 @@ rg_to_s(VALUE self)
 #  else
     rb_data = rb_enc_str_new(data, size, rb_ascii8bit_encoding());
 #  endif
+    rb_obj_freeze(rb_data);
     return rb_data;
 }
 

data/ext/glib2/rbglib.h

@@ -36,7 +36,7 @@ extern "C" {
 
 #define RBGLIB_MAJOR_VERSION 3
 #define RBGLIB_MINOR_VERSION 2
-#define RBGLIB_MICRO_VERSION 1
+#define RBGLIB_MICRO_VERSION 2
 
 #ifndef RB_ZALLOC
 #  ifdef ZALLOC
@@ -46,6 +46,10 @@ extern "C" {
 #  endif
 #endif
 
+#ifndef RB_ALLOC_N
+#  define RB_ALLOC_N(type, n) ALLOC_N(type, n)
+#endif
+
 /* For Ruby < 2.3 */
 #ifndef RB_OBJ_FROZEN
 #  define RB_OBJ_FROZEN(obj) OBJ_FROZEN(obj)

data/ext/glib2/rbgobj_object.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2011-2017  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2011-2018  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002-2004  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002-2003  Masahiro Sakai
  *  Copyright (C) 1998-2000 Yukihiro Matsumoto,
@@ -58,8 +58,9 @@ holder_mark(gobj_holder *holder)
 }
 
 static void
-holder_unref(gobj_holder *holder)
+holder_unref(void *data)
 {
+    gobj_holder *holder = data;
     if (holder->gobj) {
         if (!holder->destroyed) {
             g_object_set_qdata(holder->gobj, RUBY_GOBJECT_OBJ_KEY, NULL);
@@ -71,19 +72,37 @@ holder_unref(gobj_holder *holder)
 }
 
 static void
-holder_free(gobj_holder *holder)
+holder_free(void *data)
 {
+    gobj_holder *holder = data;
     holder_unref(holder);
     xfree(holder);
 }
 
+static const rb_data_type_t rg_glib_object_type = {
+    "GLib::Object",
+    {
+        holder_mark,
+        holder_free,
+        NULL,
+        NULL,
+        NULL,
+    },
+    NULL,
+    NULL,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
 VALUE
 rbgobj_object_alloc_func(VALUE klass)
 {
     gobj_holder* holder;
     VALUE result;
 
-    result = Data_Make_Struct(klass, gobj_holder, holder_mark, holder_free, holder);
+    result = TypedData_Make_Struct(klass,
+                                   gobj_holder,
+                                   &rg_glib_object_type,
+                                   holder);
     holder->self  = result;
     holder->gobj  = NULL;
     holder->cinfo = NULL;
@@ -105,7 +124,7 @@ rbgobj_gobject_initialize(VALUE obj, gpointer cobj)
     gobj_holder* holder = g_object_get_qdata((GObject*)cobj, RUBY_GOBJECT_OBJ_KEY);
     if (holder)
         rb_raise(rb_eRuntimeError, "ruby wrapper for this GObject* already exists.");
-    Data_Get_Struct(obj, gobj_holder, holder);
+    TypedData_Get_Struct(obj, gobj_holder, &rg_glib_object_type, holder);
     holder->cinfo = RVAL2CINFO(obj);
     holder->gobj  = (GObject*)cobj;
     holder->destroyed = FALSE;
@@ -149,10 +168,7 @@ rbgobj_get_gobject(VALUE obj)
 {
     gobj_holder* holder;
 
-    if (!RVAL2CBOOL(rb_obj_is_kind_of(obj, GTYPE2CLASS(G_TYPE_OBJECT))))
-        rb_raise(rb_eTypeError, "not a GLib::Object");
-
-    Data_Get_Struct(obj, gobj_holder, holder);
+    TypedData_Get_Struct(obj, gobj_holder, &rg_glib_object_type, holder);
 
     if (holder->destroyed)
         rb_raise(rb_eTypeError, "destroyed GLib::Object");
@@ -566,10 +582,7 @@ rg_destroyed_p(VALUE self)
 {
     gobj_holder* holder;
 
-    if (!RVAL2CBOOL(rb_obj_is_kind_of(self, GTYPE2CLASS(G_TYPE_OBJECT))))
-        rb_raise(rb_eTypeError, "not a GLib::Object");
-
-    Data_Get_Struct(self, gobj_holder, holder);
+    TypedData_Get_Struct(self, gobj_holder, &rg_glib_object_type, holder);
 
     return CBOOL2RVAL(holder->destroyed);
 }
@@ -582,7 +595,7 @@ rg_inspect(VALUE self)
     char *s;
     VALUE result;
 
-    Data_Get_Struct(self, gobj_holder, holder);
+    TypedData_Get_Struct(self, gobj_holder, &rg_glib_object_type, holder);
 
     class_name = rb_class2name(CLASS_OF(self));
     if (!holder->destroyed)
@@ -602,7 +615,7 @@ rg_unref(VALUE self)
 {
     gobj_holder* holder;
 
-    Data_Get_Struct(self, gobj_holder, holder);
+    TypedData_Get_Struct(self, gobj_holder, &rg_glib_object_type, holder);
 
     if (holder->destroyed)
         rb_raise(rb_eTypeError, "destroyed GLib::Object");
@@ -780,7 +793,7 @@ static VALUE
 gobj_ref_count(VALUE self)
 {
     gobj_holder* holder;
-    Data_Get_Struct(self, gobj_holder, holder);
+    TypedData_Get_Struct(self, gobj_holder, &rg_glib_object_type, holder);
     return INT2NUM(holder->gobj ? holder->gobj->ref_count : 0);
 }
 
@@ -788,7 +801,7 @@ static VALUE
 rg_floating_p(VALUE self)
 {
     gobj_holder* holder;
-    Data_Get_Struct(self, gobj_holder, holder);
+    TypedData_Get_Struct(self, gobj_holder, &rg_glib_object_type, holder);
     if (holder->gobj) {
         return CBOOL2RVAL(g_object_is_floating(holder->gobj));
     } else {

data/ext/glib2/rbgobj_type.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2002-2017  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2002-2018  Ruby-GNOME2 Project Team
  *  Copyright (C) 2002,2003  Masahiro Sakai
  *
  *  This library is free software; you can redistribute it and/or
@@ -48,133 +48,93 @@ typedef struct {
 } RGObjClassInfoDynamic;
 
 typedef struct {
-    VALUE parent;
     GType gtype;
-    gboolean create_class;
-} RGObjClassByGtypeData;
+    const gchar *name;
+    VALUE module;
+    VALUE parent;
+} RGObjDefineClassData;
 
 static void
-cinfo_mark(RGObjClassInfo* cinfo)
+cinfo_mark(void *data)
 {
+    RGObjClassInfo *cinfo = data;
     rb_gc_mark(cinfo->klass);
 }
 
-const RGObjClassInfo *
-rbgobj_lookup_class(VALUE klass)
+static void
+cinfo_free(void *data)
 {
-    VALUE data = rb_hash_aref(klass_to_cinfo, klass);
-    if (!NIL_P(data)){
-        RGObjClassInfo* cinfo;
-        Data_Get_Struct(data, RGObjClassInfo, cinfo);
-        return cinfo;
-    }
-
-    if (TYPE(klass) == T_CLASS) {
-        VALUE super;
-        super = rb_funcall(klass, id_superclass, 0);
-        return rbgobj_lookup_class(super);
-    }
-
-    rb_raise(rb_eRuntimeError, "can't get gobject class information");
+    RGObjClassInfo *cinfo = data;
+    xfree(cinfo->name);
+    xfree(cinfo->data_type);
 }
 
-static const RGObjClassInfo *rbgobj_lookup_class_by_gtype_without_lock(GType gtype,
-                                                                       VALUE parent,
-                                                                       gboolean create_class);
+static RGObjClassInfo *
+rbgobj_class_info_define_without_lock(GType gtype,
+                                      const gchar *name,
+                                      VALUE module,
+                                      VALUE parent);
 
-static VALUE
-get_superclass(GType gtype)
+static void
+rbgobj_class_info_fill_name(RGObjClassInfo *cinfo)
 {
-    VALUE super_class;
+    VALUE rb_name;
 
-    if (rbgobj_convert_get_superclass(gtype, &super_class))
-        return super_class;
+    if (cinfo->name) {
+        return;
+    }
 
-    switch (gtype) {
-      case G_TYPE_PARAM:
-      case G_TYPE_OBJECT:
-        return cInstantiatable;
-      case G_TYPE_BOXED:
-        return rb_cObject;
-      case G_TYPE_POINTER:
-        return rb_cData;
-      case G_TYPE_ENUM:
-      case G_TYPE_FLAGS:
-        return rb_cObject;
-      default:
-      {
-          GType parent_type;
+    if (!RB_TYPE_P(cinfo->klass, RUBY_T_CLASS)) {
+        return;
+    }
 
-          parent_type = g_type_parent(gtype);
-          if (parent_type == G_TYPE_INVALID) {
-              return cInstantiatable;
-          } else {
-              const RGObjClassInfo *cinfo_super;
-              cinfo_super =
-                  rbgobj_lookup_class_by_gtype_without_lock(parent_type,
-                                                            Qnil,
-                                                            TRUE);
-              return cinfo_super->klass;
-          }
-      }
+    rb_name = rb_funcall(cinfo->klass, rb_intern("name"), 0);
+    if (NIL_P(rb_name)) {
+        return;
     }
+
+    cinfo->name = RB_ALLOC_N(char, RSTRING_LEN(rb_name) + 1);
+    memcpy(cinfo->name, RSTRING_PTR(rb_name), RSTRING_LEN(rb_name));
+    cinfo->name[RSTRING_LEN(rb_name)] = '\0';
+    cinfo->data_type->wrap_struct_name = cinfo->name;
 }
 
-static const RGObjClassInfo *
-rbgobj_lookup_class_by_gtype_without_lock(GType gtype, VALUE parent,
-                                          gboolean create_class)
+static RGObjClassInfo *
+rbgobj_class_info_register_without_lock(GType gtype, VALUE klass)
 {
+    rb_data_type_t *data_type;
+    RGObjClassInfo *cinfo;
     GType fundamental_type;
-    RGObjClassInfo* cinfo;
-    RGObjClassInfoDynamic* cinfod;
-    void* gclass = NULL;
+    RGObjClassInfoDynamic *cinfod;
+    void *gclass = NULL;
     VALUE c;
 
-    if (gtype == G_TYPE_INVALID)
-        return NULL;
-
-    cinfo = g_hash_table_lookup(gtype_to_cinfo, GUINT_TO_POINTER(gtype));
-    if (cinfo)
-        return cinfo;
-
-    if (!create_class)
-        return NULL;
+    data_type = RB_ZALLOC(rb_data_type_t);
+    data_type->function.dmark = cinfo_mark;
+    data_type->function.dfree = cinfo_free;
+    if (RB_TYPE_P(klass, RUBY_T_CLASS)) {
+        VALUE p = RCLASS_SUPER(klass);
+        while (p != rb_cObject) {
+            if (RTYPEDDATA_P(p)) {
+                data_type->parent = RTYPEDDATA_TYPE(p);
+                break;
+            }
+            p = RCLASS_SUPER(p);
+        }
+    }
+    data_type->flags = RUBY_TYPED_FREE_IMMEDIATELY;
 
-    c = Data_Make_Struct(rb_cData, RGObjClassInfo, cinfo_mark, NULL, cinfo);
+    c = TypedData_Make_Struct(rb_cData, RGObjClassInfo, data_type, cinfo);
+    cinfo->klass = klass;
     cinfo->gtype = gtype;
     cinfo->mark  = NULL;
     cinfo->free  = NULL;
     cinfo->flags = 0;
+    cinfo->name = NULL;
+    cinfo->data_type = data_type;
+    rbgobj_class_info_fill_name(cinfo);
 
     fundamental_type = G_TYPE_FUNDAMENTAL(gtype);
-    switch (fundamental_type){
-    case G_TYPE_POINTER:
-    case G_TYPE_BOXED:
-    case G_TYPE_PARAM:
-    case G_TYPE_OBJECT:
-    case G_TYPE_ENUM:
-    case G_TYPE_FLAGS:
-        if (NIL_P(parent)) parent = get_superclass(gtype);
-        cinfo->klass = rb_funcall(rb_cClass, id_new, 1, parent);
-        break;
-
-    case G_TYPE_INTERFACE:
-        cinfo->klass = rb_module_new();
-        break;
-
-    default:
-      if (NIL_P(parent)) parent = get_superclass(gtype);
-      if (NIL_P(parent)) {
-          fprintf(stderr,
-                  "%s: %s's fundamental type %s isn't supported\n",
-                  "rbgobj_lookup_class_by_gtype",
-                  g_type_name(gtype),
-                  g_type_name(fundamental_type));
-          return NULL;
-      }
-      cinfo->klass = rb_funcall(rb_cClass, id_new, 1, parent);
-    }
-
     switch (fundamental_type){
       case G_TYPE_BOXED:
         rb_define_alloc_func(cinfo->klass, rbgobj_boxed_alloc_func);
@@ -217,10 +177,14 @@ rbgobj_lookup_class_by_gtype_without_lock(GType gtype, VALUE parent,
         interfaces = g_type_interfaces(gtype, &n_interfaces);
         for (i = 0; i < n_interfaces; i++){
             const RGObjClassInfo *iface_cinfo;
-            iface_cinfo =
-            rbgobj_lookup_class_by_gtype_without_lock(interfaces[i],
-                                                      Qnil,
-                                                      TRUE);
+            iface_cinfo = rbgobj_class_info_lookup_by_gtype(interfaces[i]);
+            if (!iface_cinfo) {
+                iface_cinfo =
+                    rbgobj_class_info_define_without_lock(interfaces[i],
+                                                          NULL,
+                                                          rb_cObject,
+                                                          Qnil);
+            }
             rb_include_module(cinfo->klass, iface_cinfo->klass);
         }
         g_free(interfaces);
@@ -253,55 +217,198 @@ rbgobj_lookup_class_by_gtype_without_lock(GType gtype, VALUE parent,
 }
 
 static VALUE
-rbgobj_lookup_class_by_gtype_body(VALUE data)
+get_superclass(GType gtype, VALUE module)
+{
+    VALUE super_class;
+
+    if (rbgobj_convert_get_superclass(gtype, &super_class))
+        return super_class;
+
+    switch (gtype) {
+      case G_TYPE_PARAM:
+      case G_TYPE_OBJECT:
+        return cInstantiatable;
+      case G_TYPE_BOXED:
+        return rb_cObject;
+      case G_TYPE_POINTER:
+        return rb_cData;
+      case G_TYPE_ENUM:
+      case G_TYPE_FLAGS:
+        return rb_cObject;
+      default:
+      {
+          GType parent_type;
+
+          parent_type = g_type_parent(gtype);
+          if (parent_type == G_TYPE_INVALID) {
+              return cInstantiatable;
+          } else {
+              const RGObjClassInfo *cinfo_super;
+              cinfo_super = rbgobj_class_info_lookup_by_gtype(parent_type);
+              if (!cinfo_super) {
+                  cinfo_super = rbgobj_class_info_define_without_lock(parent_type,
+                                                                      NULL,
+                                                                      module,
+                                                                      Qnil);
+              }
+              return cinfo_super->klass;
+          }
+      }
+    }
+}
+
+static RGObjClassInfo *
+rbgobj_class_info_define_without_lock(GType gtype,
+                                      const gchar *name,
+                                      VALUE module,
+                                      VALUE parent)
+{
+    GType fundamental_type;
+    VALUE klass;
+
+    fundamental_type = G_TYPE_FUNDAMENTAL(gtype);
+    switch (fundamental_type){
+    case G_TYPE_POINTER:
+    case G_TYPE_BOXED:
+    case G_TYPE_PARAM:
+    case G_TYPE_OBJECT:
+    case G_TYPE_ENUM:
+    case G_TYPE_FLAGS:
+        if (NIL_P(parent)) parent = get_superclass(gtype, module);
+        klass = rb_funcall(rb_cClass, id_new, 1, parent);
+        break;
+
+    case G_TYPE_INTERFACE:
+        klass = rb_module_new();
+        break;
+
+    default:
+      if (NIL_P(parent)) parent = get_superclass(gtype, module);
+      if (NIL_P(parent)) {
+          fprintf(stderr,
+                  "rbgobj_class_info_define: "
+                  "Unsupported fundamental type: <%s>(%s)\n",
+                  g_type_name(fundamental_type),
+                  g_type_name(gtype));
+          return NULL;
+      }
+      klass = rb_funcall(rb_cClass, id_new, 1, parent);
+    }
+
+    if (name) {
+        rb_define_const(module, name, klass);
+    }
+    return rbgobj_class_info_register_without_lock(gtype, klass);
+}
+
+static VALUE
+rbgobj_class_info_define_body(VALUE data)
 {
-    RGObjClassByGtypeData *cdata = (RGObjClassByGtypeData *)data;
+    RGObjDefineClassData *cdata = (RGObjDefineClassData *)data;
     const RGObjClassInfo *cinfo;
 
-    cinfo = rbgobj_lookup_class_by_gtype_without_lock(cdata->gtype,
-                                                      cdata->parent,
-                                                      cdata->create_class);
+    cinfo = rbgobj_class_info_define_without_lock(cdata->gtype,
+                                                  cdata->name,
+                                                  cdata->module,
+                                                  cdata->parent);
     return (VALUE)cinfo;
 }
 
 static VALUE
-rbgobj_lookup_class_by_gtype_ensure(G_GNUC_UNUSED VALUE data)
+rbgobj_class_info_define_ensure(G_GNUC_UNUSED VALUE data)
 {
     rb_funcall(lookup_class_mutex, id_unlock, 0);
     return Qundef;
 }
 
+RGObjClassInfo *
+rbgobj_class_info_define(GType gtype,
+                         const gchar *name,
+                         VALUE module,
+                         VALUE parent)
+{
+    RGObjDefineClassData data;
+
+    data.gtype = gtype;
+    data.name = name;
+    data.module = module;
+    data.parent = parent;
+
+    rb_funcall(lookup_class_mutex, id_lock, 0);
+    return (RGObjClassInfo *)rb_ensure(rbgobj_class_info_define_body,
+                                       (VALUE)&data,
+                                       rbgobj_class_info_define_ensure,
+                                       (VALUE)&data);
+}
+
+/* deprecated */
+const RGObjClassInfo *
+rbgobj_lookup_class(VALUE klass)
+{
+    return rbgobj_class_info_lookup(klass);
+}
+
+const RGObjClassInfo *
+rbgobj_class_info_lookup(VALUE klass)
+{
+    VALUE data = rb_hash_aref(klass_to_cinfo, klass);
+    if (!NIL_P(data)) {
+        RGObjClassInfo *cinfo;
+        if (RTYPEDDATA_P(data)) {
+            TypedData_Get_Struct(data,
+                                 RGObjClassInfo,
+                                 RTYPEDDATA_TYPE(data),
+                                 cinfo);
+        } else {
+            Data_Get_Struct(data, RGObjClassInfo, cinfo);
+        }
+        return cinfo;
+    }
+
+    if (TYPE(klass) == T_CLASS) {
+        VALUE super;
+        super = rb_funcall(klass, id_superclass, 0);
+        return rbgobj_lookup_class(super);
+    }
+
+    rb_raise(rb_eRuntimeError, "can't get gobject class information");
+    return NULL;
+}
+
+const RGObjClassInfo *
+rbgobj_class_info_lookup_by_gtype(GType gtype)
+{
+    if (gtype == G_TYPE_INVALID)
+        return NULL;
+
+    return g_hash_table_lookup(gtype_to_cinfo, GUINT_TO_POINTER(gtype));
+}
+
+/* deprecated */
 const RGObjClassInfo *
 rbgobj_lookup_class_by_gtype(GType gtype, VALUE parent)
 {
     return rbgobj_lookup_class_by_gtype_full(gtype, parent, TRUE);
 }
 
+/* deprecated */
 const RGObjClassInfo *
 rbgobj_lookup_class_by_gtype_full(GType gtype, VALUE parent,
                                   gboolean create_class)
 {
     const RGObjClassInfo *info;
-    RGObjClassByGtypeData data;
 
-    info = rbgobj_lookup_class_by_gtype_without_lock(gtype, parent, FALSE);
-    if (info) {
+    if (gtype == G_TYPE_INVALID)
+        return NULL;
+
+    info = rbgobj_class_info_lookup_by_gtype(gtype);
+    if (info)
         return info;
-    }
 
-    if (!create_class) {
+    if (!create_class)
         return NULL;
-    }
-
-    data.gtype = gtype;
-    data.parent = parent;
-    data.create_class = create_class;
 
-    rb_funcall(lookup_class_mutex, id_lock, 0);
-    return (RGObjClassInfo *)rb_ensure(rbgobj_lookup_class_by_gtype_body,
-                                       (VALUE)&data,
-                                       rbgobj_lookup_class_by_gtype_ensure,
-                                       (VALUE)&data);
+    return rbgobj_class_info_define(gtype, NULL, rb_cObject, parent);
 }
 
 VALUE
@@ -317,14 +424,22 @@ VALUE
 rbgobj_define_class(GType gtype, const gchar *name, VALUE module,
                     RGMarkFunc mark, RGFreeFunc free, VALUE parent)
 {
-    RGObjClassInfo* cinfo;
-    if (gtype == 0)
-        rb_bug("rbgobj_define_class: Invalid gtype [%s]\n", name);
+    RGObjClassInfo *cinfo;
+
+    if (gtype == G_TYPE_INVALID)
+        rb_bug("rbgobj_define_class: Invalid GType: <%s>\n", name);
 
-    cinfo = (RGObjClassInfo*)rbgobj_lookup_class_by_gtype(gtype, parent);
+    cinfo = (RGObjClassInfo *)rbgobj_class_info_lookup_by_gtype(gtype);
+    if (cinfo) {
+        if (!rb_const_defined(module, rb_intern(name))) {
+            rb_define_const(module, name, cinfo->klass);
+            rbgobj_class_info_fill_name(cinfo);
+        }
+    } else {
+        cinfo = rbgobj_class_info_define(gtype, name, module, parent);
+    }
     cinfo->mark = mark;
     cinfo->free = free;
-    rb_define_const(module, name, cinfo->klass);
     return cinfo->klass;
 }
 
@@ -381,8 +496,9 @@ rbgobj_register_class(VALUE klass,
     RGObjClassInfo* cinfo = NULL;
     VALUE c = Qnil;
 
-    if (klass2gtype)
+    if (klass2gtype) {
         c = Data_Make_Struct(rb_cData, RGObjClassInfo, cinfo_mark, NULL, cinfo);
+    }
     if (gtype2klass && !cinfo)
         cinfo = g_new(RGObjClassInfo, 1);