Mercurial > pub > dyncall > bindings

comparison python/pydc/pydc.c @ 46:c21d1c2c84e1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways) * implies renaming pydcext.* to pydc.* * while at it, iterate directly over args that are passed in (before we did extract fptr, sig and a tuple for the args and iterated over latter afterwards); we might have a tiny perf improvement now - added type stub as package_data
author Tassilo Philipp
date Fri, 13 Nov 2020 14:10:31 +0100
parents python/pydc/pydcext.c@0f86a5ecfe61
children d6670bd553dd
comparison
equal deleted inserted replaced
45:da553362fa7c 46:c21d1c2c84e1
1 /******************************************************************************
2 **
3 ** pydc - python dyncall package
4 **
5 ** python extension package in C
6 ** Copyright 2007-2016 Daniel Adler
7 ** 2018-2020 Tassilo Philipp
8 **
9 ** See README.txt for details (about changes, how to use, etc.).
10 **
11 *****************************************************************************/
12
13 #include <Python.h>
14 #include "dynload.h"
15 #include <limits.h>
16
17
18
19 #if ( (PY_VERSION_HEX < 0x02070000) \
20 || ((PY_VERSION_HEX >= 0x03000000) \
21 && (PY_VERSION_HEX < 0x03010000)) )
22 # define DcPyCObject_FromVoidPtr(ptr, dtor) PyCObject_FromVoidPtr((ptr), (dtor)) // !new ref!
23 # define DcPyCObject_AsVoidPtr(ppobj) PyCObject_AsVoidPtr((ppobj))
24 # define DcPyCObject_SetVoidPtr(ppobj, ptr) PyCObject_SetVoidPtr((ppobj), (ptr))
25 #else
26 # define USE_CAPSULE_API
27 # define DcPyCObject_FromVoidPtr(ptr, dtor) PyCapsule_New((ptr), NULL, (dtor)) // !new ref!
28 # define DcPyCObject_AsVoidPtr(ppobj) PyCapsule_GetPointer((ppobj), NULL)
29 # define DcPyCObject_SetVoidPtr(ppobj, ptr) //@@@ unsure what to do, cannot/shouldn't call this with a null pointer as this wants to call the dtor, so not doing anything: PyCapsule_SetPointer((ppobj), (ptr)) // this might need to call the dtor to behave like PyCObject_SetVoidPtr?
30 #endif
31
32 #if(PY_VERSION_HEX >= 0x03030000)
33 # define PYUNICODE_CACHES_UTF8
34 #endif
35
36 #if PY_MAJOR_VERSION >= 3
37 # define EXPECT_LONG_TYPE_STR "an int"
38 # define DcPyString_GET_SIZE PyBytes_GET_SIZE
39 # define DcPyString_Check PyBytes_Check
40 # define DcPyString_AsString PyBytes_AsString
41 # define DcPyInt_Check PyLong_Check
42 # define DcPyInt_AsLong PyLong_AsLong
43 # define DcPyInt_AS_LONG PyLong_AS_LONG
44 #else
45 # define EXPECT_LONG_TYPE_STR "an int or a long"
46 # define DcPyString_GET_SIZE PyString_GET_SIZE
47 # define DcPyString_Check PyString_Check
48 # define DcPyString_AsString PyString_AsString
49 # define DcPyInt_Check PyInt_Check
50 # define DcPyInt_AsLong PyInt_AsLong
51 # define DcPyInt_AS_LONG PyInt_AS_LONG
52 #endif
53
54 /* PyCObject destructor callback for libhandle */
55
56 #if defined(USE_CAPSULE_API)
57 void free_library(PyObject* capsule)
58 {
59 void* libhandle = PyCapsule_GetPointer(capsule, NULL);
60 #else
61 void free_library(void* libhandle)
62 {
63 #endif
64 if (libhandle != 0)
65 dlFreeLibrary(libhandle);
66 }
67
68
69 /* load function */
70
71 static PyObject*
72 pydc_load(PyObject* self, PyObject* args)
73 {
74 const char* libpath;
75 void* libhandle;
76
77 if (!PyArg_ParseTuple(args,"z", &libpath))
78 return PyErr_Format(PyExc_RuntimeError, "libpath argument (str) missing");
79
80 libhandle = dlLoadLibrary(libpath);
81
82 if (!libhandle)
83 return PyErr_Format(PyExc_RuntimeError, "dlLoadLibrary('%s') failed", libpath);
84
85 return DcPyCObject_FromVoidPtr(libhandle, &free_library); // !new ref!
86 }
87
88 /* find function */
89
90 static PyObject*
91 pydc_find(PyObject* self, PyObject* args)
92 {
93 PyObject* pcobj;
94 const char* symbol;
95 void* libhandle;
96 void* funcptr;
97
98 if (!PyArg_ParseTuple(args, "Os", &pcobj, &symbol))
99 return PyErr_Format(PyExc_RuntimeError, "argument mismatch");
100
101 libhandle = DcPyCObject_AsVoidPtr(pcobj);
102 if (!libhandle)
103 return PyErr_Format(PyExc_RuntimeError, "libhandle is null");
104
105 funcptr = dlFindSymbol(libhandle, symbol);
106 if (!funcptr)
107 return PyErr_Format(PyExc_RuntimeError, "symbol '%s' not found", symbol);
108
109 return DcPyCObject_FromVoidPtr(funcptr, NULL); // !new ref!
110 }
111
112 /* free function */
113
114 static PyObject*
115 pydc_free(PyObject* self, PyObject* args)
116 {
117 PyObject* pcobj;
118 void* libhandle;
119
120 if (!PyArg_ParseTuple(args, "O", &pcobj))
121 return PyErr_Format(PyExc_RuntimeError, "argument mismatch");
122
123 libhandle = DcPyCObject_AsVoidPtr(pcobj);
124 if (!libhandle)
125 return PyErr_Format(PyExc_RuntimeError, "libhandle is NULL");
126
127 dlFreeLibrary(libhandle);
128 DcPyCObject_SetVoidPtr(pcobj, NULL);
129
130 //don't think I need to release it, as the pyobj is not equivalent to the held handle
131 //Py_XDECREF(pcobj); // release ref from pydc_load()
132
133 Py_RETURN_NONE;
134 }
135
136 /* get_path function */
137
138 static PyObject*
139 pydc_get_path(PyObject* self, PyObject* args)
140 {
141 PyObject* pcobj;
142 PyObject* retobj;
143 void* libhandle;
144 char* path;
145 int path_bufSize;
146
147 if (!PyArg_ParseTuple(args, "O", &pcobj))
148 return PyErr_Format(PyExc_RuntimeError, "argument mismatch");
149
150 libhandle = (pcobj == Py_None)?NULL:DcPyCObject_AsVoidPtr(pcobj);
151 path_bufSize = dlGetLibraryPath(libhandle, NULL, 0);
152 if (!path_bufSize)
153 return PyErr_Format(PyExc_RuntimeError, "library path cannot be found");
154
155 path = malloc(path_bufSize);
156 if (path_bufSize != dlGetLibraryPath(libhandle, path, path_bufSize)) {
157 free(path);
158 return PyErr_Format(PyExc_RuntimeError, "library path cannot be queried");
159 }
160
161 retobj = Py_BuildValue("s", path); // !new ref! @@@ UTF-8 input...
162 free(path);
163 return retobj;
164 }
165
166
167 #include "dyncall.h"
168 #include "dyncall_signature.h"
169
170 DCCallVM* gpCall = NULL;
171
172 // helper to temporarily copy string arguments
173 #define NUM_AUX_STRS 64
174 static int n_str_aux;
175 static char* str_aux[NUM_AUX_STRS]; // hard limit, most likely enough and checked for below @@@ugly though
176
177
178 /* call function */
179
180 static PyObject*
181 pydc_call_impl(PyObject* self, PyObject* args) /* implementation, called by wrapper func pydc_call() */
182 {
183 const char *sig_ptr;
184 char ch;
185 int pos, ts;
186 void* pfunc;
187
188 pos = 0;
189 ts = PyTuple_Size(args);
190 if (ts < 2)
191 return PyErr_Format(PyExc_RuntimeError, "argument mismatch");
192
193 // get ptr to func to call
194 pfunc = DcPyCObject_AsVoidPtr(PyTuple_GetItem(args, pos++));
195 if (!pfunc)
196 return PyErr_Format( PyExc_RuntimeError, "function pointer is NULL" );
197
198 // get signature
199 #if !defined(PYUNICODE_CACHES_UTF8)
200 PyObject* sig_obj = NULL;
201 #endif
202 PyObject* so = PyTuple_GetItem(args, pos++);
203 if ( PyUnicode_Check(so) )
204 {
205 #if defined(PYUNICODE_CACHES_UTF8)
206 sig_ptr = PyUnicode_AsUTF8(so);
207 #else
208 // w/o PyUnicode_AsUTF8(), which caches the UTF-8 representation, itself, create new ref we'll dec below
209 if((sig_obj = PyUnicode_AsEncodedString(so, "utf-8", "strict"))) // !new ref!
210 sig_ptr = PyBytes_AS_STRING(sig_obj); // Borrowed pointer
211 #endif
212 } else if ( DcPyString_Check(so) )
213 sig_ptr = DcPyString_AsString(so); // @@@ test py 2
214
215
216
217 if (!sig_ptr)
218 return PyErr_Format( PyExc_RuntimeError, "signature is NULL" );
219
220
221 dcReset(gpCall);
222 dcMode(gpCall, DC_CALL_C_DEFAULT);
223
224 for (ch = *sig_ptr; ch != '\0' && ch != DC_SIGCHAR_ENDARG; ch = *++sig_ptr)
225 {
226 PyObject* po;
227
228 if (pos > ts)
229 return PyErr_Format( PyExc_RuntimeError, "expecting more arguments" );
230
231 po = PyTuple_GetItem(args, pos);
232
233 ++pos; // incr here, code below uses it as 1-based argument index for error strings
234
235 switch(ch)
236 {
237 case DC_SIGCHAR_CC_PREFIX:
238 {
239 if(*(sig_ptr+1) != '\0')
240 {
241 DCint mode = dcGetModeFromCCSigChar(*++sig_ptr);
242 if(mode != DC_ERROR_UNSUPPORTED_MODE)
243 dcMode(gpCall, mode);
244 }
245 --pos; // didn't count as arg
246 }
247 break;
248
249 case DC_SIGCHAR_BOOL:
250 if ( !PyBool_Check(po) )
251 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a bool", pos );
252 dcArgBool(gpCall, (Py_True == po) ? DC_TRUE : DC_FALSE);
253 break;
254
255 case DC_SIGCHAR_CHAR:
256 case DC_SIGCHAR_UCHAR:
257 {
258 DCchar c;
259 if ( PyUnicode_Check(po) )
260 {
261 #if (PY_VERSION_HEX < 0x03030000)
262 Py_UNICODE cu;
263 if (PyUnicode_GET_SIZE(po) != 1)
264 #else
265 Py_UCS4 cu;
266 if (PyUnicode_GET_LENGTH(po) != 1)
267 #endif
268 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a str with length of 1 (a char string)", pos );
269
270 #if (PY_VERSION_HEX < 0x03030000)
271 cu = PyUnicode_AS_UNICODE(po)[0];
272 #else
273 cu = PyUnicode_ReadChar(po, 0);
274 #endif
275 // check against UCHAR_MAX in every case b/c Py_UCS4 is unsigned
276 if ( (cu > UCHAR_MAX))
277 return PyErr_Format( PyExc_RuntimeError, "arg %d out of range - expecting a char code", pos );
278 c = (DCchar) cu;
279 }
280 else if ( DcPyString_Check(po) )
281 {
282 size_t l;
283 char* s;
284 l = DcPyString_GET_SIZE(po);
285 if (l != 1)
286 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a str with length of 1 (a char string)", pos );
287 s = DcPyString_AsString(po);
288 c = (DCchar) s[0];
289 }
290 else if ( DcPyInt_Check(po) )
291 {
292 long l = DcPyInt_AsLong(po);
293 if (ch == DC_SIGCHAR_CHAR && (l < CHAR_MIN || l > CHAR_MAX))
294 return PyErr_Format( PyExc_RuntimeError, "arg %d out of range - expecting %d <= arg <= %d, got %ld", pos, CHAR_MIN, CHAR_MAX, l );
295 if (ch == DC_SIGCHAR_UCHAR && (l < 0 || l > UCHAR_MAX))
296 return PyErr_Format( PyExc_RuntimeError, "arg %d out of range - expecting 0 <= arg <= %d, got %ld", pos, UCHAR_MAX, l );
297 c = (DCchar) l;
298 }
299 else
300 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a char", pos );
301 dcArgChar(gpCall, c);
302 }
303 break;
304
305 case DC_SIGCHAR_SHORT:
306 {
307 long l;
308 if ( !DcPyInt_Check(po) )
309 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting an int", pos );
310 l = DcPyInt_AS_LONG(po);
311 if (l < SHRT_MIN || l > SHRT_MAX)
312 return PyErr_Format( PyExc_RuntimeError, "arg %d out of range - expecting %d <= arg <= %d, got %ld", pos, SHRT_MIN, SHRT_MAX, l );
313 dcArgShort(gpCall, (DCshort)l);
314 }
315 break;
316
317 case DC_SIGCHAR_USHORT:
318 {
319 long l;
320 if ( !DcPyInt_Check(po) )
321 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting an int", pos );
322 l = DcPyInt_AS_LONG(po);
323 if (l < 0 || l > USHRT_MAX)
324 return PyErr_Format( PyExc_RuntimeError, "arg %d out of range - expecting 0 <= arg <= %d, got %ld", pos, USHRT_MAX, l );
325 dcArgShort(gpCall, (DCshort)l);
326 }
327 break;
328
329 case DC_SIGCHAR_INT:
330 case DC_SIGCHAR_UINT:
331 if ( !DcPyInt_Check(po) )
332 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting an int", pos );
333 dcArgInt(gpCall, (DCint) DcPyInt_AS_LONG(po));
334 break;
335
336 case DC_SIGCHAR_LONG:
337 case DC_SIGCHAR_ULONG:
338 if ( !DcPyInt_Check(po) )
339 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting an int", pos );
340 dcArgLong(gpCall, (DClong) PyLong_AsLong(po));
341 break;
342
343 case DC_SIGCHAR_LONGLONG:
344 case DC_SIGCHAR_ULONGLONG:
345 #if PY_MAJOR_VERSION < 3
346 if ( PyInt_Check(po) )
347 dcArgLongLong(gpCall, (DClonglong) PyInt_AS_LONG(po));
348 else
349 #endif
350 if ( !PyLong_Check(po) )
351 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting " EXPECT_LONG_TYPE_STR, pos );
352 dcArgLongLong(gpCall, (DClonglong)PyLong_AsLongLong(po));
353 break;
354
355 case DC_SIGCHAR_FLOAT:
356 if (!PyFloat_Check(po))
357 return PyErr_Format( PyExc_RuntimeError, "arg %d - expeecting a float", pos );
358 dcArgFloat(gpCall, (float)PyFloat_AsDouble(po));
359 break;
360
361 case DC_SIGCHAR_DOUBLE:
362 if (!PyFloat_Check(po))
363 return PyErr_Format( PyExc_RuntimeError, "arg %d - expeecting a float", pos );
364 dcArgDouble(gpCall, PyFloat_AsDouble(po));
365 break;
366
367 case DC_SIGCHAR_POINTER: // this will only accept integers or mutable array types (meaning only bytearray)
368 {
369 DCpointer p;
370 if ( PyByteArray_Check(po) )
371 p = (DCpointer) PyByteArray_AsString(po); // adds an extra '\0', but that's ok
372 #if PY_MAJOR_VERSION < 3
373 else if ( PyInt_Check(po) )
374 p = (DCpointer) PyInt_AS_LONG(po);
375 #endif
376 else if ( PyLong_Check(po) )
377 p = (DCpointer) PyLong_AsVoidPtr(po);
378 else if ( po == Py_None )
379 p = NULL;
380 else
381 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a promoting pointer-type (int, bytearray)", pos );
382 dcArgPointer(gpCall, p);
383 }
384 break;
385
386 case DC_SIGCHAR_STRING: // strings are considered to be immutable objects
387 {
388 PyObject* bo = NULL;
389 const char* p;
390 size_t s;
391 if ( PyUnicode_Check(po) )
392 {
393 if(n_str_aux >= NUM_AUX_STRS)
394 return PyErr_Format( PyExc_RuntimeError, "too many arguments (implementation limit of %d new UTF-8 string references reached) - abort", n_str_aux );
395
396 #if defined(PYUNICODE_CACHES_UTF8)
397 p = PyUnicode_AsUTF8(po);
398 #else
399 // w/o PyUnicode_AsUTF8(), which caches the UTF-8 representation, itself, create new ref we'll dec below
400 if((bo = PyUnicode_AsEncodedString(po, "utf-8", "strict"))) // !new ref!
401 p = PyBytes_AS_STRING(bo); // Borrowed pointer
402 #endif
403 } else if ( DcPyString_Check(po) )
404 p = DcPyString_AsString(po);
405 else if ( PyByteArray_Check(po) )
406 p = (DCpointer) PyByteArray_AsString(po); // adds an extra '\0', but that's ok //@@@ not sure if allowed to modify
407 else
408 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a str", pos );
409
410 // p points in any case to a buffer that shouldn't be modified, so pass a copy to dyncall (cleaned up after call)
411 s = strlen(p)+1;
412 str_aux[n_str_aux] = malloc(s);
413 strncpy(str_aux[n_str_aux], p, s);
414 Py_XDECREF(bo);
415 dcArgPointer(gpCall, (DCpointer)str_aux[n_str_aux++]);
416 }
417 break;
418
419 default:
420 return PyErr_Format( PyExc_RuntimeError, "unknown signature character '%c'", ch);
421 }
422 }
423
424 if (pos != ts)
425 return PyErr_Format( PyExc_RuntimeError, "too many arguments");
426
427 if (ch == '\0')
428 return PyErr_Format( PyExc_RuntimeError, "return value missing in signature");
429
430
431 ch = *++sig_ptr;
432 switch(ch)
433 {
434 // every line creates a new reference passed back to python
435 case DC_SIGCHAR_VOID: dcCallVoid (gpCall, pfunc); Py_RETURN_NONE; // !new ref!
436 case DC_SIGCHAR_BOOL: if(dcCallBool (gpCall, pfunc)){Py_RETURN_TRUE;}else{Py_RETURN_FALSE;} // !new ref!
437 case DC_SIGCHAR_CHAR: return Py_BuildValue("b", dcCallChar (gpCall, pfunc)); // !new ref!
438 case DC_SIGCHAR_UCHAR: return Py_BuildValue("B", dcCallChar (gpCall, pfunc)); // !new ref!
439 case DC_SIGCHAR_SHORT: return Py_BuildValue("h", dcCallShort (gpCall, pfunc)); // !new ref!
440 case DC_SIGCHAR_USHORT: return Py_BuildValue("H", dcCallShort (gpCall, pfunc)); // !new ref!
441 case DC_SIGCHAR_INT: return Py_BuildValue("i", dcCallInt (gpCall, pfunc)); // !new ref!
442 case DC_SIGCHAR_UINT: return Py_BuildValue("I", dcCallInt (gpCall, pfunc)); // !new ref!
443 case DC_SIGCHAR_LONG: return Py_BuildValue("l", dcCallLong (gpCall, pfunc)); // !new ref!
444 case DC_SIGCHAR_ULONG: return Py_BuildValue("k", dcCallLong (gpCall, pfunc)); // !new ref!
445 case DC_SIGCHAR_LONGLONG: return Py_BuildValue("L", dcCallLongLong(gpCall, pfunc)); // !new ref!
446 case DC_SIGCHAR_ULONGLONG: return Py_BuildValue("K", dcCallLongLong(gpCall, pfunc)); // !new ref!
447 case DC_SIGCHAR_FLOAT: return Py_BuildValue("f", dcCallFloat (gpCall, pfunc)); // !new ref!
448 case DC_SIGCHAR_DOUBLE: return Py_BuildValue("d", dcCallDouble (gpCall, pfunc)); // !new ref!
449 case DC_SIGCHAR_STRING: return Py_BuildValue("s", dcCallPointer (gpCall, pfunc)); // !new ref!
450 case DC_SIGCHAR_POINTER: return Py_BuildValue("n", dcCallPointer (gpCall, pfunc)); // !new ref!
451 default: return PyErr_Format(PyExc_RuntimeError, "invalid return type signature");
452 }
453
454 #if !defined(PYUNICODE_CACHES_UTF8)
455 Py_XDECREF(sig_obj);
456 #endif
457 }
458
459
460 static PyObject*
461 pydc_call(PyObject* self, PyObject* args)
462 {
463 int i;
464 n_str_aux = 0;
465 PyObject* o = pydc_call_impl(self, args);
466 for(i = 0; i<n_str_aux; ++i)
467 free(str_aux[i]);
468 return o;
469 }
470
471
472 // module deinit
473 static void deinit_pydc(void* x)
474 {
475 if(gpCall) {
476 dcFree(gpCall);
477 gpCall = NULL;
478 }
479 }
480
481
482 #define PYDC_TO_STR_(x) #x
483 #define PYDC_TO_STR(x) PYDC_TO_STR_(x)
484 #define PYDC_CONCAT_(x, y) x ## y
485 #define PYDC_CONCAT(x, y) PYDC_CONCAT_(x, y)
486
487 #define PYDC_MOD_NAME pydc
488 #define PYDC_MOD_NAME_STR PYDC_TO_STR(PYDC_MOD_NAME)
489 #define PYDC_MOD_DESC_STR "dyncall bindings for python"
490
491 #if PY_MAJOR_VERSION >= 3
492 # define PY_MOD_INIT_FUNC_NAME PYDC_CONCAT(PyInit_, PYDC_MOD_NAME)
493 #else
494 # define PY_MOD_INIT_FUNC_NAME PYDC_CONCAT(init, PYDC_MOD_NAME)
495 #endif
496
497
498 PyMODINIT_FUNC
499 PY_MOD_INIT_FUNC_NAME(void)
500 {
501 static PyMethodDef pydcMethods[] = {
502 {"load", pydc_load, METH_VARARGS, "load library" },
503 {"find", pydc_find, METH_VARARGS, "find symbols" },
504 {"free", pydc_free, METH_VARARGS, "free library" },
505 {"get_path", pydc_get_path, METH_VARARGS, "get library path"},
506 {"call", pydc_call, METH_VARARGS, "call function" },
507 {NULL,NULL,0,NULL}
508 };
509
510 PyObject* m;
511 #if PY_MAJOR_VERSION >= 3
512 static struct PyModuleDef moddef = { PyModuleDef_HEAD_INIT, PYDC_MOD_NAME_STR, PYDC_MOD_DESC_STR, -1, pydcMethods, NULL, NULL, NULL, deinit_pydc };
513 m = PyModule_Create(&moddef);
514 #else
515 m = Py_InitModule3(PYDC_MOD_NAME_STR, pydcMethods, PYDC_MOD_DESC_STR);
516 // NOTE: there is no way to pass a pointer to deinit_pydc - see PEP 3121 for details
517 #endif
518
519 if(m)
520 gpCall = dcNewCallVM(4096); //@@@ one shared callvm for the entire module, this is not reentrant
521
522 #if PY_MAJOR_VERSION >= 3
523 return m;
524 #endif
525 }
526