pycall 1.5.2 → 1.5.4

data/ext/pycall/pycall.c

@@ -10,28 +10,58 @@ VALUE mLibPython;
 VALUE mAPI;
 VALUE mHelpers;
 VALUE mConversion;
-VALUE mPyObjectWrapper;
-VALUE mPyTypeObjectWrapper;
 VALUE mGCGuard;
 
 VALUE pycall_cPyPtr;
 VALUE cPyTypePtr;
-VALUE cTuple;
-VALUE cPyError;
 
-VALUE pycall_eError;
-
-static VALUE pycall_libpython_handle;
 static VALUE python_description;
 static VALUE python_version_string;
 static Py_ssize_t python_hexversion;
 static int python_major_version;
 static int python_has_stackless_extension;
 static PyObject *python_builtins_module;
-static VALUE python_type_mapping;
-static VALUE python_type_mapping;
 static ID id_python_type_mapping;
 
+/* Don't keep Ruby objects that aren't pinned in C global variables.
+ * They may be moved by GC compaction. */
+
+static inline VALUE
+libpython_handle(void)
+{
+  return rb_funcall(mLibPython, rb_intern("handle"), 0);
+}
+
+static inline VALUE
+pyobject_wrapper_module(void)
+{
+  return rb_const_get_at(mPyCall, rb_intern("PyObjectWrapper"));
+}
+
+static inline VALUE
+pytypeobject_wrapper_module(void)
+{
+  return rb_const_get_at(mPyCall, rb_intern("PyTypeObjectWrapper"));
+}
+
+static inline VALUE
+error_class(void)
+{
+  return rb_const_get_at(mPyCall, rb_intern("Error"));
+}
+
+static inline VALUE
+pyerror_class(void)
+{
+  return rb_const_get_at(mPyCall, rb_intern("PyError"));
+}
+
+static inline VALUE
+python_type_mapping(void)
+{
+  return rb_ivar_get(mConversion, id_python_type_mapping);
+}
+
 int
 pycall_python_major_version(void)
 {
@@ -122,6 +152,58 @@ pycall_m_without_gvl(VALUE mod)
 
 /* ==== PyCall::PyPtr ==== */
 
+struct pending_decref_list {
+  rb_nativethread_lock_t lock;
+  PyObject **pyptrs;
+  size_t count;
+  size_t capacity;
+};
+
+static struct pending_decref_list pending_decrefs;
+
+static void
+pycall_pending_decref_add(PyObject *pyobj)
+{
+  rb_nativethread_lock_lock(&pending_decrefs.lock);
+  if (pending_decrefs.count == pending_decrefs.capacity) {
+    size_t new_capacity = pending_decrefs.capacity ? 2 * pending_decrefs.capacity : 64;
+    /* Not ruby_xrealloc: this function runs during GC, where xmalloc/xrealloc
+     * are prohibited (rb_bug "Cannot realloc during GC" since Ruby 3.3). */
+    PyObject **new_pyptrs = realloc(pending_decrefs.pyptrs, new_capacity * sizeof(PyObject *));
+    if (new_pyptrs == NULL) {
+      /* Leaking the object is preferable to blocking or crashing inside GC */
+      rb_nativethread_lock_unlock(&pending_decrefs.lock);
+      return;
+    }
+    pending_decrefs.pyptrs = new_pyptrs;
+    pending_decrefs.capacity = new_capacity;
+  }
+  pending_decrefs.pyptrs[pending_decrefs.count++] = pyobj;
+  rb_nativethread_lock_unlock(&pending_decrefs.lock);
+}
+
+static void
+pycall_drain_pending_decrefs(void)
+{
+  PyObject **pyptrs;
+  size_t i, count;
+
+  if (pending_decrefs.count == 0) return;
+
+  rb_nativethread_lock_lock(&pending_decrefs.lock);
+  pyptrs = pending_decrefs.pyptrs;
+  count = pending_decrefs.count;
+  pending_decrefs.pyptrs = NULL;
+  pending_decrefs.count = 0;
+  pending_decrefs.capacity = 0;
+  rb_nativethread_lock_unlock(&pending_decrefs.lock);
+
+  for (i = 0; i < count; ++i) {
+    pycall_Py_DecRef(pyptrs[i]);
+  }
+  free(pyptrs);
+}
+
 const rb_data_type_t pycall_pyptr_data_type = {
   "PyCall::PyPtr",
   { 0, pycall_pyptr_free, pycall_pyptr_memsize, },
@@ -130,6 +212,11 @@ const rb_data_type_t pycall_pyptr_data_type = {
 #endif
 };
 
+/* pycall_pyptr_free may be called by the GC sweeper on a thread that does
+ * not hold the GIL.  PyCall keeps the GIL held by the thread that
+ * initialized Python for the entire lifetime of the process, so waiting
+ * for the GIL there (PyGILState_Ensure) blocks forever while the sweeper
+ * holds the GVL, freezing every Ruby thread in the process. */
 void
 pycall_pyptr_free(void *ptr)
 {
@@ -144,9 +231,9 @@ pycall_pyptr_free(void *ptr)
     pycall_Py_DecRef(pyobj);
   }
   else {
-    PyGILState_STATE gstate = Py_API(PyGILState_Ensure)();
-    pycall_Py_DecRef(pyobj);
-    Py_API(PyGILState_Release)(gstate);
+    /* Instead of taking the GIL here, enqueue the pointer; the list is
+     * drained on the next Python call. */
+    pycall_pending_decref_add(pyobj);
   }
 }
 
@@ -628,6 +715,8 @@ pycall_libpython_api_PyObject_Dir(VALUE mod, VALUE pyptr)
   PyObject *dir;
   PyObject *pyobj;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -647,6 +736,8 @@ pycall_libpython_api_PyList_Size(VALUE mod, VALUE pyptr)
   PyObject *pyobj;
   Py_ssize_t size;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -667,6 +758,8 @@ pycall_libpython_api_PyList_GetItem(VALUE mod, VALUE pyptr, VALUE idx)
   PyObject *pyobj_item;
   Py_ssize_t i;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -732,6 +825,8 @@ pycall_libpython_helpers_m_import_module(int argc, VALUE *argv, VALUE mod)
   VALUE name, globals, locals, fromlist, level;
   char const *name_cstr;
 
+  pycall_drain_pending_decrefs();
+
   rb_scan_args(argc, argv, "14", &name, &globals, &locals, &fromlist, &level);
 
   if (RB_TYPE_P(name, T_SYMBOL)) {
@@ -784,6 +879,8 @@ pycall_libpython_helpers_m_compare(VALUE mod, VALUE op, VALUE pyptr_a, VALUE pyp
   PyObject *pyobj_a, *pyobj_b, *res;
   int opid;
 
+  pycall_drain_pending_decrefs();
+
   opid = pycall_rich_compare_opid(op);
 
   if (!is_pycall_pyptr(pyptr_a)) {
@@ -838,6 +935,8 @@ pycall_libpython_helpers_m_getattr(int argc, VALUE *argv, VALUE mod)
 {
   VALUE pyptr, name, default_value;
 
+  pycall_drain_pending_decrefs();
+
   if (rb_scan_args(argc, argv, "21", &pyptr, &name, &default_value) == 2) {
     default_value = Qundef;
   }
@@ -859,6 +958,8 @@ pycall_libpython_helpers_m_hasattr_p(VALUE mod, VALUE pyptr, VALUE name)
   PyObject *pyobj;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -878,6 +979,8 @@ pycall_libpython_helpers_m_setattr(VALUE mod, VALUE pyptr, VALUE name, VALUE val
 {
   PyObject *pyobj, *pyval;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -901,6 +1004,8 @@ pycall_libpython_helpers_m_delattr(VALUE mod, VALUE pyptr, VALUE name)
 {
   PyObject *pyobj;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -924,6 +1029,8 @@ pycall_libpython_helpers_m_callable_p(VALUE mod, VALUE pyptr)
   PyObject *pyobj;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -940,6 +1047,8 @@ pycall_libpython_helpers_m_call_object(int argc, VALUE *argv, VALUE mod)
   VALUE pyptr;
   PyObject *pyobj;
 
+  pycall_drain_pending_decrefs();
+
   if (argc < 1) {
     rb_raise(rb_eArgError, "too few arguments (%d for >=1)", argc);
   }
@@ -1089,6 +1198,8 @@ pycall_pyobject_wrapper_wrapper_method(int argc, VALUE *argv, VALUE wrapper)
   char *name_cstr;
   PyObject *pyobj, *attr;
 
+  pycall_drain_pending_decrefs();
+
   pyptr = rb_attr_get(wrapper, rb_intern("@__pyptr__"));
   if (NIL_P(pyptr) || !is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "Wrong wrapper object is given");
@@ -1144,6 +1255,8 @@ pycall_libpython_helpers_m_define_wrapper_method(VALUE mod, VALUE wrapper, VALUE
   PyObject *pyobj, *attr;
   char *name_cstr;
 
+  pycall_drain_pending_decrefs();
+
   pyptr = rb_attr_get(wrapper, rb_intern("@__pyptr__"));
   if (NIL_P(pyptr) || !is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "Wrong wrapper object is given");
@@ -1191,10 +1304,10 @@ pycall_convert_index(VALUE index)
     }
   }
   else if (rb_obj_is_kind_of(index, rb_cRange)) {
-    pyobj = pycall_pyslice_from_ruby(index); /* New refrence */
+    pyobj = pycall_pyslice_from_ruby(index); /* New reference */
   }
   else if (pycall_obj_is_step_range(index)) {
-    pyobj = pycall_pyslice_from_ruby(index); /* New refrence */
+    pyobj = pycall_pyslice_from_ruby(index); /* New reference */
   }
   else {
     pyobj = pycall_pyobject_from_ruby(index); /* New reference */
@@ -1209,6 +1322,8 @@ pycall_libpython_helpers_m_getitem(VALUE mod, VALUE pyptr, VALUE key)
   PyObject *pyobj, *pyobj_key, *pyobj_v;
   VALUE obj;
 
+  pycall_drain_pending_decrefs();
+
   if (!is_pycall_pyptr(pyptr)) {
     rb_raise(rb_eTypeError, "PyCall::PyPtr is required");
   }
@@ -1234,6 +1349,8 @@ pycall_libpython_helpers_m_setitem(VALUE mod, VALUE pyptr, VALUE key, VALUE v)
   PyObject *pyobj, *pyobj_key, *pyobj_value;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, NULL);
   pyobj_key = pycall_convert_index(key);
   pyobj_value = pycall_pyobject_from_ruby(v);
@@ -1254,6 +1371,8 @@ pycall_libpython_helpers_m_delitem(VALUE mod, VALUE pyptr, VALUE key)
   PyObject *pyobj, *pyobj_key;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, NULL);
   pyobj_key = pycall_convert_index(key);
 
@@ -1271,6 +1390,8 @@ pycall_libpython_helpers_m_str(VALUE mod, VALUE pyptr)
 {
   PyObject *pyobj, *pyobj_str;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, NULL);
 
   pyobj_str = Py_API(PyObject_Str)(pyobj);
@@ -1289,6 +1410,8 @@ pycall_libpython_helpers_m_dict_contains(VALUE mod, VALUE pyptr, VALUE key)
   PyObject *pyobj, *pyobj_key;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, Py_API(PyDict_Type));
   pyobj_key = pycall_pyobject_from_ruby(key);
   res = Py_API(PyDict_Contains)(pyobj, pyobj_key);
@@ -1306,6 +1429,8 @@ pycall_libpython_helpers_m_dict_each(VALUE mod, VALUE pyptr)
   PyObject *pyobj, *pyobj_key, *pyobj_value;
   Py_ssize_t pos;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, Py_API(PyDict_Type));
 
   pos = 0;
@@ -1325,6 +1450,8 @@ pycall_libpython_helpers_m_sequence_contains(VALUE mod, VALUE pyptr, VALUE key)
   PyObject *pyobj, *pyobj_key;
   int res;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, NULL);
   if (!Py_API(PySequence_Check)(pyobj))
     rb_raise(rb_eTypeError, "unexpected Python type %s (expected a Python sequence object)", Py_TYPE(pyobj)->tp_name);
@@ -1344,6 +1471,8 @@ pycall_libpython_helpers_m_sequence_each(VALUE mod, VALUE pyptr)
 {
   PyObject *pyobj, *pyobj_iter, *pyobj_item;
 
+  pycall_drain_pending_decrefs();
+
   pyobj = check_get_pyobj_ptr(pyptr, NULL);
   if (!Py_API(PySequence_Check)(pyobj))
     rb_raise(rb_eTypeError, "unexpected Python type %s (expected a Python sequence object)", Py_TYPE(pyobj)->tp_name);
@@ -1372,7 +1501,7 @@ pycall_libpython_helpers_m_sequence_each(VALUE mod, VALUE pyptr)
 static int
 is_pyobject_wrapper(VALUE obj)
 {
-  return RTEST(rb_obj_is_kind_of(obj, mPyObjectWrapper));
+  return RTEST(rb_obj_is_kind_of(obj, pyobject_wrapper_module()));
 }
 
 static VALUE
@@ -1425,7 +1554,7 @@ pycall_python_type_mapping_get_mapped_ancestor_class(VALUE pytypeptr)
   args[0] = pytypeptr;
   args[1] = Qnil;
 
-  rb_hash_foreach(python_type_mapping, get_mapped_ancestor_class_iter, (VALUE)args);
+  rb_hash_foreach(python_type_mapping(), get_mapped_ancestor_class_iter, (VALUE)args);
 
   return args[1];
 }
@@ -1435,7 +1564,7 @@ pycall_python_type_mapping_get_mapped_class(VALUE pytypeptr)
 {
   VALUE mapped;
   (void)check_get_pytypeobj_ptr(pytypeptr);
-  mapped = rb_hash_lookup(python_type_mapping, pytypeptr);
+  mapped = rb_hash_lookup(python_type_mapping(), pytypeptr);
   if (NIL_P(mapped)) {
     mapped = pycall_python_type_mapping_get_mapped_ancestor_class(pytypeptr);
   }
@@ -1446,16 +1575,16 @@ static int
 pycall_python_type_mapping_register(VALUE pytypeptr, VALUE rbcls)
 {
   (void)check_get_pytypeobj_ptr(pytypeptr);
-  if (rb_hash_lookup2(python_type_mapping, pytypeptr, Qundef) != Qundef)
+  if (rb_hash_lookup2(python_type_mapping(), pytypeptr, Qundef) != Qundef)
     return 0;
 
   Check_Type(rbcls, T_CLASS);
-  if (!rb_obj_is_kind_of(rbcls, mPyTypeObjectWrapper)) {
+  if (!rb_obj_is_kind_of(rbcls, pytypeobject_wrapper_module())) {
     rb_raise(rb_eTypeError, "ruby class must be extended by PyCall::PyTypeObjectWrapper");
   }
 
   /* TODO: Shouldn't have to use weak reference? */
-  rb_hash_aset(python_type_mapping, pytypeptr, rbcls);
+  rb_hash_aset(python_type_mapping(), pytypeptr, rbcls);
 
   return 1;
 }
@@ -1464,10 +1593,10 @@ static int
 pycall_python_type_mapping_unregister(VALUE pytypeptr)
 {
   (void)check_get_pytypeobj_ptr(pytypeptr);
-  if (rb_hash_lookup2(python_type_mapping, pytypeptr, Qundef) == Qundef)
+  if (rb_hash_lookup2(python_type_mapping(), pytypeptr, Qundef) == Qundef)
     return 0;
 
-  rb_hash_delete(python_type_mapping, pytypeptr);
+  rb_hash_delete(python_type_mapping(), pytypeptr);
   return 1;
 }
 
@@ -1478,7 +1607,7 @@ pycall_pyobject_wrapper_object_new(VALUE klass, PyObject *pyobj)
 
   obj = rb_obj_alloc(klass);
   rb_ivar_set(obj, rb_intern("@__pyptr__"), pycall_pyptr_new(pyobj));
-  rb_extend_object(obj, mPyObjectWrapper);
+  rb_extend_object(obj, pyobject_wrapper_module());
 
   return obj;
 }
@@ -1528,7 +1657,7 @@ pycall_pyobject_to_ruby(PyObject *pyobj)
   Py_API(Py_IncRef)((PyObject *)pyobj->ob_type);
   cls = pycall_python_type_mapping_get_mapped_class(pycall_pytypeptr_new((PyObject *)pyobj->ob_type));
   if (NIL_P(cls)) {
-    rb_warning("Currentry do not support to convert %s to Ruby object", Py_TYPE(pyobj)->tp_name);
+    rb_warning("Currently do not support to convert %s to Ruby object", Py_TYPE(pyobj)->tp_name);
     return pycall_pyobject_wrapper_object_new(rb_cObject, pyobj);
   }
 
@@ -1663,7 +1792,7 @@ pycall_pylong_to_ruby(PyObject *pyobj)
   }
 #endif
 
-  rb_warning("Currentry do not support to convert multi-precision PyLong number to Ruby object");
+  rb_warning("Currently do not support to convert multi-precision PyLong number to Ruby object");
 
   return Qnil;
 }
@@ -1787,7 +1916,11 @@ pycall_conv_m_unregister_python_type_mapping(VALUE mod, VALUE pytypeptr)
 static VALUE
 pycall_conv_m_from_ruby(VALUE mod, VALUE obj)
 {
-  PyObject *pyobj = pycall_pyobject_from_ruby(obj);
+  PyObject *pyobj;
+
+  pycall_drain_pending_decrefs();
+
+  pyobj = pycall_pyobject_from_ruby(obj);
   if (PyType_Check(pyobj) || PyClass_Check(pyobj))
     return pycall_pytypeptr_new(pyobj);
   if (PyRuby_Check(pyobj))
@@ -1799,7 +1932,11 @@ static VALUE
 pycall_conv_m_to_ruby(VALUE mod, VALUE pyptr)
 {
   VALUE obj, obj_pyptr;
-  PyObject *pyobj = check_get_pyobj_ptr(pyptr, NULL);
+  PyObject *pyobj;
+
+  pycall_drain_pending_decrefs();
+
+  pyobj = check_get_pyobj_ptr(pyptr, NULL);
   obj = obj_pyptr = pycall_pyobject_to_ruby(pyobj);
   if (is_pyobject_wrapper(obj)) {
     obj_pyptr = pycall_pyobject_wrapper_get_pyptr(obj);
@@ -2060,7 +2197,7 @@ pycall_pyerror_new(PyObject *type, PyObject *value, PyObject *traceback)
   init_args[1] = value ? pycall_pyobject_to_ruby(value) : Qnil;
   init_args[2] = traceback ? pycall_pyobject_to_ruby(traceback) : Qnil;
 
-  return rb_class_new_instance(3, init_args, cPyError);
+  return rb_class_new_instance(3, init_args, pyerror_class());
 }
 
 VALUE
@@ -2094,7 +2231,7 @@ pycall_pyerror_fetch_and_raise(char const *format, ...)
   msg = rb_vsprintf(format, args);
   va_end(args);
 
-  rb_exc_raise(rb_exc_new3(eError, msg));
+  rb_exc_raise(rb_exc_new3(error_class(), msg));
 }
 
 unsigned long
@@ -2225,7 +2362,7 @@ init_python(void)
   Py_API(Py_IncRef)((PyObject *)Py_API(PyUnicode_Type));
   rb_define_const(mAPI, "PyUnicode_Type", pycall_pytypeptr_new((PyObject *)Py_API(PyUnicode_Type)));
 
-  pycall_init_exceptions(pycall_libpython_handle);
+  pycall_init_exceptions(libpython_handle());
 }
 
 static VALUE
@@ -2286,6 +2423,7 @@ pycall_pyerror_s_fetch(VALUE klass)
 static void
 init_pyerror(void)
 {
+  VALUE cPyError = pyerror_class();
   rb_define_singleton_method(cPyError, "occurred?", pycall_pyerror_s_occurred_p, 0);
   rb_define_singleton_method(cPyError, "fetch", pycall_pyerror_s_fetch, 0);
 }
@@ -2293,7 +2431,7 @@ init_pyerror(void)
 static void
 init_tuple(void)
 {
-  cTuple = rb_funcall(mPyCall, rb_intern("wrap_class"), 1, pycall_pytypeptr_new((PyObject *)Py_API(PyTuple_Type)));
+  VALUE cTuple = rb_funcall(mPyCall, rb_intern("wrap_class"), 1, pycall_pytypeptr_new((PyObject *)Py_API(PyTuple_Type)));
   rb_define_const(mPyCall, "Tuple", cTuple);
   rb_funcall(cTuple, rb_intern("register_python_type_mapping"), 0);
   rb_define_singleton_method(cTuple, "new", pycall_tuple_s_new, -1);
@@ -2308,11 +2446,7 @@ Init_pycall(void)
   pycall_hash_salt = FIX2LONG(rb_hash(rb_str_new2("PyCall::PyObject")));
 
   mPyCall = rb_define_module("PyCall");
-  mPyObjectWrapper = rb_const_get_at(mPyCall, rb_intern("PyObjectWrapper"));
-  mPyTypeObjectWrapper = rb_const_get_at(mPyCall, rb_intern("PyTypeObjectWrapper"));
   mGCGuard = rb_define_module_under(mPyCall, "GCGuard");
-  eError = rb_const_get_at(mPyCall, rb_intern("Error"));
-  cPyError = rb_const_get_at(mPyCall, rb_intern("PyError"));
 
   /* PyCall */
 
@@ -2321,6 +2455,8 @@ Init_pycall(void)
   pycall_tls_create((pycall_tls_key *)&without_gvl_key);
   rb_define_module_function(mPyCall, "without_gvl", pycall_m_without_gvl, 0);
 
+  rb_nativethread_lock_initialize(&pending_decrefs.lock);
+
   /* PyCall::PyPtr */
 
   cPyPtr = rb_define_class_under(mPyCall, "PyPtr", rb_cBasicObject);
@@ -2362,8 +2498,7 @@ Init_pycall(void)
   /* PyCall::LibPython::API */
 
   mLibPython = rb_define_module_under(mPyCall, "LibPython");
-  pycall_libpython_handle = rb_funcall(mLibPython, rb_intern("handle"), 0);
-  pycall_init_libpython_api_table(pycall_libpython_handle);
+  pycall_init_libpython_api_table(libpython_handle());
 
   mAPI = rb_define_module_under(mLibPython, "API");
 
@@ -2405,9 +2540,8 @@ Init_pycall(void)
   rb_define_module_function(mConversion, "from_ruby", pycall_conv_m_from_ruby, 1);
   rb_define_module_function(mConversion, "to_ruby", pycall_conv_m_to_ruby, 1);
 
-  python_type_mapping = rb_hash_new();
   id_python_type_mapping = rb_intern("__python_type_mapping__");
-  rb_ivar_set(mConversion, id_python_type_mapping, python_type_mapping);
+  rb_ivar_set(mConversion, id_python_type_mapping, rb_hash_new());
 
   /* initialize the constat PYTHON_VERSION */
 

data/ext/pycall/pycall_internal.h

@@ -11,6 +11,7 @@ extern "C" {
 #include <ruby.h>
 #include <ruby/encoding.h>
 #include <ruby/thread.h>
+#include <ruby/thread_native.h>
 
 #include <assert.h>
 #include <inttypes.h>
@@ -71,7 +72,7 @@ typedef intptr_t Py_intptr_t;
 #ifdef HAVE_SSIZE_T
 typedef ssize_t Py_ssize_t;
 #elif SIZEOF_SIZE_T == SIZEOF_VOIDP
-typedef Py_intptr_tr Py_ssize_t;
+typedef Py_intptr_t Py_ssize_t;
 #elif SIZEOF_SIZE_T == SIZEOF_INT
 typedef int Py_ssize_t;
 #elif SIZEOF_SIZE_T == SIZEOF_LONG
@@ -745,11 +746,9 @@ void pycall_init_ruby_wrapper(void);
 extern intptr_t pycall_hash_salt;
 extern VALUE pycall_mPyCall;
 extern VALUE pycall_cPyPtr;
-extern VALUE pycall_eError;
 
 #define mPyCall pycall_mPyCall
 #define cPyPtr pycall_cPyPtr
-#define eError pycall_eError
 
 /* #define PYCALL_DEBUG_DUMP_REFCNT */
 

data/ext/pycall/ruby_wrapper.c

@@ -6,7 +6,6 @@ static PyMemberDef PyRuby_members[] = {
   {NULL} /* sentinel */
 };
 
-static VALUE PyRuby_get_ruby_object_and_set_pyerr(PyObject *pyobj);
 static void PyRuby_dealloc_with_gvl(PyRubyObject *);
 static PyObject * PyRuby_repr_with_gvl(PyRubyObject *);
 static PyObject * PyRuby_call_with_gvl(PyRubyObject *, PyObject *, PyObject *);
@@ -102,9 +101,7 @@ PyRuby_repr(PyRubyObject *pyro)
   VALUE obj, str;
   PyObject *res;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)pyro);
-  if (obj == Qundef)
-    return NULL;
+  obj = PyRuby_get_ruby_object((PyObject *)pyro);
 
   str = rb_inspect(obj);
   res = pycall_pystring_from_format("<PyCall.ruby_object %s>", StringValueCStr(str));
@@ -143,9 +140,7 @@ PyRuby_hash_long(PyRubyObject *pyro)
   VALUE obj, rbhash;
   intptr_t h;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)pyro);
-  if (obj == Qundef)
-    return (void *)-1;
+  obj = PyRuby_get_ruby_object((PyObject *)pyro);
 
   rbhash = rb_hash(obj);
   h = FIX2LONG(rbhash); /* Ruby's hash value is a Fixnum */
@@ -170,9 +165,7 @@ PyRuby_hash_hash_t(PyRubyObject *pyro)
   VALUE obj, rbhash;
   Py_hash_t h;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)pyro);
-  if (obj == Qundef)
-    return (void *)-1;
+  obj = PyRuby_get_ruby_object((PyObject *)pyro);
 
   rbhash = rb_hash(obj);
 #if SIZEOF_PY_HASH_T == SIZEOF_LONG
@@ -242,9 +235,7 @@ PyRuby_call(struct PyRuby_call_params *params)
   PyObject *pyobj_res;
   int state;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)params->pyro);
-  if (obj == Qundef)
-    return NULL;
+  obj = PyRuby_get_ruby_object((PyObject *)params->pyro);
 
   id_call = rb_intern("call");
   if (!rb_respond_to(obj, id_call)) {
@@ -296,9 +287,7 @@ PyRuby_getattro(struct PyRuby_getattro_params *params)
   ID name_id;
   PyObject *pyobj_res;
 
-  obj = PyRuby_get_ruby_object_and_set_pyerr((PyObject *)params->pyro);
-  if (obj == Qundef)
-    return NULL;
+  obj = PyRuby_get_ruby_object((PyObject *)params->pyro);
 
   name = pycall_pyobject_to_ruby(params->pyobj_name);
   name_cstr = StringValueCStr(name);
@@ -489,56 +478,3 @@ pycall_init_ruby_wrapper(void)
   rb_define_module_function(mPyCall, "wrap_ruby_object", pycall_m_wrap_ruby_object, 1);
 }
 
-/* --- File internal utilities --- */
-
-static VALUE
-funcall_id2ref(VALUE object_id)
-{
-  VALUE rb_mObjSpace;
-  object_id = rb_check_to_integer(object_id, "to_int");
-  rb_mObjSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
-  return rb_funcall(rb_mObjSpace, rb_intern("_id2ref"), 1, object_id);
-}
-
-static VALUE
-protect_id2ref(VALUE object_id)
-{
-  VALUE obj;
-  int state;
-
-  obj = rb_protect((VALUE (*)(VALUE))funcall_id2ref, object_id, &state);
-  if (state)
-    return Qundef;
-
-  return obj;
-}
-
-static VALUE
-protect_id2ref_and_set_pyerr(VALUE object_id)
-{
-  VALUE obj = protect_id2ref(object_id);
-  if (obj != Qundef)
-    return obj;
-
-  obj = rb_errinfo();
-  if (RTEST(rb_obj_is_kind_of(obj, rb_eRangeError))) {
-    Py_API(PyErr_SetString)(Py_API(PyExc_RuntimeError), "[BUG] referenced object was garbage-collected");
-  }
-  else {
-    VALUE emesg = rb_check_funcall(obj, rb_intern("message"), 0, 0);
-    Py_API(PyErr_Format)(Py_API(PyExc_RuntimeError),
-        "[BUG] Unable to obtain ruby object from ID: %s (%s)",
-        StringValueCStr(emesg), rb_class2name(CLASS_OF(obj)));
-  }
-  return Qundef;
-}
-
-static VALUE
-PyRuby_get_ruby_object_and_set_pyerr(PyObject *pyobj)
-{
-  VALUE obj_id;
-  if (!PyRuby_Check(pyobj))
-    return Qundef;
-  obj_id = rb_obj_id(PyRuby_get_ruby_object(pyobj));
-  return protect_id2ref_and_set_pyerr(obj_id);
-}

data/lib/pycall/libpython/pytypeobject_struct.rb

@@ -231,7 +231,7 @@ module PyCall
         else
           name, basic_size = *args
           new.tap do |t|
-            # NOTE: Disable autorelease for avoiding SEGV occurrance in Python's GC collect function
+            # NOTE: Disable autorelease for avoiding SEGV occurrence in Python's GC collect function
             #       at which the __new__ method object of this type object is freed.
             t.pointer.autorelease = false