pycall 0.1.0.alpha.20170711 → 1.0.0

data/ext/pycall/pycall_internal.h

@@ -0,0 +1,700 @@
+#ifndef PYCALL_INTERNAL_H
+#define PYCALL_INTERNAL_H 1
+
+#if defined(__cplusplus)
+extern "C" {
+#if 0
+} /* satisfy cc-mode */
+#endif
+#endif
+
+#include <ruby.h>
+#include <ruby/encoding.h>
+#include <assert.h>
+#include <inttypes.h>
+#include <limits.h>
+
+#if SIZEOF_LONG == SIZEOF_VOIDP
+# define PTR2NUM(x)   (LONG2NUM((long)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULONG(x)))
+#elif SIZEOF_LONG_LONG == SIZEOF_VOIDP
+# define PTR2NUM(x)   (LL2NUM((LONG_LONG)(x)))
+# define NUM2PTR(x)   ((void*)(NUM2ULL(x)))
+#else
+# error ---->> ruby requires sizeof(void*) == sizeof(long) or sizeof(LONG_LONG) to be compiled. <<----
+#endif
+
+#ifndef RB_INTEGER_TYPE_P
+# define RB_INTEGER_TYPE_P(obj) pycall_integer_type_p(obj)
+static inline int
+pycall_integer_type_p(VALUE obj)
+{
+  return (FIXNUM_P(obj) || (!SPECIAL_CONST_P(obj) && BUILTIN_TYPE(obj) == RUBY_T_BIGNUM));
+}
+#endif
+
+void ruby_debug_breakpoint();
+
+/* ==== python ==== */
+
+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;
+#elif SIZEOF_SIZE_T == SIZEOF_INT
+typedef int Py_ssize_t;
+#elif SIZEOF_SIZE_T == SIZEOF_LONG
+typedef long Py_ssize_t;
+#elif defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T == SIZEOF_LONG_LONG
+typedef LONG_LONG Py_ssize_t;
+#else
+# error "Unable to typedef Py_ssize_t"
+#endif
+
+#undef SSIZE_MIN
+#undef SSIZE_MAX
+
+#if SIZEOF_SIZE_T == SIZEOF_INT
+# define SSIZE_MIN INT_MIN
+# define SSIZE_MAX INT_MAX
+#elif SIZEOF_SIZE_T == SIZEOF_LONG
+# define SSIZE_MIN LONG_MIN
+# define SSIZE_MAX LONG_MAX
+#elif defined(HAVE_LONG_LONG) && SIZEOF_SIZE_T == SIZEOF_LONG_LONG
+# define SSIZE_MIN LLONG_MIN
+# define SSIZE_MAX LLONG_MAX
+#endif
+
+#define SIZEOF_PY_HASH_T SIZEOF_SSIZE_T
+typedef Py_ssize_t Py_hash_t;
+
+/* NOTE: Currently Py_TRACE_REFS is not supported */
+#define _PyObject_HEAD_EXTRA
+#define _PyObject_EXTRA_INIT
+
+#define PyObject_HEAD    \
+  _PyObject_HEAD_EXTRA   \
+  Py_ssize_t ob_refcnt;  \
+  struct _typeobject *ob_type;
+
+#define PyObject_VAR_HEAD  \
+  PyObject ob_base;        \
+  Py_ssize_t ob_size; /* Number of items in variable part */
+
+#define PyObject_HEAD_INIT(type)  \
+  _PyObject_EXTRA_INIT            \
+  { 1, type },
+
+#define PyVarObject_HEAD_INIT(type, size)  \
+  PyObject_HEAD_INIT(type) size,
+
+#define Py_INVALID_SIZE ((Py_ssize_t)-1)
+
+typedef struct {
+  PyObject_HEAD
+} PyObject;
+
+typedef struct {
+  PyObject_VAR_HEAD
+} PyVarObject;
+
+#define Py_REFCNT(ob)           (((PyObject*)(ob))->ob_refcnt)
+#define Py_TYPE(ob)             (((PyObject*)(ob))->ob_type)
+#define Py_SIZE(ob)             (((PyVarObject*)(ob))->ob_size)
+
+typedef PyObject * (*unaryfunc)(PyObject *);
+typedef PyObject * (*binaryfunc)(PyObject *, PyObject *);
+typedef PyObject * (*ternaryfunc)(PyObject *, PyObject *, PyObject *);
+typedef int (*inquiry)(PyObject *);
+typedef Py_ssize_t (*lenfunc)(PyObject *);
+typedef PyObject *(*ssizeargfunc)(PyObject *, Py_ssize_t);
+typedef int(*ssizeobjargproc)(PyObject *, Py_ssize_t, PyObject *);
+typedef int(*objobjargproc)(PyObject *, PyObject *, PyObject *);
+
+typedef struct bufferinfo {
+  void *buf;
+  PyObject *obj;        /* owned reference */
+  Py_ssize_t len;
+  Py_ssize_t itemsize;  /* This is Py_ssize_t so it can be
+			   pointed to by strides in simple case.*/
+  int readonly;
+  int ndim;
+  char *format;
+  Py_ssize_t *shape;
+  Py_ssize_t *strides;
+  Py_ssize_t *suboffsets;
+  void *internal;
+} Py_buffer;
+
+typedef int (*getbufferproc)(PyObject *, Py_buffer *, int);
+typedef void (*releasebufferproc)(PyObject *, Py_buffer *);
+
+typedef int (*objobjproc)(PyObject *, PyObject *);
+typedef int (*visitproc)(PyObject *, void *);
+typedef int (*traverseproc)(PyObject *, visitproc, void *);
+
+typedef struct {
+    /* Number implementations must check *both*
+       arguments for proper type and implement the necessary conversions
+       in the slot functions themselves. */
+
+    binaryfunc nb_add;
+    binaryfunc nb_subtract;
+    binaryfunc nb_multiply;
+    binaryfunc nb_remainder;
+    binaryfunc nb_divmod;
+    ternaryfunc nb_power;
+    unaryfunc nb_negative;
+    unaryfunc nb_positive;
+    unaryfunc nb_absolute;
+    inquiry nb_bool;
+    unaryfunc nb_invert;
+    binaryfunc nb_lshift;
+    binaryfunc nb_rshift;
+    binaryfunc nb_and;
+    binaryfunc nb_xor;
+    binaryfunc nb_or;
+    unaryfunc nb_int;
+    void *nb_reserved;  /* the slot formerly known as nb_long */
+    unaryfunc nb_float;
+
+    binaryfunc nb_inplace_add;
+    binaryfunc nb_inplace_subtract;
+    binaryfunc nb_inplace_multiply;
+    binaryfunc nb_inplace_remainder;
+    ternaryfunc nb_inplace_power;
+    binaryfunc nb_inplace_lshift;
+    binaryfunc nb_inplace_rshift;
+    binaryfunc nb_inplace_and;
+    binaryfunc nb_inplace_xor;
+    binaryfunc nb_inplace_or;
+
+    binaryfunc nb_floor_divide;
+    binaryfunc nb_true_divide;
+    binaryfunc nb_inplace_floor_divide;
+    binaryfunc nb_inplace_true_divide;
+
+    unaryfunc nb_index;
+
+    binaryfunc nb_matrix_multiply;
+    binaryfunc nb_inplace_matrix_multiply;
+} PyNumberMethods;
+
+typedef struct {
+    lenfunc sq_length;
+    binaryfunc sq_concat;
+    ssizeargfunc sq_repeat;
+    ssizeargfunc sq_item;
+    void *was_sq_slice;
+    ssizeobjargproc sq_ass_item;
+    void *was_sq_ass_slice;
+    objobjproc sq_contains;
+
+    binaryfunc sq_inplace_concat;
+    ssizeargfunc sq_inplace_repeat;
+} PySequenceMethods;
+
+typedef struct {
+  lenfunc mp_length;
+  binaryfunc mp_subscript;
+  objobjargproc mp_ass_subscript;
+} PyMappingMethods;
+
+typedef struct {
+  unaryfunc am_await;
+  unaryfunc am_aiter;
+  unaryfunc am_anext;
+} PyAsyncMethods;
+
+typedef struct {
+     getbufferproc bf_getbuffer;
+     releasebufferproc bf_releasebuffer;
+} PyBufferProcs;
+
+typedef void (*freefunc)(void *);
+typedef void (*destructor)(PyObject *);
+typedef int (*printfunc)(PyObject *, FILE *, int);
+typedef PyObject *(*getattrfunc)(PyObject *, char *);
+typedef PyObject *(*getattrofunc)(PyObject *, PyObject *);
+typedef int (*setattrfunc)(PyObject *, char *, PyObject *);
+typedef int (*setattrofunc)(PyObject *, PyObject *, PyObject *);
+typedef PyObject *(*reprfunc)(PyObject *);
+typedef long (*hashfunc_long)(PyObject *);
+typedef Py_hash_t (*hashfunc_hash_t)(PyObject *);
+typedef PyObject *(*richcmpfunc) (PyObject *, PyObject *, int);
+typedef PyObject *(*getiterfunc) (PyObject *);
+typedef PyObject *(*iternextfunc) (PyObject *);
+typedef PyObject *(*descrgetfunc) (PyObject *, PyObject *, PyObject *);
+typedef int (*descrsetfunc) (PyObject *, PyObject *, PyObject *);
+typedef int (*initproc)(PyObject *, PyObject *, PyObject *);
+typedef PyObject *(*newfunc)(struct _typeobject *, PyObject *, PyObject *);
+typedef PyObject *(*allocfunc)(struct _typeobject *, Py_ssize_t);
+
+typedef struct PyMemberDef {
+  const char *name;
+  int type;
+  Py_ssize_t offset;
+  int flags;
+  const char *doc;
+} PyMemberDef;
+
+typedef PyObject *(*PyCFunction)(PyObject *, PyObject *);
+
+struct PyMethodDef {
+  const char  *ml_name;   /* The name of the built-in function/method */
+  PyCFunction ml_meth;    /* The C function that implements it */
+  int         ml_flags;   /* Combination of METH_xxx flags, which mostly
+                             describe the args expected by the C func */
+  const char  *ml_doc;    /* The __doc__ attribute, or NULL */
+};
+typedef struct PyMethodDef PyMethodDef;
+
+/* Flag passed to newmethodobject */
+#define Py_METH_VARARGS  0x0001
+#define Py_METH_KEYWORDS 0x0002
+#define Py_METH_NOARGS   0x0004
+#define Py_METH_O        0x0008
+#define Py_METH_CLASS    0x0010
+#define Py_METH_STATIC   0x0020
+#define Py_METH_COEXIST   0x0040
+#define Py_METH_FASTCALL  0x0080
+
+typedef struct _typeobject {
+  PyObject_VAR_HEAD
+  const char *tp_name; /* For printing, in format "<module>.<name>" */
+  Py_ssize_t tp_basicsize, tp_itemsize; /* For allocation */
+
+  /* Methods to implement standard operations */
+
+  destructor tp_dealloc;
+  printfunc tp_print;
+  getattrfunc tp_getattr;
+  setattrfunc tp_setattr;
+  PyAsyncMethods *tp_as_async; /* formerly known as tp_compare (Python 2)
+                                  or tp_reserved (Python 3) */
+  reprfunc tp_repr;
+
+  /* Method suites for standard classes */
+
+  PyNumberMethods *tp_as_number;
+  PySequenceMethods *tp_as_sequence;
+  PyMappingMethods *tp_as_mapping;
+
+  /* More standard operations (here for binary compatibility) */
+
+  union {
+    hashfunc_long   _long;
+    hashfunc_hash_t _hash_t;
+  } tp_hash;
+
+  ternaryfunc tp_call;
+  reprfunc tp_str;
+  getattrofunc tp_getattro;
+  setattrofunc tp_setattro;
+
+  /* Functions to access object as input/output buffer */
+  PyBufferProcs *tp_as_buffer;
+
+  /* Flags to define presence of optional/expanded features */
+  unsigned long tp_flags;
+
+  const char *tp_doc; /* Documentation string */
+
+  /* Assigned meaning in release 2.0 */
+  /* call function for all accessible objects */
+  traverseproc tp_traverse;
+
+  /* delete references to contained objects */
+  inquiry tp_clear;
+
+  /* Assigned meaning in release 2.1 */
+  /* rich comparisons */
+  richcmpfunc tp_richcompare;
+
+  /* weak reference enabler */
+  Py_ssize_t tp_weaklistoffset;
+
+  /* Iterators */
+  getiterfunc tp_iter;
+  iternextfunc tp_iternext;
+
+  /* Attribute descriptor and subclassing stuff */
+  struct PyMethodDef *tp_methods;
+  struct PyMemberDef *tp_members;
+  struct PyGetSetDef *tp_getset;
+  struct _typeobject *tp_base;
+  PyObject *tp_dict;
+  descrgetfunc tp_descr_get;
+  descrsetfunc tp_descr_set;
+  Py_ssize_t tp_dictoffset;
+  initproc tp_init;
+  allocfunc tp_alloc;
+  newfunc tp_new;
+  freefunc tp_free; /* Low-level free-memory routine */
+  inquiry tp_is_gc; /* For PyObject_IS_GC */
+  PyObject *tp_bases;
+  PyObject *tp_mro; /* method resolution order */
+  PyObject *tp_cache;
+  PyObject *tp_subclasses;
+  PyObject *tp_weaklist;
+  destructor tp_del;
+
+  /* Type attribute cache version tag. Added in version 2.6 */
+  unsigned int tp_version_tag;
+
+  destructor tp_finalize;
+
+#ifdef COUNT_ALLOCS
+  /* these must be last and never explicitly initialized */
+  Py_ssize_t tp_allocs;
+  Py_ssize_t tp_frees;
+  Py_ssize_t tp_maxalloc;
+  struct _typeobject *tp_prev;
+  struct _typeobject *tp_next;
+#endif
+} PyTypeObject;
+
+/* Python 2.7 */
+#define Py_TPFLAGS_HAVE_GETCHARBUFFER  (1L<<0)
+#define Py_TPFLAGS_HAVE_SEQUENCE_IN    (1L<<1)
+#define Py_TPFLAGS_GC                  0 /* was sometimes (0x00000001<<2) in Python <= 2.1 */
+#define Py_TPFLAGS_HAVE_INPLACEOPS     (1L<<3)
+#define Py_TPFLAGS_CHECKTYPES          (1L<<4)
+#define Py_TPFLAGS_HAVE_RICHCOMPARE    (1L<<5)
+#define Py_TPFLAGS_HAVE_WEAKREFS       (1L<<6)
+#define Py_TPFLAGS_HAVE_ITER           (1L<<7)
+#define Py_TPFLAGS_HAVE_CLASS          (1L<<8)
+#define Py_TPFLAGS_HAVE_INDEX          (1L<<17)
+#define Py_TPFLAGS_HAVE_NEWBUFFER      (1L<<21)
+#define Py_TPFLAGS_STRING_SUBCLASS     (1L<<27)
+
+/* Python 3.0+ has only the following TPFLAGS: */
+#define Py_TPFLAGS_HEAPTYPE (1L<<9)
+#define Py_TPFLAGS_BASETYPE (1L<<10)
+#define Py_TPFLAGS_READY    (1L<<12)
+#define Py_TPFLAGS_READYING (1L<<13)
+#define Py_TPFLAGS_HAVE_GC  (1L<<14)
+#define Py_TPFLAGS_HAVE_VERSION_TAG  (1L<<18)
+#define Py_TPFLAGS_VALID_VERSION_TAG (1L<<19)
+#define Py_TPFLAGS_IS_ABSTRACT    (1L<<20)
+#define Py_TPFLAGS_INT_SUBCLASS   (1L<<23)
+#define Py_TPFLAGS_LONG_SUBCLASS  (1L<<24)
+#define Py_TPFLAGS_LIST_SUBCLASS  (1L<<25)
+#define Py_TPFLAGS_TUPLE_SUBCLASS (1L<<26)
+#define Py_TPFLAGS_BYTES_SUBCLASS (1L<<27)
+#define Py_TPFLAGS_UNICODE_SUBCLASS  (1L<<28)
+#define Py_TPFLAGS_DICT_SUBCLASS     (1L<<29)
+#define Py_TPFLAGS_BASE_EXC_SUBCLASS (1L<<30)
+#define Py_TPFLAGS_TYPE_SUBCLASS     (1L<<31)
+
+/* only use this if we have the stackless extension */
+#define Py_TPFLAGS_HAVE_STACKLESS_EXTENSION (3L<<15)
+
+#define PyType_HasFeature(t, f)  (((t)->tp_flags & (f)) != 0)
+#define PyType_FastSubclass(t,f)  PyType_HasFeature(t,f)
+
+/* Member Types */
+#define Py_T_SHORT     0
+#define Py_T_INT       1
+#define Py_T_LONG      2
+#define Py_T_FLOAT     3
+#define Py_T_DOUBLE    4
+#define Py_T_STRING    5
+#define Py_T_OBJECT    6
+/* XXX the ordering here is weird for binary compatibility */
+#define Py_T_CHAR      7   /* 1-character string */
+#define Py_T_BYTE      8   /* 8-bit signed int */
+/* unsigned variants: */
+#define Py_T_UBYTE     9
+#define Py_T_USHORT    10
+#define Py_T_UINT      11
+#define Py_T_ULONG     12
+
+/* Added by Jack: strings contained in the structure */
+#define Py_T_STRING_INPLACE    13
+
+/* Added by Lillo: bools contained in the structure (assumed char) */
+#define Py_T_BOOL      14
+
+#define Py_T_OBJECT_EX 16  /* Like T_OBJECT, but raises AttributeError
+                           when the value is NULL, instead of
+                           converting to None. */
+#define Py_T_LONGLONG      17
+#define Py_T_ULONGLONG     18
+
+#define Py_T_PYSSIZET      19      /* Py_ssize_t */
+#define Py_T_NONE          20      /* Value is always None */
+
+
+/* Member Flags */
+#define Py_READONLY            1
+#define Py_READ_RESTRICTED     2
+#define Py_PY_WRITE_RESTRICTED 4
+#define Py_RESTRICTED          (READ_RESTRICTED | PY_WRITE_RESTRICTED)
+
+/* Rich comparison opcodes */
+#define Py_LT 0
+#define Py_LE 1
+#define Py_EQ 2
+#define Py_NE 3
+#define Py_GT 4
+#define Py_GE 5
+
+#define PyType_IS_GC(t) PyType_HasFeature((t), Py_TPFLAGS_HAVE_GC)
+#define PyObject_IS_GC(o) (PyType_IS_GC(Py_TYPE(o)) && \
+    (Py_TYPE(o)->tp_is_gc == NULL || Py_TYPE(o)->tp_is_gc(o)))
+
+typedef union _gc_head {
+  struct {
+    union _gc_head *gc_next;
+    union _gc_head *gc_prev;
+    Py_ssize_t gc_refs;
+  } gc;
+  long double dummy;  /* force worst-case alignment */
+} PyGC_Head;
+
+typedef struct {
+  PyObject_HEAD
+  PyObject *cl_bases; /* A tuple of class objects */
+  PyObject *cl_dict;  /* A dictionary */
+  PyObject *cl_name;  /* A string */
+  /* The following three are functions or NULL */
+  PyObject *cl_getattr;
+  PyObject *cl_setattr;
+  PyObject *cl_delattr;
+  PyObject *cl_weakreflist; /* List of weak references */
+} PyClassObject;
+
+typedef struct {
+  PyObject_HEAD
+  PyClassObject *in_class;  /* The class object */
+  PyObject *in_dict;        /* A dictionary */
+  PyObject *in_weakreflist; /* List of weak references */
+} PyInstanceObject;
+
+/* ==== ruby_object wrapper ==== */
+
+typedef struct {
+  PyObject_HEAD
+  VALUE ruby_object;
+} PyRubyObject;
+
+extern PyTypeObject PyRuby_Type;
+
+#define PyRuby_Check(pyobj) (Py_TYPE(pyobj) == &PyRuby_Type)
+#define PyRuby_get_ruby_object(pyobj) (((PyRubyObject *)(pyobj))->ruby_object)
+
+PyObject * PyRuby_New(VALUE ruby_object);
+
+/* ==== pycall ==== */
+
+typedef struct {
+  PyObject *_Py_NoneStruct;
+  PyObject *_Py_TrueStruct;
+  PyObject *_Py_FalseStruct;
+
+  PyTypeObject *PyBool_Type;
+  PyTypeObject *PyClass_Type;
+  PyTypeObject *PyComplex_Type;
+  PyTypeObject *PyDict_Type;
+  PyTypeObject *PyFloat_Type;
+  PyTypeObject *PyInstance_Type;
+  PyTypeObject *PyInt_Type;
+  PyTypeObject *PyList_Type;
+  PyTypeObject *PyLong_Type;
+  PyTypeObject *PyModule_Type;
+  PyTypeObject *PyString_Type;
+  PyTypeObject *PyTuple_Type;
+  PyTypeObject *PyType_Type;
+  PyTypeObject *PyUnicode_Type;
+
+  PyObject *PyExc_RuntimeError;
+  PyObject *PyExc_TypeError;
+
+  void (* Py_InitializeEx)(int);
+  int (* Py_IsInitialized)();
+  char const * (* Py_GetVersion)();
+
+  void (* PySys_SetArgvEx)(int, char **, int);
+
+  void (* Py_IncRef)(PyObject *);
+  void (* Py_DecRef)(PyObject *);
+
+  PyObject * (* _PyObject_New)(PyTypeObject *);
+  int (* PyCallable_Check)(PyObject *);
+  int (* PyObject_IsInstance)(PyObject *, PyObject *);
+  union {
+    long      (* _long)(PyObject *);
+    Py_hash_t (* _hash_t)(PyObject *);
+  } PyObject_Hash;
+  PyObject * (* PyObject_RichCompare)(PyObject *, PyObject *, int);
+  PyObject * (* PyObject_Call)(PyObject *, PyObject *, PyObject *);
+  PyObject * (* PyObject_CallMethod)(PyObject *, char const *, char const *, ...);
+  PyObject * (* PyObject_Dir)(PyObject *);
+  PyObject * (* PyObject_GenericGetAttr)(PyObject *, PyObject *);
+  PyObject * (* PyObject_GetAttrString)(PyObject *, char const *);
+  int (* PyObject_SetAttrString)(PyObject *, char const *, PyObject *);
+  int (* PyObject_HasAttrString)(PyObject *, char const *);
+  PyObject * (* PyObject_GetItem)(PyObject *, PyObject *);
+  int (* PyObject_SetItem)(PyObject *obj, PyObject *key, PyObject *value);
+  int (* PyObject_DelItem)(PyObject *, PyObject *);
+  PyObject * (* PyObject_GetIter)(PyObject *);
+  PyObject * (* PyObject_Str)(PyObject *);
+  PyObject * (* PyObject_Repr)(PyObject *);
+
+  int (* PyType_Ready)(PyTypeObject *);
+  PyObject * (* PyType_GenericNew)(PyTypeObject *, PyObject *, PyObject *);
+
+  PyObject * (* PyWeakref_NewRef)(PyObject *ob, PyObject *callback);
+
+  PyObject * (* PyBool_FromLong)(long);
+
+  PyObject * (* PyCFunction_NewEx)(PyMethodDef *, PyObject *, PyObject *);
+
+  double (* PyComplex_RealAsDouble)(PyObject *);
+  double (* PyComplex_ImagAsDouble)(PyObject *);
+  PyObject * (* PyComplex_FromDoubles)(double, double);
+
+  double (* PyFloat_AsDouble)(PyObject *);
+  PyObject * (* PyFloat_FromDouble)(double);
+
+  PyObject * (* PyInt_FromLong)(long);
+  PyObject * (* PyInt_FromSsize_t)(Py_ssize_t);
+  Py_ssize_t (* PyInt_AsSsize_t)(PyObject *);
+
+  long (* PyLong_AsLongAndOverflow)(PyObject *, int *);
+  PyObject * (* PyLong_FromLong)(long);
+#ifdef HAVE_LONG_LONG
+  LONG_LONG (* PyLong_AsLongLongAndOverflow)(PyObject *, int *);
+  PyObject * (* PyLong_FromLongLong)(LONG_LONG);
+#endif
+  Py_ssize_t (* PyLong_AsSsize_t)(PyObject *);
+
+  PyObject * (* PyTuple_New)(Py_ssize_t);
+  Py_ssize_t (* PyTuple_Size)(PyObject *);
+  PyObject * (* PyTuple_GetItem)(PyObject *, Py_ssize_t);
+  int (* PyTuple_SetItem)(PyObject *, Py_ssize_t, PyObject *);
+
+  PyObject * (* PySlice_New)(PyObject *, PyObject *, PyObject *);
+
+  PyObject * (* PyIter_Next)(PyObject *);
+
+  PyObject * (* PyErr_Occurred)(void);
+  void (* PyErr_Fetch)(PyObject **, PyObject **, PyObject **);
+  void (* PyErr_Restore)(PyObject *, PyObject *, PyObject *);
+  void (* PyErr_Clear)(void);
+  void (* PyErr_SetString)(PyObject *, const char *);   /* decoded from utf-8 */
+  void (* PyErr_Format)(PyObject *, const char *, ...); /* ASCII-encoded string  */
+
+  PyObject * (* PyImport_ImportModule)(char const*);
+  PyObject * (* PyImport_ImportModuleLevel)(char const*, PyObject *, PyObject *, PyObject *, int);
+
+  void (* PyOS_AfterFork)(void);
+
+  PyObject * (* PyList_New)(Py_ssize_t);
+  Py_ssize_t (* PyList_Size)(PyObject *);
+  PyObject * (* PyList_GetItem)(PyObject *, Py_ssize_t);
+  int (* PyList_SetItem)(PyObject *, Py_ssize_t, PyObject *);
+  int (* PyList_Insert)(PyObject *, Py_ssize_t, PyObject *);
+  int (* PyList_Append)(PyObject *, PyObject *);
+
+  PyObject * (* PyDict_New)();
+  int (* PyDict_Contains)(PyObject *, PyObject *);
+  int (* PyDict_SetItemString)(PyObject *, char const *, PyObject *);
+  int (* PyDict_Next)(PyObject *, Py_ssize_t *, PyObject **, PyObject **);
+
+  int (* PySequence_Check)(PyObject *);
+  Py_ssize_t (* PySequence_Size)(PyObject *);
+  int (* PySequence_Contains)(PyObject *, PyObject *);
+  PyObject * (* PySequence_GetItem)(PyObject *, Py_ssize_t);
+
+  int (* PyString_AsStringAndSize)(PyObject *, char **, Py_ssize_t *);
+  PyObject * (* PyString_FromStringAndSize)(char *, Py_ssize_t);
+  PyObject * (* PyString_FromFormatV)(char const*, ...);
+
+  PyObject * (* PyUnicode_AsUTF8String)(PyObject *);
+  PyObject * (* PyUnicode_DecodeUTF8)(char const*, Py_ssize_t, char const *);
+  PyObject * (* PyUnicode_FromFormatV)(char const*, ...);
+} pycall_libpython_api_table_t;
+
+pycall_libpython_api_table_t *pycall_libpython_api_table(void);
+#define Py_API(name) (pycall_libpython_api_table()->name)
+
+int pycall_python_major_version(void);
+Py_ssize_t pycall_python_hexversion(void);
+#define pycall_python_long_hash (pycall_python_hexversion() < 0x03020000)
+
+void pycall_Py_DecRef(PyObject *);
+
+RUBY_EXTERN const rb_data_type_t pycall_pyptr_data_type;
+size_t pycall_pyptr_memsize(void const *);
+void pycall_pyptr_free(void *);
+
+VALUE pycall_import_module(char const *name);
+VALUE pycall_import_module_level(char const *name, VALUE globals, VALUE locals, VALUE fromlist, int level);
+VALUE pycall_getattr_default(VALUE pyobj, char const *name, VALUE default_value);
+VALUE pycall_getattr(VALUE pyobj, char const *name);
+
+VALUE pycall_pyobject_to_ruby(PyObject *);
+VALUE pycall_pytype_to_ruby(PyObject *);
+VALUE pycall_pymodule_to_ruby(PyObject *);
+VALUE pycall_pybool_to_ruby(PyObject *);
+VALUE pycall_pycomplex_to_ruby(PyObject *);
+VALUE pycall_pyfloat_to_ruby(PyObject *);
+VALUE pycall_pyint_to_ruby(PyObject *);
+VALUE pycall_pylong_to_ruby(PyObject *);
+VALUE pycall_pystring_to_ruby(PyObject *);
+VALUE pycall_pyobject_to_a(PyObject *);
+
+VALUE pycall_conv_to_str(VALUE);
+
+PyObject *pycall_pyobject_from_ruby(VALUE);
+PyObject *pycall_pystring_from_ruby(VALUE);
+PyObject *pycall_pytuple_from_ruby(VALUE);
+PyObject *pycall_pylist_from_ruby(VALUE);
+PyObject *pycall_pydict_from_ruby(VALUE);
+PyObject *pycall_pyslice_from_ruby(VALUE);
+
+NORETURN(void pycall_pyerror_fetch_and_raise(char const *format, ...));
+
+unsigned long pycall_default_tp_flags(void);
+PyObject *pycall_pystring_from_format(char const *format, ...);
+PyObject *pycall_pystring_from_formatv(char const *format, va_list vargs);
+
+VALUE pycall_pyrubyptr_new(PyObject *pyrubyobj);
+
+int pycall_obj_is_step_range(VALUE obj);
+int pycall_extract_range(VALUE obj, VALUE *pbegin, VALUE *pend, int *pexclude_end, VALUE *pstep);
+
+void pycall_gcguard_register(PyObject *, VALUE);
+void pycall_gcguard_delete(PyObject *);
+void pycall_gcguard_register_pyrubyobj(PyObject *);
+void pycall_gcguard_unregister_pyrubyobj(PyObject *);
+
+void pycall_init_libpython_api_table(VALUE handle);
+void pycall_init_exceptions(VALUE handle);
+void pycall_init_gcguard(void);
+void pycall_init_ruby_wrapper(void);
+
+#define pycall_hash_salt_32 0xb592cd9b
+extern long 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 */
+
+#if defined(__cplusplus)
+#if 0
+{ /* satisfy cc-mode */
+#endif
+} /* extern "C" { */
+#endif
+
+#endif /* PYCALL_INTERNAL_H */