Mercurial > pub > dyncall > bindings
annotate python/pydc/pydc.c @ 62:4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
author | Tassilo Philipp |
---|---|
date | Sat, 18 May 2024 15:33:54 +0200 |
parents | c5a69c454963 |
children | 9b6cdffd30dd |
rev | line source |
---|---|
0 | 1 /****************************************************************************** |
2 ** | |
3 ** pydc - python dyncall package | |
4 ** | |
5 ** python extension package in C | |
28 | 6 ** Copyright 2007-2016 Daniel Adler |
61 | 7 ** 2018-2023 Tassilo Philipp |
0 | 8 ** |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
9 ** See README.txt for details (about changes, how to use, etc.). |
0 | 10 ** |
11 *****************************************************************************/ | |
12 | |
13 #include <Python.h> | |
14 #include "dynload.h" | |
15 #include <limits.h> | |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
16 #include <assert.h> |
0 | 17 |
28 | 18 |
19 | |
20 #if ( (PY_VERSION_HEX < 0x02070000) \ | |
21 || ((PY_VERSION_HEX >= 0x03000000) \ | |
22 && (PY_VERSION_HEX < 0x03010000)) ) | |
30 | 23 # define DcPyCObject_FromVoidPtr(ptr, dtor) PyCObject_FromVoidPtr((ptr), (dtor)) // !new ref! |
28 | 24 # define DcPyCObject_AsVoidPtr(ppobj) PyCObject_AsVoidPtr((ppobj)) |
25 # define DcPyCObject_SetVoidPtr(ppobj, ptr) PyCObject_SetVoidPtr((ppobj), (ptr)) | |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
26 # define DcPyCObject_Check(ppobj) PyCObject_Check((ppobj)) |
28 | 27 #else |
28 # define USE_CAPSULE_API | |
30 | 29 # define DcPyCObject_FromVoidPtr(ptr, dtor) PyCapsule_New((ptr), NULL, (dtor)) // !new ref! |
28 | 30 # define DcPyCObject_AsVoidPtr(ppobj) PyCapsule_GetPointer((ppobj), NULL) |
29 | 31 # 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? |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
32 # define DcPyCObject_Check(ppobj) PyCapsule_CheckExact((ppobj)) |
28 | 33 #endif |
34 | |
43
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
35 #if(PY_VERSION_HEX >= 0x03030000) |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
36 # define PYUNICODE_CACHES_UTF8 |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
37 #endif |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
38 |
28 | 39 #if PY_MAJOR_VERSION >= 3 |
29 | 40 # define EXPECT_LONG_TYPE_STR "an int" |
28 | 41 # define DcPyString_GET_SIZE PyBytes_GET_SIZE |
42 # define DcPyString_Check PyBytes_Check | |
43 # define DcPyString_AsString PyBytes_AsString | |
44 # define DcPyInt_Check PyLong_Check | |
45 # define DcPyInt_AsLong PyLong_AsLong | |
46 # define DcPyInt_AS_LONG PyLong_AS_LONG | |
47 #else | |
29 | 48 # define EXPECT_LONG_TYPE_STR "an int or a long" |
28 | 49 # define DcPyString_GET_SIZE PyString_GET_SIZE |
50 # define DcPyString_Check PyString_Check | |
51 # define DcPyString_AsString PyString_AsString | |
52 # define DcPyInt_Check PyInt_Check | |
53 # define DcPyInt_AsLong PyInt_AsLong | |
54 # define DcPyInt_AS_LONG PyInt_AS_LONG | |
55 #endif | |
56 | |
0 | 57 /* PyCObject destructor callback for libhandle */ |
58 | |
28 | 59 #if defined(USE_CAPSULE_API) |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
60 static void free_library(PyObject* capsule) |
28 | 61 { |
29 | 62 void* libhandle = PyCapsule_GetPointer(capsule, NULL); |
28 | 63 #else |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
64 static void free_library(void* libhandle) |
0 | 65 { |
28 | 66 #endif |
29 | 67 if (libhandle != 0) |
68 dlFreeLibrary(libhandle); | |
0 | 69 } |
70 | |
28 | 71 |
0 | 72 /* load function */ |
73 | |
74 static PyObject* | |
75 pydc_load(PyObject* self, PyObject* args) | |
76 { | |
29 | 77 const char* libpath; |
78 void* libhandle; | |
0 | 79 |
32
2089026debae
- allowing 'None' as arg for pydc.load, effectively resulting in dlLoadLibrary(NULL), which is own process
Tassilo Philipp
parents:
31
diff
changeset
|
80 if (!PyArg_ParseTuple(args,"z", &libpath)) |
31 | 81 return PyErr_Format(PyExc_RuntimeError, "libpath argument (str) missing"); |
0 | 82 |
29 | 83 libhandle = dlLoadLibrary(libpath); |
0 | 84 |
29 | 85 if (!libhandle) |
86 return PyErr_Format(PyExc_RuntimeError, "dlLoadLibrary('%s') failed", libpath); | |
0 | 87 |
30 | 88 return DcPyCObject_FromVoidPtr(libhandle, &free_library); // !new ref! |
0 | 89 } |
90 | |
91 /* find function */ | |
92 | |
93 static PyObject* | |
94 pydc_find(PyObject* self, PyObject* args) | |
95 { | |
29 | 96 PyObject* pcobj; |
97 const char* symbol; | |
98 void* libhandle; | |
99 void* funcptr; | |
0 | 100 |
29 | 101 if (!PyArg_ParseTuple(args, "Os", &pcobj, &symbol)) |
102 return PyErr_Format(PyExc_RuntimeError, "argument mismatch"); | |
16
a40084782546
- added support for more return values to python binding
cslag
parents:
5
diff
changeset
|
103 |
29 | 104 libhandle = DcPyCObject_AsVoidPtr(pcobj); |
105 if (!libhandle) | |
106 return PyErr_Format(PyExc_RuntimeError, "libhandle is null"); | |
0 | 107 |
29 | 108 funcptr = dlFindSymbol(libhandle, symbol); |
109 if (!funcptr) | |
110 return PyErr_Format(PyExc_RuntimeError, "symbol '%s' not found", symbol); | |
0 | 111 |
30 | 112 return DcPyCObject_FromVoidPtr(funcptr, NULL); // !new ref! |
0 | 113 } |
114 | |
115 /* free function */ | |
116 | |
117 static PyObject* | |
118 pydc_free(PyObject* self, PyObject* args) | |
119 { | |
29 | 120 PyObject* pcobj; |
121 void* libhandle; | |
0 | 122 |
29 | 123 if (!PyArg_ParseTuple(args, "O", &pcobj)) |
124 return PyErr_Format(PyExc_RuntimeError, "argument mismatch"); | |
16
a40084782546
- added support for more return values to python binding
cslag
parents:
5
diff
changeset
|
125 |
29 | 126 libhandle = DcPyCObject_AsVoidPtr(pcobj); |
127 if (!libhandle) | |
128 return PyErr_Format(PyExc_RuntimeError, "libhandle is NULL"); | |
0 | 129 |
29 | 130 dlFreeLibrary(libhandle); |
131 DcPyCObject_SetVoidPtr(pcobj, NULL); | |
28 | 132 |
30 | 133 //don't think I need to release it, as the pyobj is not equivalent to the held handle |
134 //Py_XDECREF(pcobj); // release ref from pydc_load() | |
135 | |
29 | 136 Py_RETURN_NONE; |
0 | 137 } |
138 | |
33
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
139 /* get_path function */ |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
140 |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
141 static PyObject* |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
142 pydc_get_path(PyObject* self, PyObject* args) |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
143 { |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
144 PyObject* pcobj; |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
145 PyObject* retobj; |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
146 void* libhandle; |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
147 char* path; |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
148 int path_bufSize; |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
149 |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
150 if (!PyArg_ParseTuple(args, "O", &pcobj)) |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
151 return PyErr_Format(PyExc_RuntimeError, "argument mismatch"); |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
152 |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
153 libhandle = (pcobj == Py_None)?NULL:DcPyCObject_AsVoidPtr(pcobj); |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
154 path_bufSize = dlGetLibraryPath(libhandle, NULL, 0); |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
155 if (!path_bufSize) |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
156 return PyErr_Format(PyExc_RuntimeError, "library path cannot be found"); |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
157 |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
158 path = malloc(path_bufSize); |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
159 if (path_bufSize != dlGetLibraryPath(libhandle, path, path_bufSize)) { |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
160 free(path); |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
161 return PyErr_Format(PyExc_RuntimeError, "library path cannot be queried"); |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
162 } |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
163 |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
164 retobj = Py_BuildValue("s", path); // !new ref! @@@ UTF-8 input... |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
165 free(path); |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
166 return retobj; |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
167 } |
ba47a3d709d7
- pydc: added support to get libhandle's path
Tassilo Philipp
parents:
32
diff
changeset
|
168 |
28 | 169 |
0 | 170 #include "dyncall.h" |
171 #include "dyncall_signature.h" | |
172 | |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
173 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
174 /* helpers */ |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
175 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
176 static inline PyObject* py2dcchar(DCchar* c, PyObject* po, int u, int pos) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
177 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
178 if ( PyUnicode_Check(po) ) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
179 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
180 #if (PY_VERSION_HEX < 0x03030000) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
181 Py_UNICODE cu; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
182 if (PyUnicode_GET_SIZE(po) != 1) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
183 #else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
184 Py_UCS4 cu; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
185 if (PyUnicode_GET_LENGTH(po) != 1) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
186 #endif |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
187 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a str with length of 1 (a char string)", pos ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
188 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
189 #if (PY_VERSION_HEX < 0x03030000) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
190 cu = PyUnicode_AS_UNICODE(po)[0]; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
191 #else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
192 cu = PyUnicode_ReadChar(po, 0); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
193 #endif |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
194 // check against UCHAR_MAX in every case b/c Py_UCS4 is unsigned |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
195 if ( (cu > UCHAR_MAX)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
196 return PyErr_Format( PyExc_RuntimeError, "arg %d out of range - expecting a char code", pos ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
197 *c = (DCchar) cu; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
198 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
199 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
200 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
201 if ( DcPyString_Check(po) ) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
202 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
203 size_t l; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
204 char* s; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
205 l = DcPyString_GET_SIZE(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
206 if (l != 1) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
207 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a str with length of 1 (a char string)", pos ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
208 s = DcPyString_AsString(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
209 *c = (DCchar) s[0]; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
210 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
211 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
212 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
213 if ( DcPyInt_Check(po) ) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
214 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
215 long l = DcPyInt_AsLong(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
216 if (u && (l < 0 || l > UCHAR_MAX)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
217 return PyErr_Format( PyExc_RuntimeError, "arg %d out of range - expecting 0 <= arg <= %d, got %ld", pos, UCHAR_MAX, l ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
218 if (!u && (l < CHAR_MIN || l > CHAR_MAX)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
219 return PyErr_Format( PyExc_RuntimeError, "arg %d out of range - expecting %d <= arg <= %d, got %ld", pos, CHAR_MIN, CHAR_MAX, l ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
220 *c = (DCchar) l; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
221 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
222 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
223 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
224 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a char", pos ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
225 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
226 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
227 static inline PyObject* py2dcshort(DCshort* s, PyObject* po, int u, int pos) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
228 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
229 long l; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
230 if ( !DcPyInt_Check(po) ) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
231 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting an int", pos ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
232 l = DcPyInt_AS_LONG(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
233 if (u && (l < 0 || l > USHRT_MAX)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
234 return PyErr_Format( PyExc_RuntimeError, "arg %d out of range - expecting 0 <= arg <= %d, got %ld", pos, USHRT_MAX, l ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
235 if (!u && (l < SHRT_MIN || l > SHRT_MAX)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
236 return PyErr_Format( PyExc_RuntimeError, "arg %d out of range - expecting %d <= arg <= %d, got %ld", pos, SHRT_MIN, SHRT_MAX, l ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
237 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
238 *s = (DCshort)l; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
239 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
240 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
241 |
62
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
242 static inline PyObject* py2dcint(DCint* i, PyObject* po, int u, int pos) |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
243 { |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
244 long long ll; |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
245 if ( !DcPyInt_Check(po) ) |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
246 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting an int", pos ); |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
247 ll = (DClonglong) PyLong_AsLongLong(po); |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
248 if (u && (ll < 0 || ll > UINT_MAX)) |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
249 return PyErr_Format( PyExc_RuntimeError, "arg %lld out of range - expecting 0 <= arg <= %ld, got %lld", pos, UINT_MAX, ll ); |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
250 if (!u && (ll < INT_MIN || ll > INT_MAX)) |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
251 return PyErr_Format( PyExc_RuntimeError, "arg %lld out of range - expecting %ld <= arg <= %ld, got %lld", pos, INT_MIN, INT_MAX, ll ); |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
252 |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
253 *i = (DCint)ll; |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
254 return po; |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
255 } |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
256 |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
257 static inline PyObject* py2dclong(DClong* l, PyObject* po, int u, int pos) |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
258 { |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
259 long long ll; |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
260 if ( !DcPyInt_Check(po) ) |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
261 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting an int", pos ); |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
262 ll = (DClonglong) PyLong_AsLongLong(po); |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
263 if (u && (ll < 0 || ll > ULONG_MAX)) //@@@ on lp64, this is a bad comparison |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
264 return PyErr_Format( PyExc_RuntimeError, "arg %lld out of range - expecting 0 <= arg <= %ld, got %lld", pos, ULONG_MAX, ll ); |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
265 if (!u && (ll < LONG_MIN || ll > LONG_MAX)) |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
266 return PyErr_Format( PyExc_RuntimeError, "arg %lld out of range - expecting %ld <= arg <= %ld, got %lld", pos, LONG_MIN, LONG_MAX, ll ); |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
267 |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
268 *l = (DClong)ll; |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
269 return po; |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
270 } |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
271 |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
272 static inline PyObject* py2dclonglong(DClonglong* ll, PyObject* po, int pos) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
273 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
274 #if PY_MAJOR_VERSION < 3 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
275 if ( PyInt_Check(po) ) { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
276 *ll = (DClonglong) PyInt_AS_LONG(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
277 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
278 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
279 #endif |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
280 if ( !PyLong_Check(po) ) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
281 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting " EXPECT_LONG_TYPE_STR, pos ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
282 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
283 *ll = (DClonglong) PyLong_AsLongLong(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
284 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
285 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
286 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
287 static inline PyObject* py2dcpointer(DCpointer* p, PyObject* po, int pos) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
288 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
289 if ( PyByteArray_Check(po) ) { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
290 *p = (DCpointer) PyByteArray_AsString(po); // adds an extra '\0', but that's ok |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
291 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
292 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
293 #if PY_MAJOR_VERSION < 3 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
294 if ( PyInt_Check(po) ) { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
295 *p = (DCpointer) PyInt_AS_LONG(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
296 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
297 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
298 #endif |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
299 if ( PyLong_Check(po) ) { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
300 *p = (DCpointer) PyLong_AsVoidPtr(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
301 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
302 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
303 if ( po == Py_None ) { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
304 *p = NULL; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
305 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
306 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
307 if ( DcPyCObject_Check(po) ) { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
308 *p = DcPyCObject_AsVoidPtr(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
309 return po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
310 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
311 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
312 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a promoting pointer-type (int), mutable array (bytearray) or callback func handle (int, created with new_callback())", pos ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
313 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
314 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
315 |
30 | 316 DCCallVM* gpCall = NULL; |
0 | 317 |
43
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
318 // helper to temporarily copy string arguments |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
319 #define NUM_AUX_STRS 64 |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
320 static int n_str_aux; |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
321 static char* str_aux[NUM_AUX_STRS]; // hard limit, most likely enough and checked for below @@@ugly though |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
322 |
29 | 323 |
0 | 324 /* call function */ |
325 | |
326 static PyObject* | |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
327 pydc_call_impl(PyObject* self, PyObject* args) /* implementation, called by wrapper func pydc_call() */ |
0 | 328 { |
59 | 329 const char *sig_ptr = NULL; |
29 | 330 char ch; |
331 int pos, ts; | |
332 void* pfunc; | |
333 | |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
334 pos = 0; |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
335 ts = PyTuple_Size(args); |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
336 if (ts < 2) |
29 | 337 return PyErr_Format(PyExc_RuntimeError, "argument mismatch"); |
338 | |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
339 // get ptr to func to call |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
340 pfunc = DcPyCObject_AsVoidPtr(PyTuple_GetItem(args, pos++)); |
29 | 341 if (!pfunc) |
342 return PyErr_Format( PyExc_RuntimeError, "function pointer is NULL" ); | |
16
a40084782546
- added support for more return values to python binding
cslag
parents:
5
diff
changeset
|
343 |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
344 // get signature |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
345 #if !defined(PYUNICODE_CACHES_UTF8) |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
346 PyObject* sig_obj = NULL; |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
347 #endif |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
348 PyObject* so = PyTuple_GetItem(args, pos++); |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
349 if ( PyUnicode_Check(so) ) |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
350 { |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
351 #if defined(PYUNICODE_CACHES_UTF8) |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
352 sig_ptr = PyUnicode_AsUTF8(so); |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
353 #else |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
354 // w/o PyUnicode_AsUTF8(), which caches the UTF-8 representation, itself, create new ref we'll dec below |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
355 if((sig_obj = PyUnicode_AsEncodedString(so, "utf-8", "strict"))) // !new ref! |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
356 sig_ptr = PyBytes_AS_STRING(sig_obj); // Borrowed pointer |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
357 #endif |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
358 } else if ( DcPyString_Check(so) ) |
49 | 359 sig_ptr = DcPyString_AsString(so); |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
360 |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
361 |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
362 |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
363 if (!sig_ptr) |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
364 return PyErr_Format( PyExc_RuntimeError, "signature is NULL" ); |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
365 |
29 | 366 |
367 dcReset(gpCall); | |
37 | 368 dcMode(gpCall, DC_CALL_C_DEFAULT); |
28 | 369 |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
370 for (ch = *sig_ptr; ch != '\0' && ch != DC_SIGCHAR_ENDARG; ch = *++sig_ptr) |
29 | 371 { |
372 PyObject* po; | |
373 | |
374 if (pos > ts) | |
375 return PyErr_Format( PyExc_RuntimeError, "expecting more arguments" ); | |
28 | 376 |
29 | 377 po = PyTuple_GetItem(args, pos); |
378 | |
379 ++pos; // incr here, code below uses it as 1-based argument index for error strings | |
0 | 380 |
29 | 381 switch(ch) |
382 { | |
35
75fe1dec0eb4
- added support for signature-based calling convention switch
Tassilo Philipp
parents:
34
diff
changeset
|
383 case DC_SIGCHAR_CC_PREFIX: |
75fe1dec0eb4
- added support for signature-based calling convention switch
Tassilo Philipp
parents:
34
diff
changeset
|
384 { |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
385 if(*(sig_ptr+1) != '\0') |
35
75fe1dec0eb4
- added support for signature-based calling convention switch
Tassilo Philipp
parents:
34
diff
changeset
|
386 { |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
387 DCint mode = dcGetModeFromCCSigChar(*++sig_ptr); |
40 | 388 if(mode != DC_ERROR_UNSUPPORTED_MODE) |
389 dcMode(gpCall, mode); | |
35
75fe1dec0eb4
- added support for signature-based calling convention switch
Tassilo Philipp
parents:
34
diff
changeset
|
390 } |
36 | 391 --pos; // didn't count as arg |
35
75fe1dec0eb4
- added support for signature-based calling convention switch
Tassilo Philipp
parents:
34
diff
changeset
|
392 } |
75fe1dec0eb4
- added support for signature-based calling convention switch
Tassilo Philipp
parents:
34
diff
changeset
|
393 break; |
75fe1dec0eb4
- added support for signature-based calling convention switch
Tassilo Philipp
parents:
34
diff
changeset
|
394 |
29 | 395 case DC_SIGCHAR_BOOL: |
396 if ( !PyBool_Check(po) ) | |
397 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a bool", pos ); | |
398 dcArgBool(gpCall, (Py_True == po) ? DC_TRUE : DC_FALSE); | |
399 break; | |
16
a40084782546
- added support for more return values to python binding
cslag
parents:
5
diff
changeset
|
400 |
29 | 401 case DC_SIGCHAR_CHAR: |
402 case DC_SIGCHAR_UCHAR: | |
403 { | |
404 DCchar c; | |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
405 if(!py2dcchar(&c, po, ch == DC_SIGCHAR_UCHAR, pos)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
406 return NULL; |
29 | 407 dcArgChar(gpCall, c); |
408 } | |
409 break; | |
410 | |
411 case DC_SIGCHAR_SHORT: | |
412 case DC_SIGCHAR_USHORT: | |
413 { | |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
414 DCshort s; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
415 if(!py2dcshort(&s, po, ch == DC_SIGCHAR_USHORT, pos)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
416 return NULL; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
417 dcArgShort(gpCall, s); |
29 | 418 } |
419 break; | |
16
a40084782546
- added support for more return values to python binding
cslag
parents:
5
diff
changeset
|
420 |
29 | 421 case DC_SIGCHAR_INT: |
422 case DC_SIGCHAR_UINT: | |
62
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
423 { |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
424 DCint i; |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
425 if(!py2dcint(&i, po, ch == DC_SIGCHAR_UINT, pos)) |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
426 return NULL; |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
427 dcArgInt(gpCall, i); |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
428 } |
29 | 429 |
430 case DC_SIGCHAR_LONG: | |
431 case DC_SIGCHAR_ULONG: | |
62
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
432 { |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
433 DClong l; |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
434 if(!py2dclong(&l, po, ch == DC_SIGCHAR_ULONG, pos)) |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
435 return NULL; |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
436 dcArgLong(gpCall, l); |
4a9f6c7c09c1
- fix inccorect overflow errors for int (and long on LLP64 systems)
Tassilo Philipp
parents:
61
diff
changeset
|
437 } |
29 | 438 |
439 case DC_SIGCHAR_LONGLONG: | |
440 case DC_SIGCHAR_ULONGLONG: | |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
441 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
442 DClonglong ll; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
443 if(!py2dclonglong(&ll, po, pos)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
444 return NULL; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
445 dcArgLongLong(gpCall, ll); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
446 } |
29 | 447 break; |
448 | |
449 case DC_SIGCHAR_FLOAT: | |
450 if (!PyFloat_Check(po)) | |
51 | 451 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a float", pos ); |
29 | 452 dcArgFloat(gpCall, (float)PyFloat_AsDouble(po)); |
453 break; | |
454 | |
455 case DC_SIGCHAR_DOUBLE: | |
456 if (!PyFloat_Check(po)) | |
51 | 457 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a float", pos ); |
29 | 458 dcArgDouble(gpCall, PyFloat_AsDouble(po)); |
459 break; | |
0 | 460 |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
461 case DC_SIGCHAR_POINTER: // this will only accept integers, mutable array types (meaning only bytearray) or tuples describing a callback |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
462 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
463 DCpointer p; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
464 if(!py2dcpointer(&p, po, pos)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
465 return NULL; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
466 dcArgPointer(gpCall, p); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
467 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
468 break; |
0 | 469 |
34 | 470 case DC_SIGCHAR_STRING: // strings are considered to be immutable objects |
29 | 471 { |
30 | 472 PyObject* bo = NULL; |
29 | 473 const char* p; |
43
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
474 if ( PyUnicode_Check(po) ) |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
475 { |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
476 #if defined(PYUNICODE_CACHES_UTF8) |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
477 p = PyUnicode_AsUTF8(po); |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
478 #else |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
479 // w/o PyUnicode_AsUTF8(), which caches the UTF-8 representation, itself, create new ref we'll dec below |
30 | 480 if((bo = PyUnicode_AsEncodedString(po, "utf-8", "strict"))) // !new ref! |
29 | 481 p = PyBytes_AS_STRING(bo); // Borrowed pointer |
43
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
482 #endif |
34 | 483 } else if ( DcPyString_Check(po) ) |
43
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
484 p = DcPyString_AsString(po); |
34 | 485 else if ( PyByteArray_Check(po) ) |
486 p = (DCpointer) PyByteArray_AsString(po); // adds an extra '\0', but that's ok //@@@ not sure if allowed to modify | |
61 | 487 else if ( po == Py_None ) |
488 p = NULL; | |
34 | 489 else |
31 | 490 return PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a str", pos ); |
34 | 491 |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
492 if(n_str_aux >= NUM_AUX_STRS) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
493 return PyErr_Format( PyExc_RuntimeError, "too many arguments (implementation limit of %d new UTF-8 string references reached) - abort", n_str_aux ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
494 |
61 | 495 if(!p) |
496 str_aux[n_str_aux] = NULL; | |
497 else { | |
498 // p points in every case to a buffer that shouldn't be modified, so pass a copy to dyncall (cleaned up after call) | |
499 size_t s = strlen(p)+1; | |
500 str_aux[n_str_aux] = malloc(s); | |
501 strncpy(str_aux[n_str_aux], p, s); | |
502 } | |
30 | 503 Py_XDECREF(bo); |
43
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
504 dcArgPointer(gpCall, (DCpointer)str_aux[n_str_aux++]); |
29 | 505 } |
506 break; | |
507 | |
508 default: | |
509 return PyErr_Format( PyExc_RuntimeError, "unknown signature character '%c'", ch); | |
510 } | |
511 } | |
512 | |
513 if (pos != ts) | |
514 return PyErr_Format( PyExc_RuntimeError, "too many arguments"); | |
515 | |
516 if (ch == '\0') | |
517 return PyErr_Format( PyExc_RuntimeError, "return value missing in signature"); | |
518 | |
519 | |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
520 ch = *++sig_ptr; |
29 | 521 switch(ch) |
522 { | |
30 | 523 // every line creates a new reference passed back to python |
524 case DC_SIGCHAR_VOID: dcCallVoid (gpCall, pfunc); Py_RETURN_NONE; // !new ref! | |
525 case DC_SIGCHAR_BOOL: if(dcCallBool (gpCall, pfunc)){Py_RETURN_TRUE;}else{Py_RETURN_FALSE;} // !new ref! | |
526 case DC_SIGCHAR_CHAR: return Py_BuildValue("b", dcCallChar (gpCall, pfunc)); // !new ref! | |
527 case DC_SIGCHAR_UCHAR: return Py_BuildValue("B", dcCallChar (gpCall, pfunc)); // !new ref! | |
528 case DC_SIGCHAR_SHORT: return Py_BuildValue("h", dcCallShort (gpCall, pfunc)); // !new ref! | |
529 case DC_SIGCHAR_USHORT: return Py_BuildValue("H", dcCallShort (gpCall, pfunc)); // !new ref! | |
530 case DC_SIGCHAR_INT: return Py_BuildValue("i", dcCallInt (gpCall, pfunc)); // !new ref! | |
531 case DC_SIGCHAR_UINT: return Py_BuildValue("I", dcCallInt (gpCall, pfunc)); // !new ref! | |
532 case DC_SIGCHAR_LONG: return Py_BuildValue("l", dcCallLong (gpCall, pfunc)); // !new ref! | |
533 case DC_SIGCHAR_ULONG: return Py_BuildValue("k", dcCallLong (gpCall, pfunc)); // !new ref! | |
534 case DC_SIGCHAR_LONGLONG: return Py_BuildValue("L", dcCallLongLong(gpCall, pfunc)); // !new ref! | |
535 case DC_SIGCHAR_ULONGLONG: return Py_BuildValue("K", dcCallLongLong(gpCall, pfunc)); // !new ref! | |
536 case DC_SIGCHAR_FLOAT: return Py_BuildValue("f", dcCallFloat (gpCall, pfunc)); // !new ref! | |
537 case DC_SIGCHAR_DOUBLE: return Py_BuildValue("d", dcCallDouble (gpCall, pfunc)); // !new ref! | |
538 case DC_SIGCHAR_STRING: return Py_BuildValue("s", dcCallPointer (gpCall, pfunc)); // !new ref! | |
539 case DC_SIGCHAR_POINTER: return Py_BuildValue("n", dcCallPointer (gpCall, pfunc)); // !new ref! | |
29 | 540 default: return PyErr_Format(PyExc_RuntimeError, "invalid return type signature"); |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
541 // @@@ this could be handled via array lookups of a 256b array instead of switch/case, then share it with callback code if it makes sense |
29 | 542 } |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
543 |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
544 #if !defined(PYUNICODE_CACHES_UTF8) |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
545 Py_XDECREF(sig_obj); |
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
546 #endif |
0 | 547 } |
548 | |
549 | |
43
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
550 static PyObject* |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
551 pydc_call(PyObject* self, PyObject* args) |
43
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
552 { |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
553 int i; |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
554 n_str_aux = 0; |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
555 PyObject* o = pydc_call_impl(self, args); |
43
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
556 for(i = 0; i<n_str_aux; ++i) |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
557 free(str_aux[i]); |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
558 return o; |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
559 } |
1086ca649715
- fixed use after free issue with string handling (keeping strings as copy until after call)
Tassilo Philipp
parents:
40
diff
changeset
|
560 |
28 | 561 |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
562 #include "dyncall_callback.h" |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
563 #include "dyncall_args.h" |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
564 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
565 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
566 /* PyCObject destructor callback for callback obj */ |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
567 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
568 #if defined(USE_CAPSULE_API) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
569 static void free_callback(PyObject* capsule) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
570 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
571 void* cb = PyCapsule_GetPointer(capsule, NULL); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
572 #else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
573 static void free_callback(void* cb) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
574 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
575 #endif |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
576 if (cb != 0) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
577 dcbFreeCallback(cb); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
578 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
579 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
580 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
581 struct callback_userdata { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
582 PyObject* f; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
583 char sig[]; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
584 }; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
585 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
586 /* generic callback handler dispatching to python */ |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
587 static char handle_py_callbacks(DCCallback* pcb, DCArgs* args, DCValue* result, void* userdata) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
588 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
589 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
590 struct callback_userdata* x = (struct callback_userdata*)userdata; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
591 const char* sig_ptr = x->sig; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
592 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
593 Py_ssize_t n_args = ((PyCodeObject*)PyFunction_GetCode(x->f))->co_argcount; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
594 Py_ssize_t pos = 0; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
595 PyObject* py_args = PyTuple_New(n_args); // !new ref! |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
596 PyObject* po; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
597 char ch; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
598 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
599 if(py_args) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
600 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
601 // @@@ we could do the below actually by using dyncall itself, piecing together python's sig string and then dcCallPointer(vm, Py_BuildValue, ...) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
602 for (ch = *sig_ptr; ch != '\0' && ch != DC_SIGCHAR_ENDARG && pos < n_args; ch = *++sig_ptr) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
603 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
604 switch(ch) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
605 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
606 case DC_SIGCHAR_CC_PREFIX: assert(*(sig_ptr+1) == DC_SIGCHAR_CC_DEFAULT); /* not handling callbacks to anything but default callconf */ break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
607 case DC_SIGCHAR_BOOL: PyTuple_SET_ITEM(py_args, pos++, PyBool_FromLong(dcbArgBool (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
608 case DC_SIGCHAR_CHAR: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("b", dcbArgChar (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
609 case DC_SIGCHAR_UCHAR: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("B", dcbArgUChar (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
610 case DC_SIGCHAR_SHORT: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("h", dcbArgShort (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
611 case DC_SIGCHAR_USHORT: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("H", dcbArgUShort (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
612 case DC_SIGCHAR_INT: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("i", dcbArgInt (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
613 case DC_SIGCHAR_UINT: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("I", dcbArgUInt (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
614 case DC_SIGCHAR_LONG: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("l", dcbArgLong (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
615 case DC_SIGCHAR_ULONG: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("k", dcbArgULong (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
616 case DC_SIGCHAR_LONGLONG: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("L", dcbArgLongLong (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
617 case DC_SIGCHAR_ULONGLONG: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("K", dcbArgULongLong(args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
618 case DC_SIGCHAR_FLOAT: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("f", dcbArgFloat (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
619 case DC_SIGCHAR_DOUBLE: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("d", dcbArgDouble (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
620 case DC_SIGCHAR_STRING: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("s", dcbArgPointer (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
621 case DC_SIGCHAR_POINTER: PyTuple_SET_ITEM(py_args, pos++, Py_BuildValue("n", dcbArgPointer (args))); break; // !new ref! (but "stolen" by SET_ITEM) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
622 default: /* will lead to "signature not matching" error */ pos = n_args; break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
623 // @@@ this could be handled via array lookups of a 256b array instead of switch/case, then share it with call code (for returns) if it makes sense |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
624 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
625 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
626 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
627 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
628 // we must be at end of sigstring, here |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
629 if(ch == ')') |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
630 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
631 po = PyEval_CallObject(x->f, py_args); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
632 if(po) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
633 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
634 // return value type |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
635 ch = *++sig_ptr; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
636 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
637 // @@@ copypasta from above, as a bit different, NO error handling right now, NO handling of 'Z', ... |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
638 switch(ch) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
639 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
640 case DC_SIGCHAR_BOOL: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
641 if ( !PyBool_Check(po) ) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
642 PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a bool", -1 ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
643 else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
644 result->B = ((Py_True == po) ? DC_TRUE : DC_FALSE); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
645 break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
646 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
647 case DC_SIGCHAR_CHAR: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
648 case DC_SIGCHAR_UCHAR: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
649 py2dcchar(&result->c, po, ch == DC_SIGCHAR_UCHAR, -1); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
650 break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
651 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
652 case DC_SIGCHAR_SHORT: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
653 case DC_SIGCHAR_USHORT: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
654 py2dcshort(&result->s, po, ch == DC_SIGCHAR_USHORT, -1); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
655 break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
656 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
657 case DC_SIGCHAR_INT: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
658 case DC_SIGCHAR_UINT: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
659 if ( !DcPyInt_Check(po) ) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
660 PyErr_Format( PyExc_RuntimeError, "arg %d - expecting an int", -1 ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
661 else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
662 result->i = (DCint) DcPyInt_AS_LONG(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
663 break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
664 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
665 case DC_SIGCHAR_LONG: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
666 case DC_SIGCHAR_ULONG: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
667 if ( !DcPyInt_Check(po) ) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
668 PyErr_Format( PyExc_RuntimeError, "arg %d - expecting an int", -1 ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
669 else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
670 result->j = (DClong) PyLong_AsLong(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
671 break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
672 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
673 case DC_SIGCHAR_LONGLONG: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
674 case DC_SIGCHAR_ULONGLONG: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
675 py2dclonglong(&result->l, po, -1); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
676 break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
677 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
678 case DC_SIGCHAR_FLOAT: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
679 if (!PyFloat_Check(po)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
680 PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a float", -1 ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
681 else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
682 result->f = (float)PyFloat_AsDouble(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
683 break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
684 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
685 case DC_SIGCHAR_DOUBLE: |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
686 if (!PyFloat_Check(po)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
687 PyErr_Format( PyExc_RuntimeError, "arg %d - expecting a float", -1 ); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
688 else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
689 result->d = PyFloat_AsDouble(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
690 break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
691 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
692 case DC_SIGCHAR_POINTER: // this will only accept integers, mutable array types (meaning only bytearray) or tuples describing a callback |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
693 py2dcpointer(&result->p, po, -1); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
694 break; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
695 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
696 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
697 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
698 Py_DECREF(po); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
699 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
700 else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
701 PyErr_SetString(PyExc_RuntimeError, "callback error: unknown error calling back python callback function"); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
702 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
703 else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
704 PyErr_Format(PyExc_RuntimeError, "callback error: python callback doesn't match signature argument count or signature wrong (invalid sig char or return type not specified)"); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
705 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
706 Py_DECREF(py_args); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
707 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
708 else |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
709 PyErr_SetString(PyExc_RuntimeError, "callback error: unknown error creating python arg tuple"); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
710 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
711 // as callbacks might be called repeatedly we don't want the error indicator to pollute other calls, so print |
55
2e8a56976bf8
fixed missing () making branch always be entered
Tassilo Philipp
parents:
54
diff
changeset
|
712 if(PyErr_Occurred()) { |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
713 PyErr_Print(); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
714 return 'v'; // used as return char for errors @@@ unsure if smart, but it would at least indicate that no return value was set |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
715 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
716 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
717 return ch; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
718 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
719 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
720 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
721 /* new callback object function */ |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
722 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
723 static PyObject* |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
724 pydc_new_callback(PyObject* self, PyObject* args) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
725 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
726 PyObject* f; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
727 const char* sig; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
728 struct callback_userdata* ud; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
729 DCCallback* cb; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
730 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
731 if (!PyArg_ParseTuple(args, "sO", &sig, &f) || !PyFunction_Check(f)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
732 return PyErr_Format(PyExc_RuntimeError, "argument mismatch"); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
733 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
734 // pass signature and f (as borrowed ptr) in userdata; not incrementing f's refcount, |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
735 // b/c we can probably expect user making sure callback exists when its needed/called |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
736 ud = malloc(sizeof(struct callback_userdata) + strlen(sig)+1); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
737 cb = dcbNewCallback(sig, handle_py_callbacks, ud); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
738 if(!cb) { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
739 free(ud); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
740 Py_RETURN_NONE; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
741 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
742 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
743 ud->f = f; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
744 strcpy(ud->sig, sig); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
745 return DcPyCObject_FromVoidPtr(cb, &free_callback); // !new ref! |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
746 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
747 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
748 /* free callback object function */ |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
749 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
750 static PyObject* |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
751 pydc_free_callback(PyObject* self, PyObject* args) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
752 { |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
753 PyObject* pcobj; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
754 void* cb; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
755 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
756 if (!PyArg_ParseTuple(args, "O", &pcobj)) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
757 return PyErr_Format(PyExc_RuntimeError, "argument mismatch"); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
758 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
759 cb = DcPyCObject_AsVoidPtr(pcobj); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
760 if (!cb) |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
761 return PyErr_Format(PyExc_RuntimeError, "cbhandle is NULL"); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
762 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
763 free(dcbGetUserData(cb)); // free helper struct callback_userdata |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
764 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
765 dcbFreeCallback(cb); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
766 DcPyCObject_SetVoidPtr(pcobj, NULL); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
767 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
768 //don't think I need to release it, as the pyobj is not equivalent to the held handle |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
769 //Py_XDECREF(pcobj); // release ref from pydc_load() |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
770 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
771 Py_RETURN_NONE; |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
772 } |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
773 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
774 |
60 | 775 /* helper creating a string from a pointer handle (Py_ssize_t, must point to |
776 * string data); this makes it easier to use C functions that allocate memory, | |
777 * retrieve the handle via 'p' in order to call free() on it later, and get the | |
778 * string it points to | |
779 */ | |
780 static PyObject* | |
781 pydc_p2Z(PyObject* self, PyObject* args) | |
782 { | |
783 size_t p; | |
784 if(PyArg_ParseTuple(args, "n", &p)) | |
785 return Py_BuildValue("s", (const char*)p); | |
786 | |
787 Py_RETURN_NONE; | |
788 } | |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
789 |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
790 |
30 | 791 // module deinit |
792 static void deinit_pydc(void* x) | |
793 { | |
794 if(gpCall) { | |
795 dcFree(gpCall); | |
796 gpCall = NULL; | |
797 } | |
798 } | |
28 | 799 |
800 | |
801 #define PYDC_TO_STR_(x) #x | |
802 #define PYDC_TO_STR(x) PYDC_TO_STR_(x) | |
803 #define PYDC_CONCAT_(x, y) x ## y | |
804 #define PYDC_CONCAT(x, y) PYDC_CONCAT_(x, y) | |
805 | |
46
c21d1c2c84e1
- removed pydc.py wrapper overhead (which only called pydcext.so functions, directly, anyways)
Tassilo Philipp
parents:
44
diff
changeset
|
806 #define PYDC_MOD_NAME pydc |
28 | 807 #define PYDC_MOD_NAME_STR PYDC_TO_STR(PYDC_MOD_NAME) |
808 #define PYDC_MOD_DESC_STR "dyncall bindings for python" | |
809 | |
810 #if PY_MAJOR_VERSION >= 3 | |
811 # define PY_MOD_INIT_FUNC_NAME PYDC_CONCAT(PyInit_, PYDC_MOD_NAME) | |
812 #else | |
813 # define PY_MOD_INIT_FUNC_NAME PYDC_CONCAT(init, PYDC_MOD_NAME) | |
814 #endif | |
815 | |
0 | 816 |
817 PyMODINIT_FUNC | |
28 | 818 PY_MOD_INIT_FUNC_NAME(void) |
0 | 819 { |
29 | 820 static PyMethodDef pydcMethods[] = { |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
821 {"load", pydc_load, METH_VARARGS, "load library" }, |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
822 {"find", pydc_find, METH_VARARGS, "find symbols" }, |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
823 {"free", pydc_free, METH_VARARGS, "free library" }, |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
824 {"get_path", pydc_get_path, METH_VARARGS, "get library path" }, |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
825 {"call", pydc_call, METH_VARARGS, "call function" }, |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
826 {"new_callback", pydc_new_callback, METH_VARARGS, "new callback obj" }, // @@@ doc: only functions, not every callable, and only with positional args |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
827 {"free_callback", pydc_free_callback, METH_VARARGS, "free callback obj"}, |
60 | 828 {"p2Z", pydc_p2Z, METH_VARARGS, "ptr to C-string" }, // helper func |
29 | 829 {NULL,NULL,0,NULL} |
830 }; | |
28 | 831 |
29 | 832 PyObject* m; |
28 | 833 #if PY_MAJOR_VERSION >= 3 |
30 | 834 static struct PyModuleDef moddef = { PyModuleDef_HEAD_INIT, PYDC_MOD_NAME_STR, PYDC_MOD_DESC_STR, -1, pydcMethods, NULL, NULL, NULL, deinit_pydc }; |
29 | 835 m = PyModule_Create(&moddef); |
28 | 836 #else |
29 | 837 m = Py_InitModule3(PYDC_MOD_NAME_STR, pydcMethods, PYDC_MOD_DESC_STR); |
30 | 838 // NOTE: there is no way to pass a pointer to deinit_pydc - see PEP 3121 for details |
28 | 839 #endif |
840 | |
54
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
841 /* we convert pointers to python ints via Py_BuildValue('n', ...) which expects Py_ssize_t */ |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
842 assert(sizeof(Py_ssize_t) >= sizeof(void*)); |
918dab7a6606
- added callback support (comes with some bigger refactoring)
Tassilo Philipp
parents:
51
diff
changeset
|
843 |
29 | 844 if(m) |
845 gpCall = dcNewCallVM(4096); //@@@ one shared callvm for the entire module, this is not reentrant | |
28 | 846 |
847 #if PY_MAJOR_VERSION >= 3 | |
29 | 848 return m; |
28 | 849 #endif |
0 | 850 } |
851 |