Line data Source code
1 : /* ----------------------------------------------------------------------------
2 : * This file was automatically generated by SWIG (http://www.swig.org).
3 : * Version 3.0.10
4 : *
5 : * This file is not intended to be easily readable and contains a number of
6 : * coding conventions designed to improve portability and efficiency. Do not make
7 : * changes to this file unless you know what you are doing--modify the SWIG
8 : * interface file instead.
9 : * ----------------------------------------------------------------------------- */
10 :
11 : /* -----------------------------------------------------------------------------
12 : * This section contains generic SWIG labels for method/variable
13 : * declarations/attributes, and other compiler dependent labels.
14 : * ----------------------------------------------------------------------------- */
15 :
16 : /* template workaround for compilers that cannot correctly implement the C++ standard */
17 : #ifndef SWIGTEMPLATEDISAMBIGUATOR
18 : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
19 : # define SWIGTEMPLATEDISAMBIGUATOR template
20 : # elif defined(__HP_aCC)
21 : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
22 : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
23 : # define SWIGTEMPLATEDISAMBIGUATOR template
24 : # else
25 : # define SWIGTEMPLATEDISAMBIGUATOR
26 : # endif
27 : #endif
28 :
29 : /* inline attribute */
30 : #ifndef SWIGINLINE
31 : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
32 : # define SWIGINLINE inline
33 : # else
34 : # define SWIGINLINE
35 : # endif
36 : #endif
37 :
38 : /* attribute recognised by some compilers to avoid 'unused' warnings */
39 : #ifndef SWIGUNUSED
40 : # if defined(__GNUC__)
41 : # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
42 : # define SWIGUNUSED __attribute__ ((__unused__))
43 : # else
44 : # define SWIGUNUSED
45 : # endif
46 : # elif defined(__ICC)
47 : # define SWIGUNUSED __attribute__ ((__unused__))
48 : # else
49 : # define SWIGUNUSED
50 : # endif
51 : #endif
52 :
53 : #ifndef SWIG_MSC_UNSUPPRESS_4505
54 : # if defined(_MSC_VER)
55 : # pragma warning(disable : 4505) /* unreferenced local function has been removed */
56 : # endif
57 : #endif
58 :
59 : #ifndef SWIGUNUSEDPARM
60 : # ifdef __cplusplus
61 : # define SWIGUNUSEDPARM(p)
62 : # else
63 : # define SWIGUNUSEDPARM(p) p SWIGUNUSED
64 : # endif
65 : #endif
66 :
67 : /* internal SWIG method */
68 : #ifndef SWIGINTERN
69 : # define SWIGINTERN static SWIGUNUSED
70 : #endif
71 :
72 : /* internal inline SWIG method */
73 : #ifndef SWIGINTERNINLINE
74 : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
75 : #endif
76 :
77 : /* exporting methods */
78 : #if defined(__GNUC__)
79 : # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
80 : # ifndef GCC_HASCLASSVISIBILITY
81 : # define GCC_HASCLASSVISIBILITY
82 : # endif
83 : # endif
84 : #endif
85 :
86 : #ifndef SWIGEXPORT
87 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
88 : # if defined(STATIC_LINKED)
89 : # define SWIGEXPORT
90 : # else
91 : # define SWIGEXPORT __declspec(dllexport)
92 : # endif
93 : # else
94 : # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
95 : # define SWIGEXPORT __attribute__ ((visibility("default")))
96 : # else
97 : # define SWIGEXPORT
98 : # endif
99 : # endif
100 : #endif
101 :
102 : /* calling conventions for Windows */
103 : #ifndef SWIGSTDCALL
104 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
105 : # define SWIGSTDCALL __stdcall
106 : # else
107 : # define SWIGSTDCALL
108 : # endif
109 : #endif
110 :
111 : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
112 : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
113 : # define _CRT_SECURE_NO_DEPRECATE
114 : #endif
115 :
116 : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
117 : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
118 : # define _SCL_SECURE_NO_DEPRECATE
119 : #endif
120 :
121 : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
122 : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
123 : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
124 : #endif
125 :
126 : /* Intel's compiler complains if a variable which was never initialised is
127 : * cast to void, which is a common idiom which we use to indicate that we
128 : * are aware a variable isn't used. So we just silence that warning.
129 : * See: https://github.com/swig/swig/issues/192 for more discussion.
130 : */
131 : #ifdef __INTEL_COMPILER
132 : # pragma warning disable 592
133 : #endif
134 : /* Errors in SWIG */
135 : #define SWIG_UnknownError -1
136 : #define SWIG_IOError -2
137 : #define SWIG_RuntimeError -3
138 : #define SWIG_IndexError -4
139 : #define SWIG_TypeError -5
140 : #define SWIG_DivisionByZero -6
141 : #define SWIG_OverflowError -7
142 : #define SWIG_SyntaxError -8
143 : #define SWIG_ValueError -9
144 : #define SWIG_SystemError -10
145 : #define SWIG_AttributeError -11
146 : #define SWIG_MemoryError -12
147 : #define SWIG_NullReferenceError -13
148 :
149 :
150 : /* -----------------------------------------------------------------------------
151 : * swigrun.swg
152 : *
153 : * This file contains generic C API SWIG runtime support for pointer
154 : * type checking.
155 : * ----------------------------------------------------------------------------- */
156 :
157 : /* This should only be incremented when either the layout of swig_type_info changes,
158 : or for whatever reason, the runtime changes incompatibly */
159 : #define SWIG_RUNTIME_VERSION "4"
160 :
161 : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
162 : #ifdef SWIG_TYPE_TABLE
163 : # define SWIG_QUOTE_STRING(x) #x
164 : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
165 : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
166 : #else
167 : # define SWIG_TYPE_TABLE_NAME
168 : #endif
169 :
170 : /*
171 : You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
172 : creating a static or dynamic library from the SWIG runtime code.
173 : In 99.9% of the cases, SWIG just needs to declare them as 'static'.
174 :
175 : But only do this if strictly necessary, ie, if you have problems
176 : with your compiler or suchlike.
177 : */
178 :
179 : #ifndef SWIGRUNTIME
180 : # define SWIGRUNTIME SWIGINTERN
181 : #endif
182 :
183 : #ifndef SWIGRUNTIMEINLINE
184 : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
185 : #endif
186 :
187 : /* Generic buffer size */
188 : #ifndef SWIG_BUFFER_SIZE
189 : # define SWIG_BUFFER_SIZE 1024
190 : #endif
191 :
192 : /* Flags for pointer conversions */
193 : #define SWIG_POINTER_DISOWN 0x1
194 : #define SWIG_CAST_NEW_MEMORY 0x2
195 :
196 : /* Flags for new pointer objects */
197 : #define SWIG_POINTER_OWN 0x1
198 :
199 :
200 : /*
201 : Flags/methods for returning states.
202 :
203 : The SWIG conversion methods, as ConvertPtr, return an integer
204 : that tells if the conversion was successful or not. And if not,
205 : an error code can be returned (see swigerrors.swg for the codes).
206 :
207 : Use the following macros/flags to set or process the returning
208 : states.
209 :
210 : In old versions of SWIG, code such as the following was usually written:
211 :
212 : if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
213 : // success code
214 : } else {
215 : //fail code
216 : }
217 :
218 : Now you can be more explicit:
219 :
220 : int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
221 : if (SWIG_IsOK(res)) {
222 : // success code
223 : } else {
224 : // fail code
225 : }
226 :
227 : which is the same really, but now you can also do
228 :
229 : Type *ptr;
230 : int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
231 : if (SWIG_IsOK(res)) {
232 : // success code
233 : if (SWIG_IsNewObj(res) {
234 : ...
235 : delete *ptr;
236 : } else {
237 : ...
238 : }
239 : } else {
240 : // fail code
241 : }
242 :
243 : I.e., now SWIG_ConvertPtr can return new objects and you can
244 : identify the case and take care of the deallocation. Of course that
245 : also requires SWIG_ConvertPtr to return new result values, such as
246 :
247 : int SWIG_ConvertPtr(obj, ptr,...) {
248 : if (<obj is ok>) {
249 : if (<need new object>) {
250 : *ptr = <ptr to new allocated object>;
251 : return SWIG_NEWOBJ;
252 : } else {
253 : *ptr = <ptr to old object>;
254 : return SWIG_OLDOBJ;
255 : }
256 : } else {
257 : return SWIG_BADOBJ;
258 : }
259 : }
260 :
261 : Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
262 : more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
263 : SWIG errors code.
264 :
265 : Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
266 : allows to return the 'cast rank', for example, if you have this
267 :
268 : int food(double)
269 : int fooi(int);
270 :
271 : and you call
272 :
273 : food(1) // cast rank '1' (1 -> 1.0)
274 : fooi(1) // cast rank '0'
275 :
276 : just use the SWIG_AddCast()/SWIG_CheckState()
277 : */
278 :
279 : #define SWIG_OK (0)
280 : #define SWIG_ERROR (-1)
281 : #define SWIG_IsOK(r) (r >= 0)
282 : #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
283 :
284 : /* The CastRankLimit says how many bits are used for the cast rank */
285 : #define SWIG_CASTRANKLIMIT (1 << 8)
286 : /* The NewMask denotes the object was created (using new/malloc) */
287 : #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
288 : /* The TmpMask is for in/out typemaps that use temporal objects */
289 : #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
290 : /* Simple returning values */
291 : #define SWIG_BADOBJ (SWIG_ERROR)
292 : #define SWIG_OLDOBJ (SWIG_OK)
293 : #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
294 : #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
295 : /* Check, add and del mask methods */
296 : #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
297 : #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
298 : #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
299 : #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
300 : #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
301 : #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
302 :
303 : /* Cast-Rank Mode */
304 : #if defined(SWIG_CASTRANK_MODE)
305 : # ifndef SWIG_TypeRank
306 : # define SWIG_TypeRank unsigned long
307 : # endif
308 : # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
309 : # define SWIG_MAXCASTRANK (2)
310 : # endif
311 : # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
312 : # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
313 : SWIGINTERNINLINE int SWIG_AddCast(int r) {
314 : return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
315 : }
316 : SWIGINTERNINLINE int SWIG_CheckState(int r) {
317 : return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
318 : }
319 : #else /* no cast-rank mode */
320 : # define SWIG_AddCast(r) (r)
321 : # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
322 : #endif
323 :
324 :
325 : #include <string.h>
326 :
327 : #ifdef __cplusplus
328 : extern "C" {
329 : #endif
330 :
331 : typedef void *(*swig_converter_func)(void *, int *);
332 : typedef struct swig_type_info *(*swig_dycast_func)(void **);
333 :
334 : /* Structure to store information on one type */
335 : typedef struct swig_type_info {
336 : const char *name; /* mangled name of this type */
337 : const char *str; /* human readable name of this type */
338 : swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
339 : struct swig_cast_info *cast; /* linked list of types that can cast into this type */
340 : void *clientdata; /* language specific type data */
341 : int owndata; /* flag if the structure owns the clientdata */
342 : } swig_type_info;
343 :
344 : /* Structure to store a type and conversion function used for casting */
345 : typedef struct swig_cast_info {
346 : swig_type_info *type; /* pointer to type that is equivalent to this type */
347 : swig_converter_func converter; /* function to cast the void pointers */
348 : struct swig_cast_info *next; /* pointer to next cast in linked list */
349 : struct swig_cast_info *prev; /* pointer to the previous cast */
350 : } swig_cast_info;
351 :
352 : /* Structure used to store module information
353 : * Each module generates one structure like this, and the runtime collects
354 : * all of these structures and stores them in a circularly linked list.*/
355 : typedef struct swig_module_info {
356 : swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
357 : size_t size; /* Number of types in this module */
358 : struct swig_module_info *next; /* Pointer to next element in circularly linked list */
359 : swig_type_info **type_initial; /* Array of initially generated type structures */
360 : swig_cast_info **cast_initial; /* Array of initially generated casting structures */
361 : void *clientdata; /* Language specific module data */
362 : } swig_module_info;
363 :
364 : /*
365 : Compare two type names skipping the space characters, therefore
366 : "char*" == "char *" and "Class<int>" == "Class<int >", etc.
367 :
368 : Return 0 when the two name types are equivalent, as in
369 : strncmp, but skipping ' '.
370 : */
371 : SWIGRUNTIME int
372 656 : SWIG_TypeNameComp(const char *f1, const char *l1,
373 : const char *f2, const char *l2) {
374 5476 : for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
375 3095 : while ((*f1 == ' ') && (f1 != l1)) ++f1;
376 3066 : while ((*f2 == ' ') && (f2 != l2)) ++f2;
377 3021 : if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
378 : }
379 45 : return (int)((l1 - f1) - (l2 - f2));
380 : }
381 :
382 : /*
383 : Check type equivalence in a name list like <name1>|<name2>|...
384 : Return 0 if equal, -1 if nb < tb, 1 if nb > tb
385 : */
386 : SWIGRUNTIME int
387 431 : SWIG_TypeCmp(const char *nb, const char *tb) {
388 431 : int equiv = 1;
389 431 : const char* te = tb + strlen(tb);
390 431 : const char* ne = nb;
391 1087 : while (equiv != 0 && *ne) {
392 18976 : for (nb = ne; *ne; ++ne) {
393 9385 : if (*ne == '|') break;
394 : }
395 656 : equiv = SWIG_TypeNameComp(nb, ne, tb, te);
396 656 : if (*ne) ++ne;
397 : }
398 431 : return equiv;
399 : }
400 :
401 : /*
402 : Check type equivalence in a name list like <name1>|<name2>|...
403 : Return 0 if not equal, 1 if equal
404 : */
405 : SWIGRUNTIME int
406 : SWIG_TypeEquiv(const char *nb, const char *tb) {
407 431 : return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
408 : }
409 :
410 : /*
411 : Check the typename
412 : */
413 : SWIGRUNTIME swig_cast_info *
414 10 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
415 10 : if (ty) {
416 10 : swig_cast_info *iter = ty->cast;
417 10 : while (iter) {
418 10 : if (strcmp(iter->type->name, c) == 0) {
419 10 : if (iter == ty->cast)
420 : return iter;
421 : /* Move iter to the top of the linked list */
422 0 : iter->prev->next = iter->next;
423 0 : if (iter->next)
424 0 : iter->next->prev = iter->prev;
425 0 : iter->next = ty->cast;
426 0 : iter->prev = 0;
427 0 : if (ty->cast) ty->cast->prev = iter;
428 0 : ty->cast = iter;
429 0 : return iter;
430 : }
431 0 : iter = iter->next;
432 : }
433 : }
434 : return 0;
435 : }
436 :
437 : /*
438 : Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
439 : */
440 : SWIGRUNTIME swig_cast_info *
441 : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
442 : if (ty) {
443 : swig_cast_info *iter = ty->cast;
444 : while (iter) {
445 : if (iter->type == from) {
446 : if (iter == ty->cast)
447 : return iter;
448 : /* Move iter to the top of the linked list */
449 : iter->prev->next = iter->next;
450 : if (iter->next)
451 : iter->next->prev = iter->prev;
452 : iter->next = ty->cast;
453 : iter->prev = 0;
454 : if (ty->cast) ty->cast->prev = iter;
455 : ty->cast = iter;
456 : return iter;
457 : }
458 : iter = iter->next;
459 : }
460 : }
461 : return 0;
462 : }
463 :
464 : /*
465 : Cast a pointer up an inheritance hierarchy
466 : */
467 : SWIGRUNTIMEINLINE void *
468 : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
469 0 : return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
470 : }
471 :
472 : /*
473 : Dynamic pointer casting. Down an inheritance hierarchy
474 : */
475 : SWIGRUNTIME swig_type_info *
476 : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
477 : swig_type_info *lastty = ty;
478 : if (!ty || !ty->dcast) return ty;
479 : while (ty && (ty->dcast)) {
480 : ty = (*ty->dcast)(ptr);
481 : if (ty) lastty = ty;
482 : }
483 : return lastty;
484 : }
485 :
486 : /*
487 : Return the name associated with this type
488 : */
489 : SWIGRUNTIMEINLINE const char *
490 : SWIG_TypeName(const swig_type_info *ty) {
491 : return ty->name;
492 : }
493 :
494 : /*
495 : Return the pretty name associated with this type,
496 : that is an unmangled type name in a form presentable to the user.
497 : */
498 : SWIGRUNTIME const char *
499 : SWIG_TypePrettyName(const swig_type_info *type) {
500 : /* The "str" field contains the equivalent pretty names of the
501 : type, separated by vertical-bar characters. We choose
502 : to print the last name, as it is often (?) the most
503 : specific. */
504 : if (!type) return NULL;
505 : if (type->str != NULL) {
506 : const char *last_name = type->str;
507 : const char *s;
508 : for (s = type->str; *s; s++)
509 : if (*s == '|') last_name = s+1;
510 : return last_name;
511 : }
512 : else
513 : return type->name;
514 : }
515 :
516 : /*
517 : Set the clientdata field for a type
518 : */
519 : SWIGRUNTIME void
520 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
521 : swig_cast_info *cast = ti->cast;
522 : /* if (ti->clientdata == clientdata) return; */
523 : ti->clientdata = clientdata;
524 :
525 : while (cast) {
526 : if (!cast->converter) {
527 : swig_type_info *tc = cast->type;
528 : if (!tc->clientdata) {
529 : SWIG_TypeClientData(tc, clientdata);
530 : }
531 : }
532 : cast = cast->next;
533 : }
534 : }
535 : SWIGRUNTIME void
536 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
537 : SWIG_TypeClientData(ti, clientdata);
538 : ti->owndata = 1;
539 : }
540 :
541 : /*
542 : Search for a swig_type_info structure only by mangled name
543 : Search is a O(log #types)
544 :
545 : We start searching at module start, and finish searching when start == end.
546 : Note: if start == end at the beginning of the function, we go all the way around
547 : the circular list.
548 : */
549 : SWIGRUNTIME swig_type_info *
550 45 : SWIG_MangledTypeQueryModule(swig_module_info *start,
551 : swig_module_info *end,
552 : const char *name) {
553 45 : swig_module_info *iter = start;
554 : do {
555 45 : if (iter->size) {
556 45 : size_t l = 0;
557 45 : size_t r = iter->size - 1;
558 : do {
559 : /* since l+r >= 0, we can (>> 1) instead (/ 2) */
560 225 : size_t i = (l + r) >> 1;
561 225 : const char *iname = iter->types[i]->name;
562 225 : if (iname) {
563 225 : int compare = strcmp(name, iname);
564 225 : if (compare == 0) {
565 : return iter->types[i];
566 225 : } else if (compare < 0) {
567 0 : if (i) {
568 0 : r = i - 1;
569 : } else {
570 : break;
571 : }
572 225 : } else if (compare > 0) {
573 225 : l = i + 1;
574 : }
575 : } else {
576 : break; /* should never happen */
577 : }
578 225 : } while (l <= r);
579 : }
580 45 : iter = iter->next;
581 45 : } while (iter != end);
582 : return 0;
583 : }
584 :
585 : /*
586 : Search for a swig_type_info structure for either a mangled name or a human readable name.
587 : It first searches the mangled names of the types, which is a O(log #types)
588 : If a type is not found it then searches the human readable names, which is O(#types).
589 :
590 : We start searching at module start, and finish searching when start == end.
591 : Note: if start == end at the beginning of the function, we go all the way around
592 : the circular list.
593 : */
594 : SWIGRUNTIME swig_type_info *
595 45 : SWIG_TypeQueryModule(swig_module_info *start,
596 : swig_module_info *end,
597 : const char *name) {
598 : /* STEP 1: Search the name field using binary search */
599 45 : swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
600 45 : if (ret) {
601 : return ret;
602 : } else {
603 : /* STEP 2: If the type hasn't been found, do a complete search
604 : of the str field (the human readable name) */
605 : swig_module_info *iter = start;
606 : do {
607 45 : size_t i = 0;
608 817 : for (; i < iter->size; ++i) {
609 862 : if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
610 : return iter->types[i];
611 : }
612 0 : iter = iter->next;
613 0 : } while (iter != end);
614 : }
615 :
616 : /* neither found a match */
617 : return 0;
618 : }
619 :
620 : /*
621 : Pack binary data into a string
622 : */
623 : SWIGRUNTIME char *
624 : SWIG_PackData(char *c, void *ptr, size_t sz) {
625 : static const char hex[17] = "0123456789abcdef";
626 : const unsigned char *u = (unsigned char *) ptr;
627 : const unsigned char *eu = u + sz;
628 : for (; u != eu; ++u) {
629 : unsigned char uu = *u;
630 : *(c++) = hex[(uu & 0xf0) >> 4];
631 : *(c++) = hex[uu & 0xf];
632 : }
633 : return c;
634 : }
635 :
636 : /*
637 : Unpack binary data from a string
638 : */
639 : SWIGRUNTIME const char *
640 : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
641 : unsigned char *u = (unsigned char *) ptr;
642 : const unsigned char *eu = u + sz;
643 : for (; u != eu; ++u) {
644 : char d = *(c++);
645 : unsigned char uu;
646 : if ((d >= '0') && (d <= '9'))
647 : uu = (unsigned char)((d - '0') << 4);
648 : else if ((d >= 'a') && (d <= 'f'))
649 : uu = (unsigned char)((d - ('a'-10)) << 4);
650 : else
651 : return (char *) 0;
652 : d = *(c++);
653 : if ((d >= '0') && (d <= '9'))
654 : uu |= (unsigned char)(d - '0');
655 : else if ((d >= 'a') && (d <= 'f'))
656 : uu |= (unsigned char)(d - ('a'-10));
657 : else
658 : return (char *) 0;
659 : *u = uu;
660 : }
661 : return c;
662 : }
663 :
664 : /*
665 : Pack 'void *' into a string buffer.
666 : */
667 : SWIGRUNTIME char *
668 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
669 : char *r = buff;
670 : if ((2*sizeof(void *) + 2) > bsz) return 0;
671 : *(r++) = '_';
672 : r = SWIG_PackData(r,&ptr,sizeof(void *));
673 : if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
674 : strcpy(r,name);
675 : return buff;
676 : }
677 :
678 : SWIGRUNTIME const char *
679 : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
680 : if (*c != '_') {
681 : if (strcmp(c,"NULL") == 0) {
682 : *ptr = (void *) 0;
683 : return name;
684 : } else {
685 : return 0;
686 : }
687 : }
688 : return SWIG_UnpackData(++c,ptr,sizeof(void *));
689 : }
690 :
691 : SWIGRUNTIME char *
692 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
693 : char *r = buff;
694 : size_t lname = (name ? strlen(name) : 0);
695 : if ((2*sz + 2 + lname) > bsz) return 0;
696 : *(r++) = '_';
697 : r = SWIG_PackData(r,ptr,sz);
698 : if (lname) {
699 : strncpy(r,name,lname+1);
700 : } else {
701 : *r = 0;
702 : }
703 : return buff;
704 : }
705 :
706 : SWIGRUNTIME const char *
707 : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
708 : if (*c != '_') {
709 : if (strcmp(c,"NULL") == 0) {
710 : memset(ptr,0,sz);
711 : return name;
712 : } else {
713 : return 0;
714 : }
715 : }
716 : return SWIG_UnpackData(++c,ptr,sz);
717 : }
718 :
719 : #ifdef __cplusplus
720 : }
721 : #endif
722 : #include <ruby.h>
723 :
724 : /* Ruby 1.9.1 has a "memoisation optimisation" when compiling with GCC which
725 : * breaks using rb_intern as an lvalue, as SWIG does. We work around this
726 : * issue for now by disabling this.
727 : * https://sourceforge.net/tracker/?func=detail&aid=2859614&group_id=1645&atid=101645
728 : */
729 : #ifdef rb_intern
730 : # undef rb_intern
731 : #endif
732 :
733 : /* Remove global macros defined in Ruby's win32.h */
734 : #ifdef write
735 : # undef write
736 : #endif
737 : #ifdef read
738 : # undef read
739 : #endif
740 : #ifdef bind
741 : # undef bind
742 : #endif
743 : #ifdef close
744 : # undef close
745 : #endif
746 : #ifdef connect
747 : # undef connect
748 : #endif
749 :
750 :
751 : /* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */
752 : #ifndef NUM2LL
753 : #define NUM2LL(x) NUM2LONG((x))
754 : #endif
755 : #ifndef LL2NUM
756 : #define LL2NUM(x) INT2NUM((long) (x))
757 : #endif
758 : #ifndef ULL2NUM
759 : #define ULL2NUM(x) UINT2NUM((unsigned long) (x))
760 : #endif
761 :
762 : /* Ruby 1.7 doesn't (yet) define NUM2ULL() */
763 : #ifndef NUM2ULL
764 : #ifdef HAVE_LONG_LONG
765 : #define NUM2ULL(x) rb_num2ull((x))
766 : #else
767 : #define NUM2ULL(x) NUM2ULONG(x)
768 : #endif
769 : #endif
770 :
771 : /* RSTRING_LEN, etc are new in Ruby 1.9, but ->ptr and ->len no longer work */
772 : /* Define these for older versions so we can just write code the new way */
773 : #ifndef RSTRING_LEN
774 : # define RSTRING_LEN(x) RSTRING(x)->len
775 : #endif
776 : #ifndef RSTRING_PTR
777 : # define RSTRING_PTR(x) RSTRING(x)->ptr
778 : #endif
779 : #ifndef RSTRING_END
780 : # define RSTRING_END(x) (RSTRING_PTR(x) + RSTRING_LEN(x))
781 : #endif
782 : #ifndef RARRAY_LEN
783 : # define RARRAY_LEN(x) RARRAY(x)->len
784 : #endif
785 : #ifndef RARRAY_PTR
786 : # define RARRAY_PTR(x) RARRAY(x)->ptr
787 : #endif
788 : #ifndef RFLOAT_VALUE
789 : # define RFLOAT_VALUE(x) RFLOAT(x)->value
790 : #endif
791 : #ifndef DOUBLE2NUM
792 : # define DOUBLE2NUM(x) rb_float_new(x)
793 : #endif
794 : #ifndef RHASH_TBL
795 : # define RHASH_TBL(x) (RHASH(x)->tbl)
796 : #endif
797 : #ifndef RHASH_ITER_LEV
798 : # define RHASH_ITER_LEV(x) (RHASH(x)->iter_lev)
799 : #endif
800 : #ifndef RHASH_IFNONE
801 : # define RHASH_IFNONE(x) (RHASH(x)->ifnone)
802 : #endif
803 : #ifndef RHASH_SIZE
804 : # define RHASH_SIZE(x) (RHASH(x)->tbl->num_entries)
805 : #endif
806 : #ifndef RHASH_EMPTY_P
807 : # define RHASH_EMPTY_P(x) (RHASH_SIZE(x) == 0)
808 : #endif
809 : #ifndef RSTRUCT_LEN
810 : # define RSTRUCT_LEN(x) RSTRUCT(x)->len
811 : #endif
812 : #ifndef RSTRUCT_PTR
813 : # define RSTRUCT_PTR(x) RSTRUCT(x)->ptr
814 : #endif
815 :
816 :
817 :
818 : /*
819 : * Need to be very careful about how these macros are defined, especially
820 : * when compiling C++ code or C code with an ANSI C compiler.
821 : *
822 : * VALUEFUNC(f) is a macro used to typecast a C function that implements
823 : * a Ruby method so that it can be passed as an argument to API functions
824 : * like rb_define_method() and rb_define_singleton_method().
825 : *
826 : * VOIDFUNC(f) is a macro used to typecast a C function that implements
827 : * either the "mark" or "free" stuff for a Ruby Data object, so that it
828 : * can be passed as an argument to API functions like Data_Wrap_Struct()
829 : * and Data_Make_Struct().
830 : */
831 :
832 : #ifdef __cplusplus
833 : # ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */
834 : # define PROTECTFUNC(f) ((VALUE (*)()) f)
835 : # define VALUEFUNC(f) ((VALUE (*)()) f)
836 : # define VOIDFUNC(f) ((void (*)()) f)
837 : # else
838 : # ifndef ANYARGS /* These definitions should work for Ruby 1.6 */
839 : # define PROTECTFUNC(f) ((VALUE (*)()) f)
840 : # define VALUEFUNC(f) ((VALUE (*)()) f)
841 : # define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
842 : # else /* These definitions should work for Ruby 1.7+ */
843 : # define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f)
844 : # define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f)
845 : # define VOIDFUNC(f) ((RUBY_DATA_FUNC) f)
846 : # endif
847 : # endif
848 : #else
849 : # define VALUEFUNC(f) (f)
850 : # define VOIDFUNC(f) (f)
851 : #endif
852 :
853 : /* Don't use for expressions have side effect */
854 : #ifndef RB_STRING_VALUE
855 : #define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s)))
856 : #endif
857 : #ifndef StringValue
858 : #define StringValue(s) RB_STRING_VALUE(s)
859 : #endif
860 : #ifndef StringValuePtr
861 : #define StringValuePtr(s) RSTRING_PTR(RB_STRING_VALUE(s))
862 : #endif
863 : #ifndef StringValueLen
864 : #define StringValueLen(s) RSTRING_LEN(RB_STRING_VALUE(s))
865 : #endif
866 : #ifndef SafeStringValue
867 : #define SafeStringValue(v) do {\
868 : StringValue(v);\
869 : rb_check_safe_str(v);\
870 : } while (0)
871 : #endif
872 :
873 : #ifndef HAVE_RB_DEFINE_ALLOC_FUNC
874 : #define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1)
875 : #define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new")
876 : #endif
877 :
878 : static VALUE _mSWIG = Qnil;
879 : /* -----------------------------------------------------------------------------
880 : * error manipulation
881 : * ----------------------------------------------------------------------------- */
882 :
883 :
884 : /* Define some additional error types */
885 : #define SWIG_ObjectPreviouslyDeletedError -100
886 :
887 :
888 : /* Define custom exceptions for errors that do not map to existing Ruby
889 : exceptions. Note this only works for C++ since a global cannot be
890 : initialized by a function in C. For C, fallback to rb_eRuntimeError.*/
891 :
892 : SWIGINTERN VALUE
893 : getNullReferenceError(void) {
894 : static int init = 0;
895 : static VALUE rb_eNullReferenceError ;
896 : if (!init) {
897 : init = 1;
898 : rb_eNullReferenceError = rb_define_class("NullReferenceError", rb_eRuntimeError);
899 : }
900 : return rb_eNullReferenceError;
901 : }
902 :
903 : SWIGINTERN VALUE
904 : getObjectPreviouslyDeletedError(void) {
905 : static int init = 0;
906 : static VALUE rb_eObjectPreviouslyDeleted ;
907 : if (!init) {
908 : init = 1;
909 : rb_eObjectPreviouslyDeleted = rb_define_class("ObjectPreviouslyDeleted", rb_eRuntimeError);
910 : }
911 : return rb_eObjectPreviouslyDeleted;
912 : }
913 :
914 :
915 : SWIGINTERN VALUE
916 : SWIG_Ruby_ErrorType(int SWIG_code) {
917 : VALUE type;
918 : switch (SWIG_code) {
919 : case SWIG_MemoryError:
920 : type = rb_eNoMemError;
921 : break;
922 : case SWIG_IOError:
923 : type = rb_eIOError;
924 : break;
925 : case SWIG_RuntimeError:
926 : type = rb_eRuntimeError;
927 : break;
928 : case SWIG_IndexError:
929 : type = rb_eIndexError;
930 : break;
931 : case SWIG_TypeError:
932 : type = rb_eTypeError;
933 : break;
934 : case SWIG_DivisionByZero:
935 : type = rb_eZeroDivError;
936 : break;
937 : case SWIG_OverflowError:
938 : type = rb_eRangeError;
939 : break;
940 : case SWIG_SyntaxError:
941 : type = rb_eSyntaxError;
942 : break;
943 : case SWIG_ValueError:
944 : type = rb_eArgError;
945 : break;
946 : case SWIG_SystemError:
947 : type = rb_eFatal;
948 : break;
949 : case SWIG_AttributeError:
950 : type = rb_eRuntimeError;
951 : break;
952 : case SWIG_NullReferenceError:
953 : type = getNullReferenceError();
954 : break;
955 : case SWIG_ObjectPreviouslyDeletedError:
956 : type = getObjectPreviouslyDeletedError();
957 : break;
958 : case SWIG_UnknownError:
959 : type = rb_eRuntimeError;
960 : break;
961 : default:
962 : type = rb_eRuntimeError;
963 : }
964 : return type;
965 : }
966 :
967 :
968 : /* This function is called when a user inputs a wrong argument to
969 : a method.
970 : */
971 : SWIGINTERN
972 : const char* Ruby_Format_TypeError( const char* msg,
973 : const char* type,
974 : const char* name,
975 : const int argn,
976 : VALUE input )
977 : {
978 : char buf[128];
979 : VALUE str;
980 : VALUE asStr;
981 : if ( msg && *msg )
982 : {
983 : str = rb_str_new2(msg);
984 : }
985 : else
986 : {
987 : str = rb_str_new(NULL, 0);
988 : }
989 :
990 : str = rb_str_cat2( str, "Expected argument " );
991 : sprintf( buf, "%d of type ", argn-1 );
992 : str = rb_str_cat2( str, buf );
993 : str = rb_str_cat2( str, type );
994 : str = rb_str_cat2( str, ", but got " );
995 : str = rb_str_cat2( str, rb_obj_classname(input) );
996 : str = rb_str_cat2( str, " " );
997 : asStr = rb_inspect(input);
998 : if ( RSTRING_LEN(asStr) > 30 )
999 : {
1000 : str = rb_str_cat( str, StringValuePtr(asStr), 30 );
1001 : str = rb_str_cat2( str, "..." );
1002 : }
1003 : else
1004 : {
1005 : str = rb_str_append( str, asStr );
1006 : }
1007 :
1008 : if ( name )
1009 : {
1010 : str = rb_str_cat2( str, "\n\tin SWIG method '" );
1011 : str = rb_str_cat2( str, name );
1012 : str = rb_str_cat2( str, "'" );
1013 : }
1014 :
1015 : return StringValuePtr( str );
1016 : }
1017 :
1018 : /* This function is called when an overloaded method fails */
1019 : SWIGINTERN
1020 : void Ruby_Format_OverloadedError(
1021 : const int argc,
1022 : const int maxargs,
1023 : const char* method,
1024 : const char* prototypes
1025 : )
1026 : {
1027 : const char* msg = "Wrong # of arguments";
1028 : if ( argc <= maxargs ) msg = "Wrong arguments";
1029 : rb_raise(rb_eArgError,"%s for overloaded method '%s'.\n"
1030 : "Possible C/C++ prototypes are:\n%s",
1031 : msg, method, prototypes);
1032 : }
1033 : /* -----------------------------------------------------------------------------
1034 : * rubytracking.swg
1035 : *
1036 : * This file contains support for tracking mappings from
1037 : * Ruby objects to C++ objects. This functionality is needed
1038 : * to implement mark functions for Ruby's mark and sweep
1039 : * garbage collector.
1040 : * ----------------------------------------------------------------------------- */
1041 :
1042 : #ifdef __cplusplus
1043 : extern "C" {
1044 : #endif
1045 :
1046 : #if !defined(ST_DATA_T_DEFINED)
1047 : /* Needs to be explicitly included for Ruby 1.8 and earlier */
1048 : #include <st.h>
1049 : #endif
1050 :
1051 : /* Ruby 1.8 actually assumes the first case. */
1052 : #if SIZEOF_VOIDP == SIZEOF_LONG
1053 : # define SWIG2NUM(v) LONG2NUM((unsigned long)v)
1054 : # define NUM2SWIG(x) (unsigned long)NUM2LONG(x)
1055 : #elif SIZEOF_VOIDP == SIZEOF_LONG_LONG
1056 : # define SWIG2NUM(v) LL2NUM((unsigned long long)v)
1057 : # define NUM2SWIG(x) (unsigned long long)NUM2LL(x)
1058 : #else
1059 : # error sizeof(void*) is not the same as long or long long
1060 : #endif
1061 :
1062 : /* Global hash table to store Trackings from C/C++
1063 : structs to Ruby Objects.
1064 : */
1065 : static st_table* swig_ruby_trackings = NULL;
1066 :
1067 : static VALUE swig_ruby_trackings_count(ANYARGS) {
1068 : return SWIG2NUM(swig_ruby_trackings->num_entries);
1069 : }
1070 :
1071 :
1072 : /* Setup a hash table to store Trackings */
1073 : SWIGRUNTIME void SWIG_RubyInitializeTrackings(void) {
1074 : /* Create a hash table to store Trackings from C++
1075 : objects to Ruby objects. */
1076 :
1077 : /* Try to see if some other .so has already created a
1078 : tracking hash table, which we keep hidden in an instance var
1079 : in the SWIG module.
1080 : This is done to allow multiple DSOs to share the same
1081 : tracking table.
1082 : */
1083 : VALUE trackings_value = Qnil;
1084 : /* change the variable name so that we can mix modules
1085 : compiled with older SWIG's - this used to be called "@__trackings__" */
1086 : ID trackings_id = rb_intern( "@__safetrackings__" );
1087 : VALUE verbose = rb_gv_get("VERBOSE");
1088 : rb_gv_set("VERBOSE", Qfalse);
1089 : trackings_value = rb_ivar_get( _mSWIG, trackings_id );
1090 : rb_gv_set("VERBOSE", verbose);
1091 :
1092 : /* The trick here is that we have to store the hash table
1093 : pointer in a Ruby variable. We do not want Ruby's GC to
1094 : treat this pointer as a Ruby object, so we convert it to
1095 : a Ruby numeric value. */
1096 : if (trackings_value == Qnil) {
1097 : /* No, it hasn't. Create one ourselves */
1098 : swig_ruby_trackings = st_init_numtable();
1099 : rb_ivar_set( _mSWIG, trackings_id, SWIG2NUM(swig_ruby_trackings) );
1100 : } else {
1101 : swig_ruby_trackings = (st_table*)NUM2SWIG(trackings_value);
1102 : }
1103 :
1104 : rb_define_virtual_variable("SWIG_TRACKINGS_COUNT", swig_ruby_trackings_count, NULL);
1105 : }
1106 :
1107 : /* Add a Tracking from a C/C++ struct to a Ruby object */
1108 : SWIGRUNTIME void SWIG_RubyAddTracking(void* ptr, VALUE object) {
1109 : /* Store the mapping to the global hash table. */
1110 0 : st_insert(swig_ruby_trackings, (st_data_t)ptr, object);
1111 : }
1112 :
1113 : /* Get the Ruby object that owns the specified C/C++ struct */
1114 : SWIGRUNTIME VALUE SWIG_RubyInstanceFor(void* ptr) {
1115 : /* Now lookup the value stored in the global hash table */
1116 : VALUE value;
1117 :
1118 0 : if (st_lookup(swig_ruby_trackings, (st_data_t)ptr, &value)) {
1119 0 : return value;
1120 : } else {
1121 : return Qnil;
1122 : }
1123 : }
1124 :
1125 : /* Remove a Tracking from a C/C++ struct to a Ruby object. It
1126 : is very important to remove objects once they are destroyed
1127 : since the same memory address may be reused later to create
1128 : a new object. */
1129 0 : SWIGRUNTIME void SWIG_RubyRemoveTracking(void* ptr) {
1130 : /* Delete the object from the hash table */
1131 0 : st_delete(swig_ruby_trackings, (st_data_t *)&ptr, NULL);
1132 0 : }
1133 :
1134 : /* This is a helper method that unlinks a Ruby object from its
1135 : underlying C++ object. This is needed if the lifetime of the
1136 : Ruby object is longer than the C++ object */
1137 : SWIGRUNTIME void SWIG_RubyUnlinkObjects(void* ptr) {
1138 : VALUE object = SWIG_RubyInstanceFor(ptr);
1139 :
1140 : if (object != Qnil) {
1141 : if (TYPE(object) != T_DATA)
1142 : abort();
1143 : DATA_PTR(object) = 0;
1144 : }
1145 : }
1146 :
1147 : /* This is a helper method that iterates over all the trackings
1148 : passing the C++ object pointer and its related Ruby object
1149 : to the passed callback function. */
1150 :
1151 : /* Proxy method to abstract the internal trackings datatype */
1152 : static int swig_ruby_internal_iterate_callback(void* ptr, VALUE obj, void(*meth)(void* ptr, VALUE obj)) {
1153 : (*meth)(ptr, obj);
1154 : return ST_CONTINUE;
1155 : }
1156 :
1157 : SWIGRUNTIME void SWIG_RubyIterateTrackings( void(*meth)(void* ptr, VALUE obj) ) {
1158 : st_foreach(swig_ruby_trackings, (int (*)(ANYARGS))&swig_ruby_internal_iterate_callback, (st_data_t)meth);
1159 : }
1160 :
1161 : #ifdef __cplusplus
1162 : }
1163 : #endif
1164 : /* -----------------------------------------------------------------------------
1165 : * Ruby API portion that goes into the runtime
1166 : * ----------------------------------------------------------------------------- */
1167 :
1168 : #ifdef __cplusplus
1169 : extern "C" {
1170 : #endif
1171 :
1172 : SWIGINTERN VALUE
1173 : SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
1174 : if (NIL_P(target)) {
1175 : target = o;
1176 : } else {
1177 : if (TYPE(target) != T_ARRAY) {
1178 : VALUE o2 = target;
1179 : target = rb_ary_new();
1180 : rb_ary_push(target, o2);
1181 : }
1182 : rb_ary_push(target, o);
1183 : }
1184 : return target;
1185 : }
1186 :
1187 : /* For ruby1.8.4 and earlier. */
1188 : #ifndef RUBY_INIT_STACK
1189 : RUBY_EXTERN void Init_stack(VALUE* addr);
1190 : # define RUBY_INIT_STACK \
1191 : VALUE variable_in_this_stack_frame; \
1192 : Init_stack(&variable_in_this_stack_frame);
1193 : #endif
1194 :
1195 :
1196 : #ifdef __cplusplus
1197 : }
1198 : #endif
1199 :
1200 : /* -----------------------------------------------------------------------------
1201 : * rubyrun.swg
1202 : *
1203 : * This file contains the runtime support for Ruby modules
1204 : * and includes code for managing global variables and pointer
1205 : * type checking.
1206 : * ----------------------------------------------------------------------------- */
1207 :
1208 : /* For backward compatibility only */
1209 : #define SWIG_POINTER_EXCEPTION 0
1210 :
1211 : /* for raw pointers */
1212 : #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1213 : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1214 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
1215 : #define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)
1216 : #define swig_owntype swig_ruby_owntype
1217 :
1218 : /* for raw packed data */
1219 : #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
1220 : #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1221 :
1222 : /* for class or struct pointers */
1223 : #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1224 : #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1225 :
1226 : /* for C or C++ function pointers */
1227 : #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
1228 : #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
1229 :
1230 : /* for C++ member pointers, ie, member methods */
1231 : #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
1232 : #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
1233 :
1234 :
1235 : /* Runtime API */
1236 :
1237 : #define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule(clientdata)
1238 : #define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer)
1239 :
1240 :
1241 : /* Error manipulation */
1242 :
1243 : #define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code)
1244 : #define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), "%s", msg)
1245 : #define SWIG_fail goto fail
1246 :
1247 :
1248 : /* Ruby-specific SWIG API */
1249 :
1250 : #define SWIG_InitRuntime() SWIG_Ruby_InitRuntime()
1251 : #define SWIG_define_class(ty) SWIG_Ruby_define_class(ty)
1252 : #define SWIG_NewClassInstance(value, ty) SWIG_Ruby_NewClassInstance(value, ty)
1253 : #define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value)
1254 : #define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty)
1255 :
1256 : #include "assert.h"
1257 :
1258 : /* -----------------------------------------------------------------------------
1259 : * pointers/data manipulation
1260 : * ----------------------------------------------------------------------------- */
1261 :
1262 : #ifdef __cplusplus
1263 : extern "C" {
1264 : #endif
1265 :
1266 : typedef struct {
1267 : VALUE klass;
1268 : VALUE mImpl;
1269 : void (*mark)(void *);
1270 : void (*destroy)(void *);
1271 : int trackObjects;
1272 : } swig_class;
1273 :
1274 :
1275 : /* Global pointer used to keep some internal SWIG stuff */
1276 : static VALUE _cSWIG_Pointer = Qnil;
1277 : static VALUE swig_runtime_data_type_pointer = Qnil;
1278 :
1279 : /* Global IDs used to keep some internal SWIG stuff */
1280 : static ID swig_arity_id = 0;
1281 : static ID swig_call_id = 0;
1282 :
1283 : /*
1284 : If your swig extension is to be run within an embedded ruby and has
1285 : director callbacks, you should set -DRUBY_EMBEDDED during compilation.
1286 : This will reset ruby's stack frame on each entry point from the main
1287 : program the first time a virtual director function is invoked (in a
1288 : non-recursive way).
1289 : If this is not done, you run the risk of Ruby trashing the stack.
1290 : */
1291 :
1292 : #ifdef RUBY_EMBEDDED
1293 :
1294 : # define SWIG_INIT_STACK \
1295 : if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
1296 : ++swig_virtual_calls;
1297 : # define SWIG_RELEASE_STACK --swig_virtual_calls;
1298 : # define Ruby_DirectorTypeMismatchException(x) \
1299 : rb_raise( rb_eTypeError, "%s", x ); return c_result;
1300 :
1301 : static unsigned int swig_virtual_calls = 0;
1302 :
1303 : #else /* normal non-embedded extension */
1304 :
1305 : # define SWIG_INIT_STACK
1306 : # define SWIG_RELEASE_STACK
1307 : # define Ruby_DirectorTypeMismatchException(x) \
1308 : throw Swig::DirectorTypeMismatchException( x );
1309 :
1310 : #endif /* RUBY_EMBEDDED */
1311 :
1312 :
1313 : SWIGRUNTIME VALUE
1314 : getExceptionClass(void) {
1315 : static int init = 0;
1316 : static VALUE rubyExceptionClass ;
1317 : if (!init) {
1318 : init = 1;
1319 : rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
1320 : }
1321 : return rubyExceptionClass;
1322 : }
1323 :
1324 : /* This code checks to see if the Ruby object being raised as part
1325 : of an exception inherits from the Ruby class Exception. If so,
1326 : the object is simply returned. If not, then a new Ruby exception
1327 : object is created and that will be returned to Ruby.*/
1328 : SWIGRUNTIME VALUE
1329 : SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
1330 : VALUE exceptionClass = getExceptionClass();
1331 : if (rb_obj_is_kind_of(obj, exceptionClass)) {
1332 : return obj;
1333 : } else {
1334 : return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
1335 : }
1336 : }
1337 :
1338 : /* Initialize Ruby runtime support */
1339 : SWIGRUNTIME void
1340 : SWIG_Ruby_InitRuntime(void)
1341 : {
1342 : if (_mSWIG == Qnil) {
1343 : _mSWIG = rb_define_module("SWIG");
1344 : swig_call_id = rb_intern("call");
1345 : swig_arity_id = rb_intern("arity");
1346 : }
1347 : }
1348 :
1349 : /* Define Ruby class for C type */
1350 : SWIGRUNTIME void
1351 : SWIG_Ruby_define_class(swig_type_info *type)
1352 : {
1353 : char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1354 : sprintf(klass_name, "TYPE%s", type->name);
1355 : if (NIL_P(_cSWIG_Pointer)) {
1356 : _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
1357 : rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
1358 : }
1359 : rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
1360 : free((void *) klass_name);
1361 : }
1362 :
1363 : /* Create a new pointer object */
1364 : SWIGRUNTIME VALUE
1365 35 : SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
1366 : {
1367 35 : int own = flags & SWIG_POINTER_OWN;
1368 : int track;
1369 : char *klass_name;
1370 : swig_class *sklass;
1371 : VALUE klass;
1372 : VALUE obj;
1373 :
1374 35 : if (!ptr)
1375 : return Qnil;
1376 :
1377 35 : if (type->clientdata) {
1378 35 : sklass = (swig_class *) type->clientdata;
1379 :
1380 : /* Are we tracking this class and have we already returned this Ruby object? */
1381 35 : track = sklass->trackObjects;
1382 35 : if (track) {
1383 0 : obj = SWIG_RubyInstanceFor(ptr);
1384 :
1385 : /* Check the object's type and make sure it has the correct type.
1386 : It might not in cases where methods do things like
1387 : downcast methods. */
1388 0 : if (obj != Qnil) {
1389 0 : VALUE value = rb_iv_get(obj, "@__swigtype__");
1390 0 : const char* type_name = RSTRING_PTR(value);
1391 :
1392 0 : if (strcmp(type->name, type_name) == 0) {
1393 : return obj;
1394 : }
1395 : }
1396 : }
1397 :
1398 : /* Create a new Ruby object */
1399 35 : obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark),
1400 : ( own ? VOIDFUNC(sklass->destroy) :
1401 : (track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
1402 35 : ), ptr);
1403 :
1404 : /* If tracking is on for this class then track this object. */
1405 35 : if (track) {
1406 : SWIG_RubyAddTracking(ptr, obj);
1407 : }
1408 : } else {
1409 0 : klass_name = (char *) malloc(4 + strlen(type->name) + 1);
1410 0 : sprintf(klass_name, "TYPE%s", type->name);
1411 0 : klass = rb_const_get(_mSWIG, rb_intern(klass_name));
1412 0 : free((void *) klass_name);
1413 0 : obj = Data_Wrap_Struct(klass, 0, 0, ptr);
1414 : }
1415 35 : rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
1416 :
1417 : return obj;
1418 : }
1419 :
1420 : /* Create a new class instance (always owned) */
1421 : SWIGRUNTIME VALUE
1422 : SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
1423 : {
1424 : VALUE obj;
1425 : swig_class *sklass = (swig_class *) type->clientdata;
1426 : obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
1427 : rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
1428 : return obj;
1429 : }
1430 :
1431 : /* Get type mangle from class name */
1432 : SWIGRUNTIMEINLINE char *
1433 10 : SWIG_Ruby_MangleStr(VALUE obj)
1434 : {
1435 10 : VALUE stype = rb_iv_get(obj, "@__swigtype__");
1436 10 : return StringValuePtr(stype);
1437 : }
1438 :
1439 : /* Acquire a pointer value */
1440 : typedef struct {
1441 : void (*datafree)(void *);
1442 : int own;
1443 : } swig_ruby_owntype;
1444 :
1445 : SWIGRUNTIME swig_ruby_owntype
1446 : SWIG_Ruby_AcquirePtr(VALUE obj, swig_ruby_owntype own) {
1447 : swig_ruby_owntype oldown = {0, 0};
1448 : if (obj) {
1449 : oldown.datafree = RDATA(obj)->dfree;
1450 : RDATA(obj)->dfree = own.datafree;
1451 : }
1452 : return oldown;
1453 : }
1454 :
1455 : /* Convert a pointer value */
1456 : SWIGRUNTIME int
1457 10 : SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, swig_ruby_owntype *own)
1458 : {
1459 : char *c;
1460 : swig_cast_info *tc;
1461 10 : void *vptr = 0;
1462 :
1463 : /* Grab the pointer */
1464 10 : if (NIL_P(obj)) {
1465 0 : if (ptr)
1466 0 : *ptr = 0;
1467 : return SWIG_OK;
1468 : } else {
1469 10 : if (TYPE(obj) != T_DATA) {
1470 : return SWIG_ERROR;
1471 : }
1472 10 : Data_Get_Struct(obj, void, vptr);
1473 : }
1474 :
1475 10 : if (own) {
1476 0 : own->datafree = RDATA(obj)->dfree;
1477 0 : own->own = 0;
1478 : }
1479 :
1480 : /* Check to see if the input object is giving up ownership
1481 : of the underlying C struct or C++ object. If so then we
1482 : need to reset the destructor since the Ruby object no
1483 : longer owns the underlying C++ object.*/
1484 10 : if (flags & SWIG_POINTER_DISOWN) {
1485 : /* Is tracking on for this class? */
1486 0 : int track = 0;
1487 0 : if (ty && ty->clientdata) {
1488 0 : swig_class *sklass = (swig_class *) ty->clientdata;
1489 0 : track = sklass->trackObjects;
1490 : }
1491 :
1492 0 : if (track) {
1493 : /* We are tracking objects for this class. Thus we change the destructor
1494 : * to SWIG_RubyRemoveTracking. This allows us to
1495 : * remove the mapping from the C++ to Ruby object
1496 : * when the Ruby object is garbage collected. If we don't
1497 : * do this, then it is possible we will return a reference
1498 : * to a Ruby object that no longer exists thereby crashing Ruby. */
1499 0 : RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
1500 : } else {
1501 0 : RDATA(obj)->dfree = 0;
1502 : }
1503 : }
1504 :
1505 : /* Do type-checking if type info was provided */
1506 10 : if (ty) {
1507 10 : if (ty->clientdata) {
1508 10 : if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
1509 10 : if (vptr == 0) {
1510 : /* The object has already been deleted */
1511 : return SWIG_ObjectPreviouslyDeletedError;
1512 : }
1513 : }
1514 : }
1515 10 : if ((c = SWIG_MangleStr(obj)) == NULL) {
1516 : return SWIG_ERROR;
1517 : }
1518 10 : tc = SWIG_TypeCheck(c, ty);
1519 10 : if (!tc) {
1520 : return SWIG_ERROR;
1521 : } else {
1522 10 : if (ptr) {
1523 10 : if (tc->type == ty) {
1524 10 : *ptr = vptr;
1525 : } else {
1526 0 : int newmemory = 0;
1527 0 : *ptr = SWIG_TypeCast(tc, vptr, &newmemory);
1528 0 : if (newmemory == SWIG_CAST_NEW_MEMORY) {
1529 : assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1530 0 : if (own)
1531 0 : own->own = own->own | SWIG_CAST_NEW_MEMORY;
1532 : }
1533 : }
1534 : }
1535 : }
1536 : } else {
1537 0 : if (ptr)
1538 0 : *ptr = vptr;
1539 : }
1540 :
1541 : return SWIG_OK;
1542 : }
1543 :
1544 : /* Check convert */
1545 : SWIGRUNTIMEINLINE int
1546 : SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
1547 : {
1548 : char *c = SWIG_MangleStr(obj);
1549 : if (!c) return 0;
1550 : return SWIG_TypeCheck(c,ty) != 0;
1551 : }
1552 :
1553 : SWIGRUNTIME VALUE
1554 : SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1555 : char result[1024];
1556 : char *r = result;
1557 : if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1558 : *(r++) = '_';
1559 : r = SWIG_PackData(r, ptr, sz);
1560 : strcpy(r, type->name);
1561 : return rb_str_new2(result);
1562 : }
1563 :
1564 : /* Convert a packed value value */
1565 : SWIGRUNTIME int
1566 : SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
1567 : swig_cast_info *tc;
1568 : const char *c;
1569 :
1570 : if (TYPE(obj) != T_STRING) goto type_error;
1571 : c = StringValuePtr(obj);
1572 : /* Pointer values must start with leading underscore */
1573 : if (*c != '_') goto type_error;
1574 : c++;
1575 : c = SWIG_UnpackData(c, ptr, sz);
1576 : if (ty) {
1577 : tc = SWIG_TypeCheck(c, ty);
1578 : if (!tc) goto type_error;
1579 : }
1580 : return SWIG_OK;
1581 :
1582 : type_error:
1583 : return SWIG_ERROR;
1584 : }
1585 :
1586 : SWIGRUNTIME swig_module_info *
1587 45 : SWIG_Ruby_GetModule(void *SWIGUNUSEDPARM(clientdata))
1588 : {
1589 : VALUE pointer;
1590 45 : swig_module_info *ret = 0;
1591 45 : VALUE verbose = rb_gv_get("VERBOSE");
1592 :
1593 : /* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
1594 45 : rb_gv_set("VERBOSE", Qfalse);
1595 :
1596 : /* first check if pointer already created */
1597 45 : pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
1598 45 : if (pointer != Qnil) {
1599 45 : Data_Get_Struct(pointer, swig_module_info, ret);
1600 : }
1601 :
1602 : /* reinstate warnings */
1603 45 : rb_gv_set("VERBOSE", verbose);
1604 45 : return ret;
1605 : }
1606 :
1607 : SWIGRUNTIME void
1608 : SWIG_Ruby_SetModule(swig_module_info *pointer)
1609 : {
1610 : /* register a new class */
1611 : VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
1612 : /* create and store the structure pointer to a global variable */
1613 : swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
1614 : rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
1615 : }
1616 :
1617 : /* This function can be used to check whether a proc or method or similarly
1618 : callable function has been passed. Usually used in a %typecheck, like:
1619 :
1620 : %typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
1621 : $result = SWIG_Ruby_isCallable( $input );
1622 : }
1623 : */
1624 : SWIGINTERN
1625 : int SWIG_Ruby_isCallable( VALUE proc )
1626 : {
1627 : if ( rb_respond_to( proc, swig_call_id ) )
1628 : return 1;
1629 : return 0;
1630 : }
1631 :
1632 : /* This function can be used to check the arity (number of arguments)
1633 : a proc or method can take. Usually used in a %typecheck.
1634 : Valid arities will be that equal to minimal or those < 0
1635 : which indicate a variable number of parameters at the end.
1636 : */
1637 : SWIGINTERN
1638 : int SWIG_Ruby_arity( VALUE proc, int minimal )
1639 : {
1640 : if ( rb_respond_to( proc, swig_arity_id ) )
1641 : {
1642 : VALUE num = rb_funcall( proc, swig_arity_id, 0 );
1643 : int arity = NUM2INT(num);
1644 : if ( arity < 0 && (arity+1) < -minimal ) return 1;
1645 : if ( arity == minimal ) return 1;
1646 : return 1;
1647 : }
1648 : return 0;
1649 : }
1650 :
1651 :
1652 : #ifdef __cplusplus
1653 : }
1654 : #endif
1655 : /* -----------------------------------------------------------------------------*
1656 : Standard SWIG API for use inside user code.
1657 :
1658 : Don't include this file directly, run the command
1659 : swig -python -external-runtime
1660 : Also, read the Modules chapter of the SWIG Manual.
1661 :
1662 : * -----------------------------------------------------------------------------*/
1663 :
1664 : #ifdef SWIG_MODULE_CLIENTDATA_TYPE
1665 :
1666 : SWIGRUNTIMEINLINE swig_type_info *
1667 : SWIG_TypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata, const char *name) {
1668 : swig_module_info *module = SWIG_GetModule(clientdata);
1669 : return SWIG_TypeQueryModule(module, module, name);
1670 : }
1671 :
1672 : SWIGRUNTIMEINLINE swig_type_info *
1673 : SWIG_MangledTypeQuery(SWIG_MODULE_CLIENTDATA_TYPE clientdata, const char *name) {
1674 : swig_module_info *module = SWIG_GetModule(clientdata);
1675 : return SWIG_MangledTypeQueryModule(module, module, name);
1676 : }
1677 :
1678 : #else
1679 :
1680 : SWIGRUNTIMEINLINE swig_type_info *
1681 : SWIG_TypeQuery(const char *name) {
1682 45 : swig_module_info *module = SWIG_GetModule(NULL);
1683 45 : return SWIG_TypeQueryModule(module, module, name);
1684 : }
1685 :
1686 : SWIGRUNTIMEINLINE swig_type_info *
1687 : SWIG_MangledTypeQuery(const char *name) {
1688 : swig_module_info *module = SWIG_GetModule(NULL);
1689 : return SWIG_MangledTypeQueryModule(module, module, name);
1690 : }
1691 :
1692 : #endif
|