← Back to branch summary

~ubuntu-branches/ubuntu/edgy/swig1.3/edgy

« back to all changes in this revision

Viewing changes to Lib/python/pyprimtypes.swg

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2005-01-10 09:48:52 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20050110094852-axi555axhj1brbwq
Tags: 1.3.22-5ubuntu2
http://bugs.debian.org/4146
Build using python2.4 and pike7.6. Closes: #4146.

Show diffs side-by-side

added added

removed removed

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