Commit | Line | Data |
---|---|---|
920dae64 AT |
1 | /* ------------------------------------------------------------ |
2 | * Primitive Types | |
3 | * ------------------------------------------------------------ */ | |
4 | ||
5 | /* | |
6 | Define the SWIG_As/From methods for the basic types. In many | |
7 | cases, these method are just aliases of the original python As/From | |
8 | methods. In the other cases, some extra work is needed. | |
9 | */ | |
10 | ||
11 | %fragment(SWIG_From_frag(signed char),"header") { | |
12 | SWIG_define(SWIG_From(signed char), PyInt_FromLong) | |
13 | } | |
14 | ||
15 | %fragment(SWIG_From_frag(unsigned char),"header") { | |
16 | SWIG_define(SWIG_From(unsigned char), PyInt_FromLong) | |
17 | } | |
18 | ||
19 | %fragment(SWIG_From_frag(short),"header") { | |
20 | SWIG_define(SWIG_From(short), PyInt_FromLong) | |
21 | } | |
22 | ||
23 | %fragment(SWIG_From_frag(unsigned short),"header") { | |
24 | SWIG_define(SWIG_From(unsigned short), PyInt_FromLong) | |
25 | } | |
26 | ||
27 | %fragment(SWIG_From_frag(int),"header") { | |
28 | SWIG_define(SWIG_From(int), PyInt_FromLong) | |
29 | } | |
30 | ||
31 | %fragment(SWIG_From_frag(long),"header") { | |
32 | SWIG_define(SWIG_From(long), PyInt_FromLong) | |
33 | } | |
34 | ||
35 | %fragment(SWIG_From_frag(float),"header") { | |
36 | SWIG_define(SWIG_From(float), PyFloat_FromDouble) | |
37 | } | |
38 | ||
39 | %fragment(SWIG_From_frag(double),"header") { | |
40 | SWIG_define(SWIG_From(double), PyFloat_FromDouble) | |
41 | } | |
42 | ||
43 | /* | |
44 | Here, we have all the complex AsVal/From methods | |
45 | */ | |
46 | ||
47 | %fragment("<limits.h>","header") %{ | |
48 | #include <limits.h> | |
49 | %} | |
50 | ||
51 | %fragment(SWIG_AsVal_frag(unsigned long),"header") { | |
52 | SWIGINTERN int | |
53 | SWIG_AsVal(unsigned long)(PyObject *obj, unsigned long *val) | |
54 | { | |
55 | if (PyLong_Check(obj)) { | |
56 | unsigned long v = PyLong_AsUnsignedLong(obj); | |
57 | if (!PyErr_Occurred()) { | |
58 | if (val) *val = v; | |
59 | return 1; | |
60 | } else { | |
61 | if (!val) PyErr_Clear(); | |
62 | return 0; | |
63 | } | |
64 | } | |
65 | if (PyInt_Check(obj)) { | |
66 | long v = PyInt_AsLong(obj); | |
67 | if (v >= 0) { | |
68 | if (val) *val = v; | |
69 | return 1; | |
70 | } | |
71 | } | |
72 | if (val) { | |
73 | SWIG_type_error("unsigned long", obj); | |
74 | } | |
75 | return 0; | |
76 | } | |
77 | } | |
78 | ||
79 | %fragment("SWIG_CheckLongInRange","header", | |
80 | fragment="<limits.h>") { | |
81 | SWIGINTERN int | |
82 | SWIG_CheckLongInRange(long value, long min_value, long max_value, | |
83 | const char *errmsg) | |
84 | { | |
85 | if (value < min_value) { | |
86 | if (errmsg) { | |
87 | PyErr_Format(PyExc_OverflowError, | |
88 | "value %ld is less than '%s' minimum %ld", | |
89 | value, errmsg, min_value); | |
90 | } | |
91 | return 0; | |
92 | } else if (value > max_value) { | |
93 | if (errmsg) { | |
94 | PyErr_Format(PyExc_OverflowError, | |
95 | "value %ld is greater than '%s' maximum %ld", | |
96 | value, errmsg, max_value); | |
97 | } | |
98 | return 0; | |
99 | } | |
100 | return 1; | |
101 | } | |
102 | } | |
103 | ||
104 | %fragment("SWIG_CheckUnsignedLongInRange","header", | |
105 | fragment="<limits.h>") { | |
106 | SWIGINTERNINLINE int | |
107 | SWIG_CheckUnsignedLongInRange(unsigned long value, | |
108 | unsigned long max_value, | |
109 | const char *errmsg) | |
110 | { | |
111 | if (value > max_value) { | |
112 | if (errmsg) { | |
113 | PyErr_Format(PyExc_OverflowError, | |
114 | "value %lu is greater than '%s' minimum %lu", | |
115 | value, errmsg, max_value); | |
116 | } | |
117 | return 0; | |
118 | } | |
119 | return 1; | |
120 | } | |
121 | } | |
122 | ||
123 | ||
124 | %fragment(SWIG_AsVal_frag(double),"header") { | |
125 | SWIGINTERN int | |
126 | SWIG_AsVal(double)(PyObject *obj, double *val) | |
127 | { | |
128 | if (PyFloat_Check(obj)) { | |
129 | if (val) *val = PyFloat_AsDouble(obj); | |
130 | return 1; | |
131 | } | |
132 | if (PyInt_Check(obj)) { | |
133 | if (val) *val = PyInt_AsLong(obj); | |
134 | return 1; | |
135 | } | |
136 | if (PyLong_Check(obj)) { | |
137 | double v = PyLong_AsDouble(obj); | |
138 | if (!PyErr_Occurred()) { | |
139 | if (val) *val = v; | |
140 | return 1; | |
141 | } else { | |
142 | if (!val) PyErr_Clear(); | |
143 | return 0; | |
144 | } | |
145 | } | |
146 | if (val) { | |
147 | SWIG_type_error("double", obj); | |
148 | } | |
149 | return 0; | |
150 | } | |
151 | } | |
152 | ||
153 | %fragment(SWIG_AsVal_frag(long),"header") { | |
154 | SWIGINTERN int | |
155 | SWIG_AsVal(long)(PyObject * obj, long* val) | |
156 | { | |
157 | if (PyLong_Check(obj)) { | |
158 | long v = PyLong_AsLong(obj); | |
159 | if (!PyErr_Occurred()) { | |
160 | if (val) *val = v; | |
161 | return 1; | |
162 | } else { | |
163 | if (!val) PyErr_Clear(); | |
164 | return 0; | |
165 | } | |
166 | } | |
167 | if (PyInt_Check(obj)) { | |
168 | if (val) *val = PyInt_AsLong(obj); | |
169 | return 1; | |
170 | } | |
171 | if (val) { | |
172 | SWIG_type_error("long", obj); | |
173 | } | |
174 | return 0; | |
175 | } | |
176 | } | |
177 | ||
178 | ||
179 | %fragment(SWIG_From_frag(long long),"header", | |
180 | fragment="<limits.h>") { | |
181 | SWIGINTERNINLINE PyObject* | |
182 | SWIG_From(long long)(long long value) | |
183 | { | |
184 | return ((value < LONG_MIN) || (value > LONG_MAX)) ? | |
185 | PyLong_FromLongLong(value) | |
186 | : PyInt_FromLong(SWIG_numeric_cast(value,long)); | |
187 | } | |
188 | } | |
189 | ||
190 | ||
191 | %fragment(SWIG_From_frag(unsigned long long),"header", | |
192 | fragment="<limits.h>") { | |
193 | SWIGINTERNINLINE PyObject* | |
194 | SWIG_From(unsigned long long)(unsigned long long value) | |
195 | { | |
196 | return (value > LONG_MAX) ? | |
197 | PyLong_FromUnsignedLongLong(value) : | |
198 | PyInt_FromLong(SWIG_numeric_cast(value,long)); | |
199 | } | |
200 | } | |
201 | ||
202 | %fragment(SWIG_AsVal_frag(long long),"header") { | |
203 | SWIGINTERN int | |
204 | SWIG_AsVal(long long)(PyObject *obj, long long *val) | |
205 | { | |
206 | if (PyLong_Check(obj)) { | |
207 | long long v = PyLong_AsLongLong(obj); | |
208 | if (!PyErr_Occurred()) { | |
209 | if (val) *val = v; | |
210 | return 1; | |
211 | } else { | |
212 | if (!val) PyErr_Clear(); | |
213 | return 0; | |
214 | } | |
215 | } | |
216 | if (PyInt_Check(obj)) { | |
217 | if (val) *val = PyInt_AsLong(obj); | |
218 | return 1; | |
219 | } | |
220 | if (val) { | |
221 | SWIG_type_error("long long", obj); | |
222 | } | |
223 | return 0; | |
224 | } | |
225 | } | |
226 | ||
227 | %fragment(SWIG_AsVal_frag(unsigned long long),"header", | |
228 | fragment=SWIG_AsVal_frag(unsigned long)) { | |
229 | SWIGINTERN int | |
230 | SWIG_AsVal(unsigned long long)(PyObject *obj, unsigned long long *val) | |
231 | { | |
232 | unsigned long v; | |
233 | if (PyLong_Check(obj)) { | |
234 | unsigned long long v = PyLong_AsUnsignedLongLong(obj); | |
235 | if (!PyErr_Occurred()) { | |
236 | if (val) *val = v; | |
237 | return 1; | |
238 | } else { | |
239 | if (!val) PyErr_Clear(); | |
240 | return 0; | |
241 | } | |
242 | } | |
243 | if (SWIG_AsVal(unsigned long)(obj,&v)) { | |
244 | if (val) *val = v; | |
245 | return 1; | |
246 | } else { | |
247 | PyErr_Clear(); | |
248 | } | |
249 | if (val) { | |
250 | SWIG_type_error("unsigned long long", obj); | |
251 | } | |
252 | return 0; | |
253 | } | |
254 | } | |
255 | ||
256 | %fragment(SWIG_From_frag(unsigned long),"header") { | |
257 | SWIGINTERNINLINE PyObject* | |
258 | SWIG_From(unsigned long)(unsigned long value) | |
259 | { | |
260 | return (value > LONG_MAX) ? | |
261 | PyLong_FromUnsignedLong(value) | |
262 | : PyInt_FromLong(SWIG_numeric_cast(value,long)); | |
263 | } | |
264 | } | |
265 | ||
266 | %fragment(SWIG_AsVal_frag(signed char),"header", | |
267 | fragment="SWIG_CheckLongInRange", | |
268 | fragment=SWIG_AsVal_frag(long)) { | |
269 | SWIGINTERN int | |
270 | SWIG_AsVal(signed char)(PyObject *obj, signed char *val) | |
271 | { | |
272 | const char* errmsg = val ? "signed char" : (char*) 0; | |
273 | long v; | |
274 | if (SWIG_AsVal(long)(obj, &v)) { | |
275 | if (SWIG_CheckLongInRange(v, SCHAR_MIN, SCHAR_MAX, errmsg)) { | |
276 | if (val) *val = SWIG_numeric_cast(v, signed char); | |
277 | return 1; | |
278 | } else { | |
279 | return 0; | |
280 | } | |
281 | } else { | |
282 | PyErr_Clear(); | |
283 | } | |
284 | if (val) { | |
285 | SWIG_type_error(errmsg, obj); | |
286 | } | |
287 | return 0; | |
288 | } | |
289 | } | |
290 | ||
291 | %fragment(SWIG_AsVal_frag(short),"header", | |
292 | fragment="SWIG_CheckLongInRange", | |
293 | fragment=SWIG_AsVal_frag(long)) { | |
294 | SWIGINTERN int | |
295 | SWIG_AsVal(short)(PyObject *obj, short *val) | |
296 | { | |
297 | const char* errmsg = val ? "short" : (char*)0; | |
298 | long v; | |
299 | if (SWIG_AsVal(long)(obj, &v)) { | |
300 | if (SWIG_CheckLongInRange(v, SHRT_MIN, SHRT_MAX, errmsg)) { | |
301 | if (val) *val = SWIG_numeric_cast(v, short); | |
302 | return 1; | |
303 | } else { | |
304 | return 0; | |
305 | } | |
306 | } else { | |
307 | PyErr_Clear(); | |
308 | } | |
309 | if (val) { | |
310 | SWIG_type_error(errmsg, obj); | |
311 | } | |
312 | return 0; | |
313 | } | |
314 | } | |
315 | ||
316 | /* need range checks */ | |
317 | ||
318 | %fragment(SWIG_AsVal_frag(int),"header", | |
319 | fragment="SWIG_CheckLongInRange", | |
320 | fragment=SWIG_AsVal_frag(long)) { | |
321 | %#if INT_MAX != LONG_MAX | |
322 | SWIGINTERN int | |
323 | SWIG_AsVal(int)(PyObject *obj, int *val) | |
324 | { | |
325 | const char* errmsg = val ? "int" : (char*)0; | |
326 | long v; | |
327 | if (SWIG_AsVal(long)(obj, &v)) { | |
328 | if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) { | |
329 | if (val) *val = SWIG_numeric_cast(v, int); | |
330 | return 1; | |
331 | } else { | |
332 | return 0; | |
333 | } | |
334 | } else { | |
335 | PyErr_Clear(); | |
336 | } | |
337 | if (val) { | |
338 | SWIG_type_error(errmsg, obj); | |
339 | } | |
340 | return 0; | |
341 | } | |
342 | %#else | |
343 | SWIGINTERNINLINE int | |
344 | SWIG_AsVal(int)(PyObject *obj, int *val) | |
345 | { | |
346 | return SWIG_AsVal(long)(obj,(long*)val); | |
347 | } | |
348 | %#endif | |
349 | } | |
350 | ||
351 | %fragment(SWIG_AsVal_frag(unsigned int),"header", | |
352 | fragment="SWIG_CheckUnsignedLongInRange", | |
353 | fragment=SWIG_AsVal_frag(unsigned long)) { | |
354 | %#if UINT_MAX != ULONG_MAX | |
355 | SWIGINTERN int | |
356 | SWIG_AsVal(unsigned int)(PyObject *obj, unsigned int *val) | |
357 | { | |
358 | const char* errmsg = val ? "unsigned int" : (char*)0; | |
359 | unsigned long v; | |
360 | if (SWIG_AsVal(unsigned long)(obj, &v)) { | |
361 | if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) { | |
362 | if (val) *val = SWIG_numeric_cast(v, unsigned int); | |
363 | return 1; | |
364 | } | |
365 | } else { | |
366 | PyErr_Clear(); | |
367 | } | |
368 | if (val) { | |
369 | SWIG_type_error(errmsg, obj); | |
370 | } | |
371 | return 0; | |
372 | } | |
373 | %#else | |
374 | SWIGINTERNINLINE unsigned int | |
375 | SWIG_AsVal(unsigned int)(PyObject *obj, unsigned int *val) | |
376 | { | |
377 | return SWIG_AsVal(unsigned long)(obj,(unsigned long *)val); | |
378 | } | |
379 | %#endif | |
380 | } | |
381 | ||
382 | %fragment(SWIG_From_frag(unsigned int),"header", | |
383 | fragment=SWIG_From_frag(long), | |
384 | fragment=SWIG_From_frag(unsigned long)) { | |
385 | %#if UINT_MAX < LONG_MAX | |
386 | SWIG_define(SWIG_From(unsigned int), SWIG_From(long)) | |
387 | %#else | |
388 | SWIG_define(SWIG_From(unsigned int), SWIG_From(unsigned long)) | |
389 | %#endif | |
390 | } | |
391 | ||
392 | %fragment(SWIG_AsVal_frag(unsigned char),"header", | |
393 | fragment=SWIG_AsVal_frag(unsigned long), | |
394 | fragment="SWIG_CheckUnsignedLongInRange") { | |
395 | SWIGINTERN int | |
396 | SWIG_AsVal(unsigned char)(PyObject *obj, unsigned char *val) | |
397 | { | |
398 | const char* errmsg = val ? "unsigned char" : (char*)0; | |
399 | unsigned long v; | |
400 | if (SWIG_AsVal(unsigned long)(obj, &v)) { | |
401 | if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) { | |
402 | if (val) *val = SWIG_numeric_cast(v, unsigned char); | |
403 | return 1; | |
404 | } else { | |
405 | return 0; | |
406 | } | |
407 | } else { | |
408 | PyErr_Clear(); | |
409 | } | |
410 | if (val) { | |
411 | SWIG_type_error(errmsg, obj); | |
412 | } | |
413 | return 0; | |
414 | } | |
415 | } | |
416 | ||
417 | %fragment(SWIG_AsVal_frag(unsigned short),"header", | |
418 | fragment="SWIG_CheckUnsignedLongInRange", | |
419 | fragment=SWIG_AsVal_frag(unsigned long)) { | |
420 | SWIGINTERN int | |
421 | SWIG_AsVal(unsigned short)(PyObject *obj, unsigned short *val) | |
422 | { | |
423 | const char* errmsg = val ? "unsigned short" : (char*)0; | |
424 | unsigned long v; | |
425 | if (SWIG_AsVal(unsigned long)(obj, &v)) { | |
426 | if (SWIG_CheckUnsignedLongInRange(v, USHRT_MAX, errmsg)) { | |
427 | if (val) *val = SWIG_numeric_cast(v, unsigned short); | |
428 | return 1; | |
429 | } else { | |
430 | return 0; | |
431 | } | |
432 | } else { | |
433 | PyErr_Clear(); | |
434 | } | |
435 | if (val) { | |
436 | SWIG_type_error(errmsg, obj); | |
437 | } | |
438 | return 0; | |
439 | } | |
440 | } | |
441 | ||
442 | ||
443 | %fragment("SWIG_CheckDoubleInRange","header") { | |
444 | %#include <float.h> | |
445 | SWIGINTERN int | |
446 | SWIG_CheckDoubleInRange(double value, double min_value, | |
447 | double max_value, const char* errmsg) | |
448 | { | |
449 | if (value < min_value) { | |
450 | if (errmsg) { | |
451 | PyErr_Format(PyExc_OverflowError, | |
452 | "value %g is less than %s minimum %g", | |
453 | value, errmsg, min_value); | |
454 | } | |
455 | return 0; | |
456 | } else if (value > max_value) { | |
457 | if (errmsg) { | |
458 | PyErr_Format(PyExc_OverflowError, | |
459 | "value %g is greater than %s maximum %g", | |
460 | value, errmsg, max_value); | |
461 | } | |
462 | return 0; | |
463 | } | |
464 | return 1; | |
465 | } | |
466 | } | |
467 | ||
468 | %fragment(SWIG_AsVal_frag(float),"header", | |
469 | fragment="SWIG_CheckDoubleInRange", | |
470 | fragment=SWIG_AsVal_frag(double)) { | |
471 | SWIGINTERN int | |
472 | SWIG_AsVal(float)(PyObject *obj, float *val) | |
473 | { | |
474 | const char* errmsg = val ? "float" : (char*)0; | |
475 | double v; | |
476 | if (SWIG_AsVal(double)(obj, &v)) { | |
477 | if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) { | |
478 | if (val) *val = SWIG_numeric_cast(v, float); | |
479 | return 1; | |
480 | } else { | |
481 | return 0; | |
482 | } | |
483 | } else { | |
484 | PyErr_Clear(); | |
485 | } | |
486 | if (val) { | |
487 | SWIG_type_error(errmsg, obj); | |
488 | } | |
489 | return 0; | |
490 | } | |
491 | } | |
492 | ||
493 | %fragment(SWIG_From_frag(char),"header") { | |
494 | SWIGINTERNINLINE PyObject* | |
495 | SWIG_From(char)(char c) | |
496 | { | |
497 | return PyString_FromStringAndSize(&c,1); | |
498 | } | |
499 | } | |
500 | ||
501 | %fragment(SWIG_AsVal_frag(char),"header", | |
502 | fragment="SWIG_AsCharArray", | |
503 | fragment="SWIG_CheckLongInRange", | |
504 | fragment=SWIG_AsVal_frag(long)) { | |
505 | SWIGINTERN int | |
506 | SWIG_AsVal(char)(PyObject *obj, char *val) | |
507 | { | |
508 | const char* errmsg = val ? "char" : (char*)0; | |
509 | long v; | |
510 | if (SWIG_AsVal(long)(obj, &v)) { | |
511 | if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) { | |
512 | if (val) *val = SWIG_numeric_cast(v, char); | |
513 | return 1; | |
514 | } else { | |
515 | return 0; | |
516 | } | |
517 | } else { | |
518 | PyErr_Clear(); | |
519 | return SWIG_AsCharArray(obj, val, 1); | |
520 | } | |
521 | } | |
522 | } | |
523 | ||
524 | %fragment(SWIG_From_frag(wchar_t),"header") { | |
525 | SWIGINTERNINLINE PyObject* | |
526 | SWIG_From(wchar_t)(wchar_t c) | |
527 | { | |
528 | return PyUnicode_FromWideChar(&c, 1); | |
529 | } | |
530 | } | |
531 | ||
532 | %fragment(SWIG_AsVal_frag(wchar_t),"header", | |
533 | fragment="SWIG_AsWCharArray", | |
534 | fragment="SWIG_CheckLongInRange", | |
535 | fragment=SWIG_AsVal_frag(long)) { | |
536 | %#include <wchar.h> | |
537 | SWIGINTERN int | |
538 | SWIG_AsVal(wchar_t)(PyObject *obj, wchar_t *val) | |
539 | { | |
540 | const char* errmsg = val ? "wchar_t" : (char*)0; | |
541 | long v; | |
542 | if (SWIG_AsVal(long)(obj, &v)) { | |
543 | if (SWIG_CheckLongInRange(v, WCHAR_MIN, WCHAR_MAX, errmsg)) { | |
544 | if (val) *val = SWIG_numeric_cast(v, wchar_t); | |
545 | return 1; | |
546 | } else { | |
547 | return 0; | |
548 | } | |
549 | } else { | |
550 | PyErr_Clear(); | |
551 | return SWIG_AsWCharArray(obj, val, 1); | |
552 | } | |
553 | } | |
554 | } | |
555 | ||
556 | %fragment(SWIG_From_frag(bool),"header") { | |
557 | SWIGINTERNINLINE PyObject* | |
558 | SWIG_From(bool)(bool value) | |
559 | { | |
560 | PyObject *obj = value ? Py_True : Py_False; | |
561 | Py_INCREF(obj); | |
562 | return obj; | |
563 | } | |
564 | } | |
565 | ||
566 | %fragment(SWIG_AsVal_frag(bool),"header", | |
567 | fragment=SWIG_AsVal_frag(int)) { | |
568 | SWIGINTERN int | |
569 | SWIG_AsVal(bool)(PyObject *obj, bool *val) | |
570 | { | |
571 | if (obj == Py_True) { | |
572 | if (val) *val = true; | |
573 | return 1; | |
574 | } | |
575 | if (obj == Py_False) { | |
576 | if (val) *val = false; | |
577 | return 1; | |
578 | } | |
579 | int res = 0; | |
580 | if (SWIG_AsVal(int)(obj, &res)) { | |
581 | if (val) *val = res ? true : false; | |
582 | return 1; | |
583 | } else { | |
584 | PyErr_Clear(); | |
585 | } | |
586 | if (val) { | |
587 | SWIG_type_error("bool", obj); | |
588 | } | |
589 | return 0; | |
590 | } | |
591 | } | |
592 | ||
593 | ||
594 | /* ------------------------------------------------------------ | |
595 | * typemap for primitive type with no pointer representation | |
596 | * ------------------------------------------------------------ */ | |
597 | ||
598 | %define %typemap_primitive(Code, ...) | |
599 | %typemap_asvalfromn(SWIG_arg(Code), __VA_ARGS__); | |
600 | %enddef | |
601 | ||
602 | ||
603 | ||
604 | /* ------------------------------------------------------------ | |
605 | * Primitive Type Macros | |
606 | * ------------------------------------------------------------ */ | |
607 | ||
608 | /* useful macros to derive typemap declarations from primitive types */ | |
609 | ||
610 | %define _apply_macro(macro, arg, ...) | |
611 | #if #__VA_ARGS__ != "" | |
612 | macro(__VA_ARGS__,arg); | |
613 | #else | |
614 | macro(arg); | |
615 | #endif | |
616 | %enddef | |
617 | ||
618 | /* Apply macro to the order types */ | |
619 | %define %apply_ctypes(Macro,...) | |
620 | _apply_macro(Macro, bool , __VA_ARGS__); | |
621 | _apply_macro(Macro, signed char , __VA_ARGS__); | |
622 | _apply_macro(Macro, unsigned char , __VA_ARGS__); | |
623 | _apply_macro(Macro, short , __VA_ARGS__); | |
624 | _apply_macro(Macro, unsigned short , __VA_ARGS__); | |
625 | _apply_macro(Macro, int , __VA_ARGS__); | |
626 | _apply_macro(Macro, unsigned int , __VA_ARGS__); | |
627 | _apply_macro(Macro, long , __VA_ARGS__); | |
628 | _apply_macro(Macro, unsigned long , __VA_ARGS__); | |
629 | _apply_macro(Macro, long long , __VA_ARGS__); | |
630 | _apply_macro(Macro, unsigned long long , __VA_ARGS__); | |
631 | _apply_macro(Macro, float , __VA_ARGS__); | |
632 | _apply_macro(Macro, double , __VA_ARGS__); | |
633 | _apply_macro(Macro, char , __VA_ARGS__); | |
634 | _apply_macro(Macro, wchar_t , __VA_ARGS__); | |
635 | %enddef | |
636 | ||
637 | /* apply the Macro(Type) to all the C++ types */ | |
638 | %define %apply_cpptypes(Macro,...) | |
639 | %apply_ctypes(Macro, __VA_ARGS__) | |
640 | _apply_macro(Macro, std::string, __VA_ARGS__); | |
641 | _apply_macro(Macro, std::complex<float> , __VA_ARGS__); | |
642 | _apply_macro(Macro, std::complex<double> , __VA_ARGS__); | |
643 | %enddef | |
644 | ||
645 | /* apply the Macro2(Type1, Type2) to all the C++ types */ | |
646 | %define %apply_cpptypes_2(Macro2) | |
647 | %apply_cpptypes(%apply_cpptypes, Macro2) | |
648 | %enddef | |
649 | ||
650 | %define %apply_checkctypes(Macro) | |
651 | Macro(SWIG_CCode(BOOL), bool); | |
652 | Macro(SWIG_CCode(INT8), signed char); | |
653 | Macro(SWIG_CCode(UINT8), unsigned char); | |
654 | Macro(SWIG_CCode(INT16), short); | |
655 | Macro(SWIG_CCode(UINT16), unsigned short); | |
656 | Macro(SWIG_CCode(INT32), int); | |
657 | Macro(SWIG_CCode(UINT32), unsigned int); | |
658 | Macro(SWIG_CCode(INT64), long); | |
659 | Macro(SWIG_CCode(UINT64), unsigned long); | |
660 | Macro(SWIG_CCode(INT128), long long); | |
661 | Macro(SWIG_CCode(UINT128), unsigned long long); | |
662 | Macro(SWIG_CCode(FLOAT), float); | |
663 | Macro(SWIG_CCode(DOUBLE), double); | |
664 | Macro(SWIG_CCode(CHAR), char); | |
665 | Macro(SWIG_CCode(UNICHAR), wchar_t); | |
666 | %enddef | |
667 | ||
668 | /* ------------------------------------------------------------ | |
669 | * Apply the primitive typemap for all the types with checkcode | |
670 | * ------------------------------------------------------------ */ | |
671 | ||
672 | %apply_checkctypes(%typemap_primitive) | |
673 | ||
674 |