/ext/pycall/libpython.c

https://github.com/mrkn/pycall.rb · C · 228 lines · 187 code · 41 blank · 0 comment · 16 complexity · 88f2f777b119ade0123099f95cd6ca5d MD5 · raw file 

    

  1. #include "pycall_internal.h"
    2. 

  2. 

  3. static pycall_libpython_api_table_t api_table = { NULL, };
    4. 

  4. static int python_string_as_bytes;
    5. 

  5. 

  6. pycall_libpython_api_table_t *
    7. 

  7. pycall_libpython_api_table(void)
    8. 

  8. {
    9. 

  9.   return &api_table;
    10. 

  10. }
    11. 

  11. 

  12. struct lookup_libpython_api_args {
    13. 

  13.   VALUE libpython_handle;
    14. 

  14.   char const *name;
    15. 

  15. };
    16. 

  16. 

  17. static VALUE
    18. 

  18. lookup_libpython_api_0(struct lookup_libpython_api_args *args)
    19. 

  19. {
    20. 

  20.   return rb_funcall(args->libpython_handle, rb_intern("sym"), 1, rb_str_new2(args->name));
    21. 

  21. }
    22. 

  22. 

  23. static void *
    24. 

  24. lookup_libpython_api(VALUE libpython_handle, char const *name)
    25. 

  25. {
    26. 

  26.   struct lookup_libpython_api_args arg;
    27. 

  27.   VALUE addr;
    28. 

  28.   int state;
    29. 

  29. 

  30.   arg.libpython_handle = libpython_handle;
    31. 

  31.   arg.name = name;
    32. 

  32.   addr = rb_protect((VALUE (*)(VALUE))lookup_libpython_api_0, (VALUE)&arg, &state);
    33. 

  33.   if (state) {
    34. 

  34.     rb_set_errinfo(Qnil);
    35. 

  35.     return NULL;
    36. 

  36.   }
    37. 

  37.   else {
    38. 

  38.     return NIL_P(addr) ? NULL : NUM2PTR(addr);
    39. 

  39.   }
    40. 

  40. }
    41. 

  41. 

  42. #define LOOKUP_API_ENTRY(api_name) lookup_libpython_api(libpython_handle, #api_name)
    43. 

  43. #define CHECK_API_ENTRY(api_name) (LOOKUP_API_ENTRY(api_name) != NULL)
    44. 

  44. 

  45. #define required 1
    46. 

  46. #define optional 0
    47. 

  47. 

  48. #define INIT_API_TABLE_ENTRY2(member_name, api_name, required) do { \
    49. 

  49.   void *fptr = LOOKUP_API_ENTRY(api_name); \
    50. 

  50.   if (!fptr && required) { \
    51. 

  51.     rb_raise(eLibPythonFunctionNotFound, "Unable to find the required symbol in libpython: %s", #api_name); \
    52. 

  52.   } \
    53. 

  53.   (api_table.member_name) = fptr; \
    54. 

  54. } while (0)
    55. 

  55. 

  56. #define INIT_API_TABLE_ENTRY(api_name, required) INIT_API_TABLE_ENTRY2(api_name, api_name, required)
    57. 

  57. 

  58. #define INIT_API_TABLE_ENTRY_PTR(api_name, required) do { \
    59. 

  59.   INIT_API_TABLE_ENTRY(api_name, required); \
    60. 

  60.   (api_table.api_name) = *(void **)(api_table.api_name); \
    61. 

  61. } while (0)
    62. 

  62. 

  63. void
    64. 

  64. pycall_init_libpython_api_table(VALUE libpython_handle)
    65. 

  65. {
    66. 

  66.   VALUE eLibPythonFunctionNotFound = rb_const_get_at(pycall_mPyCall, rb_intern("LibPythonFunctionNotFound"));
    67. 

  67. 

  68.   INIT_API_TABLE_ENTRY(_Py_NoneStruct, required);
    69. 

  69. 

  70.   INIT_API_TABLE_ENTRY(PyBool_Type, required);
    71. 

  71.   INIT_API_TABLE_ENTRY(PyClass_Type, optional);
    72. 

  72.   INIT_API_TABLE_ENTRY(PyComplex_Type, required);
    73. 

  73.   INIT_API_TABLE_ENTRY(PyDict_Type, required);
    74. 

  74.   INIT_API_TABLE_ENTRY(PyFloat_Type, required);
    75. 

  75.   INIT_API_TABLE_ENTRY(PyList_Type, required);
    76. 

  76.   INIT_API_TABLE_ENTRY(PyInstance_Type, optional);
    77. 

  77.   INIT_API_TABLE_ENTRY(PyInt_Type, optional);
    78. 

  78.   INIT_API_TABLE_ENTRY(PyLong_Type, required);
    79. 

  79.   INIT_API_TABLE_ENTRY(PyModule_Type, required);
    80. 

  80.   python_string_as_bytes = !CHECK_API_ENTRY(PyString_Type);
    81. 

  81.   if (python_string_as_bytes) {
    82. 

  82.     INIT_API_TABLE_ENTRY2(PyString_Type, PyBytes_Type, required);
    83. 

  83.   }
    84. 

  84.   else {
    85. 

  85.     INIT_API_TABLE_ENTRY(PyString_Type, required);
    86. 

  86.   }
    87. 

  87.   INIT_API_TABLE_ENTRY(PyTuple_Type, required);
    88. 

  88.   INIT_API_TABLE_ENTRY(PyType_Type, required);
    89. 

  89.   INIT_API_TABLE_ENTRY(PyUnicode_Type, required);
    90. 

  90. 

  91.   INIT_API_TABLE_ENTRY(Py_InitializeEx, required);
    92. 

  92.   INIT_API_TABLE_ENTRY(Py_IsInitialized, required);
    93. 

  93.   INIT_API_TABLE_ENTRY(Py_GetVersion, required);
    94. 

  94. 

  95.   INIT_API_TABLE_ENTRY(PySys_SetArgvEx, required);
    96. 

  96. 

  97.   INIT_API_TABLE_ENTRY(Py_IncRef, required);
    98. 

  98.   INIT_API_TABLE_ENTRY(Py_DecRef, required);
    99. 

  99. 

  100.   INIT_API_TABLE_ENTRY(_PyObject_New, required);
    101. 

  101.   INIT_API_TABLE_ENTRY(PyCallable_Check, required);
    102. 

  102.   INIT_API_TABLE_ENTRY(PyObject_IsInstance, required);
    103. 

  103.   INIT_API_TABLE_ENTRY(PyObject_IsSubclass, required);
    104. 

  104.   INIT_API_TABLE_ENTRY2(PyObject_Hash._hash_t, PyObject_Hash, required);
    105. 

  105.   INIT_API_TABLE_ENTRY(PyObject_RichCompare, required);
    106. 

  106.   INIT_API_TABLE_ENTRY(PyObject_Call, required);
    107. 

  107.   INIT_API_TABLE_ENTRY(PyObject_CallMethod, required);
    108. 

  108.   INIT_API_TABLE_ENTRY(PyObject_Dir, required);
    109. 

  109.   INIT_API_TABLE_ENTRY(PyObject_GenericGetAttr, required);
    110. 

  110.   INIT_API_TABLE_ENTRY(PyObject_GetAttrString, required);
    111. 

  111.   INIT_API_TABLE_ENTRY(PyObject_SetAttrString, required);
    112. 

  112.   INIT_API_TABLE_ENTRY(PyObject_HasAttrString, required);
    113. 

  113.   INIT_API_TABLE_ENTRY(PyObject_GetItem, required);
    114. 

  114.   INIT_API_TABLE_ENTRY(PyObject_SetItem, required);
    115. 

  115.   INIT_API_TABLE_ENTRY(PyObject_DelItem, required);
    116. 

  116.   INIT_API_TABLE_ENTRY(PyObject_GetIter, required);
    117. 

  117.   INIT_API_TABLE_ENTRY(PyObject_Str, required);
    118. 

  118.   INIT_API_TABLE_ENTRY(PyObject_Repr, required);
    119. 

  119. 

  120.   INIT_API_TABLE_ENTRY(PyType_Ready, required);
    121. 

  121.   INIT_API_TABLE_ENTRY(PyType_GenericNew, required);
    122. 

  122. 

  123.   INIT_API_TABLE_ENTRY(PyCFunction_NewEx, required);
    124. 

  124. 

  125.   INIT_API_TABLE_ENTRY(PyWeakref_NewRef, required);
    126. 

  126. 

  127.   INIT_API_TABLE_ENTRY(PyBool_FromLong, required);
    128. 

  128. 

  129.   INIT_API_TABLE_ENTRY(PyComplex_RealAsDouble, required);
    130. 

  130.   INIT_API_TABLE_ENTRY(PyComplex_ImagAsDouble, required);
    131. 

  131.   INIT_API_TABLE_ENTRY(PyComplex_FromDoubles, required);
    132. 

  132. 

  133.   INIT_API_TABLE_ENTRY(PyFloat_AsDouble, required);
    134. 

  134.   INIT_API_TABLE_ENTRY(PyFloat_FromDouble, required);
    135. 

  135. 

  136.   INIT_API_TABLE_ENTRY(PyList_New, required);
    137. 

  137.   INIT_API_TABLE_ENTRY(PyList_Size, required);
    138. 

  138.   INIT_API_TABLE_ENTRY(PyList_GetItem, required);
    139. 

  139.   INIT_API_TABLE_ENTRY(PyList_SetItem, required);
    140. 

  140.   INIT_API_TABLE_ENTRY(PyList_Insert, required);
    141. 

  141.   INIT_API_TABLE_ENTRY(PyList_Append, required);
    142. 

  142. 

  143.   INIT_API_TABLE_ENTRY(PyInt_FromLong, optional);
    144. 

  144.   INIT_API_TABLE_ENTRY(PyInt_FromSsize_t, optional);
    145. 

  145.   INIT_API_TABLE_ENTRY(PyInt_AsSsize_t, optional);
    146. 

  146. 

  147.   INIT_API_TABLE_ENTRY(PyLong_AsLongAndOverflow, required);
    148. 

  148.   INIT_API_TABLE_ENTRY(PyLong_FromLong, required);
    149. 

  149. #ifdef HAVE_LONG_LONG
    150. 

  150.   INIT_API_TABLE_ENTRY(PyLong_AsLongLongAndOverflow, required);
    151. 

  151.   INIT_API_TABLE_ENTRY(PyLong_FromLongLong, required);
    152. 

  152. #endif
    153. 

  153.   INIT_API_TABLE_ENTRY(PyLong_AsSsize_t, required);
    154. 

  154. 

  155.   INIT_API_TABLE_ENTRY(PyTuple_New, required);
    156. 

  156.   INIT_API_TABLE_ENTRY(PyTuple_Size, required);
    157. 

  157.   INIT_API_TABLE_ENTRY(PyTuple_GetItem, required);
    158. 

  158.   INIT_API_TABLE_ENTRY(PyTuple_SetItem, required);
    159. 

  159. 

  160.   INIT_API_TABLE_ENTRY(PySlice_New, required);
    161. 

  161. 

  162.   INIT_API_TABLE_ENTRY(PyIter_Next, required);
    163. 

  163. 

  164.   INIT_API_TABLE_ENTRY(PyEval_ThreadsInitialized, required);
    165. 

  165.   INIT_API_TABLE_ENTRY(PyEval_InitThreads, required);
    166. 

  166. 

  167.   INIT_API_TABLE_ENTRY(PyErr_Occurred, required);
    168. 

  168.   INIT_API_TABLE_ENTRY(PyErr_Fetch, required);
    169. 

  169.   INIT_API_TABLE_ENTRY(PyErr_Restore, required);
    170. 

  170.   INIT_API_TABLE_ENTRY(PyErr_Clear, required);
    171. 

  171.   INIT_API_TABLE_ENTRY(PyErr_SetString, required);
    172. 

  172.   INIT_API_TABLE_ENTRY(PyErr_Format, required);
    173. 

  173.   INIT_API_TABLE_ENTRY(PyErr_SetInterrupt, required);
    174. 

  174. 

  175.   INIT_API_TABLE_ENTRY(PyImport_ImportModule, required);
    176. 

  176.   INIT_API_TABLE_ENTRY(PyImport_ImportModuleLevel, required);
    177. 

  177. 

  178.   INIT_API_TABLE_ENTRY(PyOS_AfterFork, required);
    179. 

  179. 

  180.   INIT_API_TABLE_ENTRY(PyList_Size, required);
    181. 

  181.   INIT_API_TABLE_ENTRY(PyList_GetItem, required);
    182. 

  182. 

  183.   INIT_API_TABLE_ENTRY(PyDict_New, required);
    184. 

  184.   INIT_API_TABLE_ENTRY(PyDict_Contains, required);
    185. 

  185.   INIT_API_TABLE_ENTRY(PyDict_SetItemString, required);
    186. 

  186.   INIT_API_TABLE_ENTRY(PyDict_Next, required);
    187. 

  187. 

  188.   INIT_API_TABLE_ENTRY(PySequence_Check, required);
    189. 

  189.   INIT_API_TABLE_ENTRY(PySequence_Size, required);
    190. 

  190.   INIT_API_TABLE_ENTRY(PySequence_Contains, required);
    191. 

  191.   INIT_API_TABLE_ENTRY(PySequence_GetItem, required);
    192. 

  192. 

  193.   if (python_string_as_bytes) {
    194. 

  194.     INIT_API_TABLE_ENTRY2(PyString_AsStringAndSize, PyBytes_AsStringAndSize, required);
    195. 

  195.     INIT_API_TABLE_ENTRY2(PyString_FromStringAndSize, PyBytes_FromStringAndSize, required);
    196. 

  196.     INIT_API_TABLE_ENTRY2(PyString_FromFormatV, PyBytes_FromFormat, required);
    197. 

  197.   }
    198. 

  198.   else {
    199. 

  199.     INIT_API_TABLE_ENTRY(PyString_AsStringAndSize, required);
    200. 

  200.     INIT_API_TABLE_ENTRY(PyString_FromStringAndSize, required);
    201. 

  201.     INIT_API_TABLE_ENTRY(PyString_FromFormatV, required);
    202. 

  202.   }
    203. 

  203. 

  204.   if (CHECK_API_ENTRY(PyUnicode_DecodeUTF8)) {
    205. 

  205.     INIT_API_TABLE_ENTRY(PyUnicode_AsUTF8String, required);
    206. 

  206.     INIT_API_TABLE_ENTRY(PyUnicode_DecodeUTF8, required);
    207. 

  207.     INIT_API_TABLE_ENTRY(PyUnicode_FromFormatV, required);
    208. 

  208.   }
    209. 

  209.   else if (CHECK_API_ENTRY(PyUnicodeUCS4_DecodeUTF8)) {
    210. 

  210.     INIT_API_TABLE_ENTRY2(PyUnicode_AsUTF8String, PyUnicodeUCS4_AsUTF8String, required);
    211. 

  211.     INIT_API_TABLE_ENTRY2(PyUnicode_DecodeUTF8, PyUnicodeUCS4_DecodeUTF8, required);
    212. 

  212.     INIT_API_TABLE_ENTRY2(PyUnicode_FromFormatV, PyUnicodeUCS4_FromFormatV, required);
    213. 

  213.   }
    214. 

  214.   else if (CHECK_API_ENTRY(PyUnicodeUCS2_DecodeUTF8)) {
    215. 

  215.     INIT_API_TABLE_ENTRY2(PyUnicode_AsUTF8String, PyUnicodeUCS2_AsUTF8String, required);
    216. 

  216.     INIT_API_TABLE_ENTRY2(PyUnicode_DecodeUTF8, PyUnicodeUCS2_DecodeUTF8, required);
    217. 

  217.     INIT_API_TABLE_ENTRY2(PyUnicode_FromFormatV, PyUnicodeUCS2_FromFormatV, required);
    218. 

  218.   }
    219. 

  219. }
    220. 

  220. 

  221. void
    222. 

  222. pycall_init_exceptions(VALUE libpython_handle)
    223. 

  223. {
    224. 

  224.   VALUE eLibPythonFunctionNotFound = rb_const_get_at(pycall_mPyCall, rb_intern("LibPythonFunctionNotFound"));
    225. 

  225. 

  226.   INIT_API_TABLE_ENTRY_PTR(PyExc_RuntimeError, required);
    227. 

  227.   INIT_API_TABLE_ENTRY_PTR(PyExc_TypeError, required);
    228. 

  228. }
    229.