1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 3.0.7
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 #include "../config/config.h"
12
13
14 #define SWIGPERL
15 #define SWIG_CASTRANK_MODE
16
17 /* -----------------------------------------------------------------------------
18 * This section contains generic SWIG labels for method/variable
19 * declarations/attributes, and other compiler dependent labels.
20 * ----------------------------------------------------------------------------- */
21
22 /* template workaround for compilers that cannot correctly implement the C++ standard */
23 #ifndef SWIGTEMPLATEDISAMBIGUATOR
24 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
25 # define SWIGTEMPLATEDISAMBIGUATOR template
26 # elif defined(__HP_aCC)
27 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
28 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
29 # define SWIGTEMPLATEDISAMBIGUATOR template
30 # else
31 # define SWIGTEMPLATEDISAMBIGUATOR
32 # endif
33 #endif
34
35 /* inline attribute */
36 #ifndef SWIGINLINE
37 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
38 # define SWIGINLINE inline
39 # else
40 # define SWIGINLINE
41 # endif
42 #endif
43
44 /* attribute recognised by some compilers to avoid 'unused' warnings */
45 #ifndef SWIGUNUSED
46 # if defined(__GNUC__)
47 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
48 # define SWIGUNUSED __attribute__ ((__unused__))
49 # else
50 # define SWIGUNUSED
51 # endif
52 # elif defined(__ICC)
53 # define SWIGUNUSED __attribute__ ((__unused__))
54 # else
55 # define SWIGUNUSED
56 # endif
57 #endif
58
59 #ifndef SWIG_MSC_UNSUPPRESS_4505
60 # if defined(_MSC_VER)
61 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
62 # endif
63 #endif
64
65 #ifndef SWIGUNUSEDPARM
66 # ifdef __cplusplus
67 # define SWIGUNUSEDPARM(p)
68 # else
69 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
70 # endif
71 #endif
72
73 /* internal SWIG method */
74 #ifndef SWIGINTERN
75 # define SWIGINTERN static SWIGUNUSED
76 #endif
77
78 /* internal inline SWIG method */
79 #ifndef SWIGINTERNINLINE
80 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
81 #endif
82
83 /* exporting methods */
84 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
85 # ifndef GCC_HASCLASSVISIBILITY
86 # define GCC_HASCLASSVISIBILITY
87 # endif
88 #endif
89
90 #ifndef SWIGEXPORT
91 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
92 # if defined(STATIC_LINKED)
93 # define SWIGEXPORT
94 # else
95 # define SWIGEXPORT __declspec(dllexport)
96 # endif
97 # else
98 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
99 # define SWIGEXPORT __attribute__ ((visibility("default")))
100 # else
101 # define SWIGEXPORT
102 # endif
103 # endif
104 #endif
105
106 /* calling conventions for Windows */
107 #ifndef SWIGSTDCALL
108 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
109 # define SWIGSTDCALL __stdcall
110 # else
111 # define SWIGSTDCALL
112 # endif
113 #endif
114
115 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
116 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
117 # define _CRT_SECURE_NO_DEPRECATE
118 #endif
119
120 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
121 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
122 # define _SCL_SECURE_NO_DEPRECATE
123 #endif
124
125 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
126 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
127 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
128 #endif
129
130 /* Intel's compiler complains if a variable which was never initialised is
131 * cast to void, which is a common idiom which we use to indicate that we
132 * are aware a variable isn't used. So we just silence that warning.
133 * See: https://github.com/swig/swig/issues/192 for more discussion.
134 */
135 #ifdef __INTEL_COMPILER
136 # pragma warning disable 592
137 #endif
138
139 /* -----------------------------------------------------------------------------
140 * swigrun.swg
141 *
142 * This file contains generic C API SWIG runtime support for pointer
143 * type checking.
144 * ----------------------------------------------------------------------------- */
145
146 /* This should only be incremented when either the layout of swig_type_info changes,
147 or for whatever reason, the runtime changes incompatibly */
148 #define SWIG_RUNTIME_VERSION "4"
149
150 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
151 #ifdef SWIG_TYPE_TABLE
152 # define SWIG_QUOTE_STRING(x) #x
153 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
154 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
155 #else
156 # define SWIG_TYPE_TABLE_NAME
157 #endif
158
159 /*
160 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
161 creating a static or dynamic library from the SWIG runtime code.
162 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
163
164 But only do this if strictly necessary, ie, if you have problems
165 with your compiler or suchlike.
166 */
167
168 #ifndef SWIGRUNTIME
169 # define SWIGRUNTIME SWIGINTERN
170 #endif
171
172 #ifndef SWIGRUNTIMEINLINE
173 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
174 #endif
175
176 /* Generic buffer size */
177 #ifndef SWIG_BUFFER_SIZE
178 # define SWIG_BUFFER_SIZE 1024
179 #endif
180
181 /* Flags for pointer conversions */
182 #define SWIG_POINTER_DISOWN 0x1
183 #define SWIG_CAST_NEW_MEMORY 0x2
184
185 /* Flags for new pointer objects */
186 #define SWIG_POINTER_OWN 0x1
187
188
189 /*
190 Flags/methods for returning states.
191
192 The SWIG conversion methods, as ConvertPtr, return an integer
193 that tells if the conversion was successful or not. And if not,
194 an error code can be returned (see swigerrors.swg for the codes).
195
196 Use the following macros/flags to set or process the returning
197 states.
198
199 In old versions of SWIG, code such as the following was usually written:
200
201 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
202 // success code
203 } else {
204 //fail code
205 }
206
207 Now you can be more explicit:
208
209 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
210 if (SWIG_IsOK(res)) {
211 // success code
212 } else {
213 // fail code
214 }
215
216 which is the same really, but now you can also do
217
218 Type *ptr;
219 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
220 if (SWIG_IsOK(res)) {
221 // success code
222 if (SWIG_IsNewObj(res) {
223 ...
224 delete *ptr;
225 } else {
226 ...
227 }
228 } else {
229 // fail code
230 }
231
232 I.e., now SWIG_ConvertPtr can return new objects and you can
233 identify the case and take care of the deallocation. Of course that
234 also requires SWIG_ConvertPtr to return new result values, such as
235
236 int SWIG_ConvertPtr(obj, ptr,...) {
237 if (<obj is ok>) {
238 if (<need new object>) {
239 *ptr = <ptr to new allocated object>;
240 return SWIG_NEWOBJ;
241 } else {
242 *ptr = <ptr to old object>;
243 return SWIG_OLDOBJ;
244 }
245 } else {
246 return SWIG_BADOBJ;
247 }
248 }
249
250 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
251 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
252 SWIG errors code.
253
254 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
255 allows to return the 'cast rank', for example, if you have this
256
257 int food(double)
258 int fooi(int);
259
260 and you call
261
262 food(1) // cast rank '1' (1 -> 1.0)
263 fooi(1) // cast rank '0'
264
265 just use the SWIG_AddCast()/SWIG_CheckState()
266 */
267
268 #define SWIG_OK (0)
269 #define SWIG_ERROR (-1)
270 #define SWIG_IsOK(r) (r >= 0)
271 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
272
273 /* The CastRankLimit says how many bits are used for the cast rank */
274 #define SWIG_CASTRANKLIMIT (1 << 8)
275 /* The NewMask denotes the object was created (using new/malloc) */
276 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
277 /* The TmpMask is for in/out typemaps that use temporal objects */
278 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
279 /* Simple returning values */
280 #define SWIG_BADOBJ (SWIG_ERROR)
281 #define SWIG_OLDOBJ (SWIG_OK)
282 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
283 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
284 /* Check, add and del mask methods */
285 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
286 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
287 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
288 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
289 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
290 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
291
292 /* Cast-Rank Mode */
293 #if defined(SWIG_CASTRANK_MODE)
294 # ifndef SWIG_TypeRank
295 # define SWIG_TypeRank unsigned long
296 # endif
297 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
298 # define SWIG_MAXCASTRANK (2)
299 # endif
300 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
301 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
SWIG_AddCast(int r)302 SWIGINTERNINLINE int SWIG_AddCast(int r) {
303 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
304 }
SWIG_CheckState(int r)305 SWIGINTERNINLINE int SWIG_CheckState(int r) {
306 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
307 }
308 #else /* no cast-rank mode */
309 # define SWIG_AddCast(r) (r)
310 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
311 #endif
312
313
314 #include <string.h>
315
316 #ifdef __cplusplus
317 extern "C" {
318 #endif
319
320 typedef void *(*swig_converter_func)(void *, int *);
321 typedef struct swig_type_info *(*swig_dycast_func)(void **);
322
323 /* Structure to store information on one type */
324 typedef struct swig_type_info {
325 const char *name; /* mangled name of this type */
326 const char *str; /* human readable name of this type */
327 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
328 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
329 void *clientdata; /* language specific type data */
330 int owndata; /* flag if the structure owns the clientdata */
331 } swig_type_info;
332
333 /* Structure to store a type and conversion function used for casting */
334 typedef struct swig_cast_info {
335 swig_type_info *type; /* pointer to type that is equivalent to this type */
336 swig_converter_func converter; /* function to cast the void pointers */
337 struct swig_cast_info *next; /* pointer to next cast in linked list */
338 struct swig_cast_info *prev; /* pointer to the previous cast */
339 } swig_cast_info;
340
341 /* Structure used to store module information
342 * Each module generates one structure like this, and the runtime collects
343 * all of these structures and stores them in a circularly linked list.*/
344 typedef struct swig_module_info {
345 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
346 size_t size; /* Number of types in this module */
347 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
348 swig_type_info **type_initial; /* Array of initially generated type structures */
349 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
350 void *clientdata; /* Language specific module data */
351 } swig_module_info;
352
353 /*
354 Compare two type names skipping the space characters, therefore
355 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
356
357 Return 0 when the two name types are equivalent, as in
358 strncmp, but skipping ' '.
359 */
360 SWIGRUNTIME int
SWIG_TypeNameComp(const char * f1,const char * l1,const char * f2,const char * l2)361 SWIG_TypeNameComp(const char *f1, const char *l1,
362 const char *f2, const char *l2) {
363 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
364 while ((*f1 == ' ') && (f1 != l1)) ++f1;
365 while ((*f2 == ' ') && (f2 != l2)) ++f2;
366 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
367 }
368 return (int)((l1 - f1) - (l2 - f2));
369 }
370
371 /*
372 Check type equivalence in a name list like <name1>|<name2>|...
373 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
374 */
375 SWIGRUNTIME int
SWIG_TypeCmp(const char * nb,const char * tb)376 SWIG_TypeCmp(const char *nb, const char *tb) {
377 int equiv = 1;
378 const char* te = tb + strlen(tb);
379 const char* ne = nb;
380 while (equiv != 0 && *ne) {
381 for (nb = ne; *ne; ++ne) {
382 if (*ne == '|') break;
383 }
384 equiv = SWIG_TypeNameComp(nb, ne, tb, te);
385 if (*ne) ++ne;
386 }
387 return equiv;
388 }
389
390 /*
391 Check type equivalence in a name list like <name1>|<name2>|...
392 Return 0 if not equal, 1 if equal
393 */
394 SWIGRUNTIME int
SWIG_TypeEquiv(const char * nb,const char * tb)395 SWIG_TypeEquiv(const char *nb, const char *tb) {
396 return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
397 }
398
399 /*
400 Check the typename
401 */
402 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheck(const char * c,swig_type_info * ty)403 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
404 if (ty) {
405 swig_cast_info *iter = ty->cast;
406 while (iter) {
407 if (strcmp(iter->type->name, c) == 0) {
408 if (iter == ty->cast)
409 return iter;
410 /* Move iter to the top of the linked list */
411 iter->prev->next = iter->next;
412 if (iter->next)
413 iter->next->prev = iter->prev;
414 iter->next = ty->cast;
415 iter->prev = 0;
416 if (ty->cast) ty->cast->prev = iter;
417 ty->cast = iter;
418 return iter;
419 }
420 iter = iter->next;
421 }
422 }
423 return 0;
424 }
425
426 /*
427 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
428 */
429 SWIGRUNTIME swig_cast_info *
SWIG_TypeCheckStruct(swig_type_info * from,swig_type_info * ty)430 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
431 if (ty) {
432 swig_cast_info *iter = ty->cast;
433 while (iter) {
434 if (iter->type == from) {
435 if (iter == ty->cast)
436 return iter;
437 /* Move iter to the top of the linked list */
438 iter->prev->next = iter->next;
439 if (iter->next)
440 iter->next->prev = iter->prev;
441 iter->next = ty->cast;
442 iter->prev = 0;
443 if (ty->cast) ty->cast->prev = iter;
444 ty->cast = iter;
445 return iter;
446 }
447 iter = iter->next;
448 }
449 }
450 return 0;
451 }
452
453 /*
454 Cast a pointer up an inheritance hierarchy
455 */
456 SWIGRUNTIMEINLINE void *
SWIG_TypeCast(swig_cast_info * ty,void * ptr,int * newmemory)457 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
458 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
459 }
460
461 /*
462 Dynamic pointer casting. Down an inheritance hierarchy
463 */
464 SWIGRUNTIME swig_type_info *
SWIG_TypeDynamicCast(swig_type_info * ty,void ** ptr)465 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
466 swig_type_info *lastty = ty;
467 if (!ty || !ty->dcast) return ty;
468 while (ty && (ty->dcast)) {
469 ty = (*ty->dcast)(ptr);
470 if (ty) lastty = ty;
471 }
472 return lastty;
473 }
474
475 /*
476 Return the name associated with this type
477 */
478 SWIGRUNTIMEINLINE const char *
SWIG_TypeName(const swig_type_info * ty)479 SWIG_TypeName(const swig_type_info *ty) {
480 return ty->name;
481 }
482
483 /*
484 Return the pretty name associated with this type,
485 that is an unmangled type name in a form presentable to the user.
486 */
487 SWIGRUNTIME const char *
SWIG_TypePrettyName(const swig_type_info * type)488 SWIG_TypePrettyName(const swig_type_info *type) {
489 /* The "str" field contains the equivalent pretty names of the
490 type, separated by vertical-bar characters. We choose
491 to print the last name, as it is often (?) the most
492 specific. */
493 if (!type) return NULL;
494 if (type->str != NULL) {
495 const char *last_name = type->str;
496 const char *s;
497 for (s = type->str; *s; s++)
498 if (*s == '|') last_name = s+1;
499 return last_name;
500 }
501 else
502 return type->name;
503 }
504
505 /*
506 Set the clientdata field for a type
507 */
508 SWIGRUNTIME void
SWIG_TypeClientData(swig_type_info * ti,void * clientdata)509 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
510 swig_cast_info *cast = ti->cast;
511 /* if (ti->clientdata == clientdata) return; */
512 ti->clientdata = clientdata;
513
514 while (cast) {
515 if (!cast->converter) {
516 swig_type_info *tc = cast->type;
517 if (!tc->clientdata) {
518 SWIG_TypeClientData(tc, clientdata);
519 }
520 }
521 cast = cast->next;
522 }
523 }
524 SWIGRUNTIME void
SWIG_TypeNewClientData(swig_type_info * ti,void * clientdata)525 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
526 SWIG_TypeClientData(ti, clientdata);
527 ti->owndata = 1;
528 }
529
530 /*
531 Search for a swig_type_info structure only by mangled name
532 Search is a O(log #types)
533
534 We start searching at module start, and finish searching when start == end.
535 Note: if start == end at the beginning of the function, we go all the way around
536 the circular list.
537 */
538 SWIGRUNTIME swig_type_info *
SWIG_MangledTypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)539 SWIG_MangledTypeQueryModule(swig_module_info *start,
540 swig_module_info *end,
541 const char *name) {
542 swig_module_info *iter = start;
543 do {
544 if (iter->size) {
545 size_t l = 0;
546 size_t r = iter->size - 1;
547 do {
548 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
549 size_t i = (l + r) >> 1;
550 const char *iname = iter->types[i]->name;
551 if (iname) {
552 int compare = strcmp(name, iname);
553 if (compare == 0) {
554 return iter->types[i];
555 } else if (compare < 0) {
556 if (i) {
557 r = i - 1;
558 } else {
559 break;
560 }
561 } else if (compare > 0) {
562 l = i + 1;
563 }
564 } else {
565 break; /* should never happen */
566 }
567 } while (l <= r);
568 }
569 iter = iter->next;
570 } while (iter != end);
571 return 0;
572 }
573
574 /*
575 Search for a swig_type_info structure for either a mangled name or a human readable name.
576 It first searches the mangled names of the types, which is a O(log #types)
577 If a type is not found it then searches the human readable names, which is O(#types).
578
579 We start searching at module start, and finish searching when start == end.
580 Note: if start == end at the beginning of the function, we go all the way around
581 the circular list.
582 */
583 SWIGRUNTIME swig_type_info *
SWIG_TypeQueryModule(swig_module_info * start,swig_module_info * end,const char * name)584 SWIG_TypeQueryModule(swig_module_info *start,
585 swig_module_info *end,
586 const char *name) {
587 /* STEP 1: Search the name field using binary search */
588 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
589 if (ret) {
590 return ret;
591 } else {
592 /* STEP 2: If the type hasn't been found, do a complete search
593 of the str field (the human readable name) */
594 swig_module_info *iter = start;
595 do {
596 size_t i = 0;
597 for (; i < iter->size; ++i) {
598 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
599 return iter->types[i];
600 }
601 iter = iter->next;
602 } while (iter != end);
603 }
604
605 /* neither found a match */
606 return 0;
607 }
608
609 /*
610 Pack binary data into a string
611 */
612 SWIGRUNTIME char *
SWIG_PackData(char * c,void * ptr,size_t sz)613 SWIG_PackData(char *c, void *ptr, size_t sz) {
614 static const char hex[17] = "0123456789abcdef";
615 const unsigned char *u = (unsigned char *) ptr;
616 const unsigned char *eu = u + sz;
617 for (; u != eu; ++u) {
618 unsigned char uu = *u;
619 *(c++) = hex[(uu & 0xf0) >> 4];
620 *(c++) = hex[uu & 0xf];
621 }
622 return c;
623 }
624
625 /*
626 Unpack binary data from a string
627 */
628 SWIGRUNTIME const char *
SWIG_UnpackData(const char * c,void * ptr,size_t sz)629 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
630 unsigned char *u = (unsigned char *) ptr;
631 const unsigned char *eu = u + sz;
632 for (; u != eu; ++u) {
633 char d = *(c++);
634 unsigned char uu;
635 if ((d >= '0') && (d <= '9'))
636 uu = ((d - '0') << 4);
637 else if ((d >= 'a') && (d <= 'f'))
638 uu = ((d - ('a'-10)) << 4);
639 else
640 return (char *) 0;
641 d = *(c++);
642 if ((d >= '0') && (d <= '9'))
643 uu |= (d - '0');
644 else if ((d >= 'a') && (d <= 'f'))
645 uu |= (d - ('a'-10));
646 else
647 return (char *) 0;
648 *u = uu;
649 }
650 return c;
651 }
652
653 /*
654 Pack 'void *' into a string buffer.
655 */
656 SWIGRUNTIME char *
SWIG_PackVoidPtr(char * buff,void * ptr,const char * name,size_t bsz)657 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
658 char *r = buff;
659 if ((2*sizeof(void *) + 2) > bsz) return 0;
660 *(r++) = '_';
661 r = SWIG_PackData(r,&ptr,sizeof(void *));
662 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
663 strcpy(r,name);
664 return buff;
665 }
666
667 SWIGRUNTIME const char *
SWIG_UnpackVoidPtr(const char * c,void ** ptr,const char * name)668 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
669 if (*c != '_') {
670 if (strcmp(c,"NULL") == 0) {
671 *ptr = (void *) 0;
672 return name;
673 } else {
674 return 0;
675 }
676 }
677 return SWIG_UnpackData(++c,ptr,sizeof(void *));
678 }
679
680 SWIGRUNTIME char *
SWIG_PackDataName(char * buff,void * ptr,size_t sz,const char * name,size_t bsz)681 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
682 char *r = buff;
683 size_t lname = (name ? strlen(name) : 0);
684 if ((2*sz + 2 + lname) > bsz) return 0;
685 *(r++) = '_';
686 r = SWIG_PackData(r,ptr,sz);
687 if (lname) {
688 strncpy(r,name,lname+1);
689 } else {
690 *r = 0;
691 }
692 return buff;
693 }
694
695 SWIGRUNTIME const char *
SWIG_UnpackDataName(const char * c,void * ptr,size_t sz,const char * name)696 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
697 if (*c != '_') {
698 if (strcmp(c,"NULL") == 0) {
699 memset(ptr,0,sz);
700 return name;
701 } else {
702 return 0;
703 }
704 }
705 return SWIG_UnpackData(++c,ptr,sz);
706 }
707
708 #ifdef __cplusplus
709 }
710 #endif
711
712 /* Errors in SWIG */
713 #define SWIG_UnknownError -1
714 #define SWIG_IOError -2
715 #define SWIG_RuntimeError -3
716 #define SWIG_IndexError -4
717 #define SWIG_TypeError -5
718 #define SWIG_DivisionByZero -6
719 #define SWIG_OverflowError -7
720 #define SWIG_SyntaxError -8
721 #define SWIG_ValueError -9
722 #define SWIG_SystemError -10
723 #define SWIG_AttributeError -11
724 #define SWIG_MemoryError -12
725 #define SWIG_NullReferenceError -13
726
727
728
729 #ifdef __cplusplus
730 /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
731 #include <math.h>
732 #include <stdlib.h>
733 extern "C" {
734 #endif
735 #include "EXTERN.h"
736 #include "perl.h"
737 #include "XSUB.h"
738
739 /* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
740
741 /* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
742 #ifndef PERL_REVISION
743 # if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
744 # define PERL_PATCHLEVEL_H_IMPLICIT
745 # include <patchlevel.h>
746 # endif
747 # if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
748 # include <could_not_find_Perl_patchlevel.h>
749 # endif
750 # ifndef PERL_REVISION
751 # define PERL_REVISION (5)
752 # define PERL_VERSION PATCHLEVEL
753 # define PERL_SUBVERSION SUBVERSION
754 # endif
755 #endif
756
757 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
758 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
759 #endif
760
761 #ifndef SvIOK_UV
762 # define SvIOK_UV(sv) (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
763 #endif
764
765 #ifndef SvUOK
766 # define SvUOK(sv) SvIOK_UV(sv)
767 #endif
768
769 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
770 # define PL_sv_undef sv_undef
771 # define PL_na na
772 # define PL_errgv errgv
773 # define PL_sv_no sv_no
774 # define PL_sv_yes sv_yes
775 # define PL_markstack_ptr markstack_ptr
776 #endif
777
778 #ifndef IVSIZE
779 # ifdef LONGSIZE
780 # define IVSIZE LONGSIZE
781 # else
782 # define IVSIZE 4 /* A bold guess, but the best we can make. */
783 # endif
784 #endif
785
786 #ifndef INT2PTR
787 # if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
788 # define PTRV UV
789 # define INT2PTR(any,d) (any)(d)
790 # else
791 # if PTRSIZE == LONGSIZE
792 # define PTRV unsigned long
793 # else
794 # define PTRV unsigned
795 # endif
796 # define INT2PTR(any,d) (any)(PTRV)(d)
797 # endif
798
799 # define NUM2PTR(any,d) (any)(PTRV)(d)
800 # define PTR2IV(p) INT2PTR(IV,p)
801 # define PTR2UV(p) INT2PTR(UV,p)
802 # define PTR2NV(p) NUM2PTR(NV,p)
803
804 # if PTRSIZE == LONGSIZE
805 # define PTR2ul(p) (unsigned long)(p)
806 # else
807 # define PTR2ul(p) INT2PTR(unsigned long,p)
808 # endif
809 #endif /* !INT2PTR */
810
811 #ifndef SvPV_nolen
812 # define SvPV_nolen(x) SvPV(x,PL_na)
813 #endif
814
815 #ifndef get_sv
816 # define get_sv perl_get_sv
817 #endif
818
819 #ifndef ERRSV
820 # define ERRSV get_sv("@",FALSE)
821 #endif
822
823 #ifndef pTHX_
824 #define pTHX_
825 #endif
826
827 #include <string.h>
828 #ifdef __cplusplus
829 }
830 #endif
831
832 /* -----------------------------------------------------------------------------
833 * error manipulation
834 * ----------------------------------------------------------------------------- */
835
836 SWIGINTERN const char*
SWIG_Perl_ErrorType(int code)837 SWIG_Perl_ErrorType(int code) {
838 switch(code) {
839 case SWIG_MemoryError:
840 return "MemoryError";
841 case SWIG_IOError:
842 return "IOError";
843 case SWIG_RuntimeError:
844 return "RuntimeError";
845 case SWIG_IndexError:
846 return "IndexError";
847 case SWIG_TypeError:
848 return "TypeError";
849 case SWIG_DivisionByZero:
850 return "ZeroDivisionError";
851 case SWIG_OverflowError:
852 return "OverflowError";
853 case SWIG_SyntaxError:
854 return "SyntaxError";
855 case SWIG_ValueError:
856 return "ValueError";
857 case SWIG_SystemError:
858 return "SystemError";
859 case SWIG_AttributeError:
860 return "AttributeError";
861 default:
862 return "RuntimeError";
863 }
864 }
865
866
867 /* -----------------------------------------------------------------------------
868 * perlrun.swg
869 *
870 * This file contains the runtime support for Perl modules
871 * and includes code for managing global variables and pointer
872 * type checking.
873 * ----------------------------------------------------------------------------- */
874
875 #ifdef PERL_OBJECT
876 #define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
877 #define SWIG_PERL_OBJECT_CALL pPerl,
878 #else
879 #define SWIG_PERL_OBJECT_DECL
880 #define SWIG_PERL_OBJECT_CALL
881 #endif
882
883 /* Common SWIG API */
884
885 /* for raw pointers */
886 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
887 #define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
888 #define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
889 #define swig_owntype int
890
891 /* for raw packed data */
892 #define SWIG_ConvertPacked(obj, p, s, type) SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
893 #define SWIG_NewPackedObj(p, s, type) SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
894
895 /* for class or struct pointers */
896 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
897 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
898
899 /* for C or C++ function pointers */
900 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
901 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
902
903 /* for C++ member pointers, ie, member methods */
904 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_ConvertPacked(obj, ptr, sz, ty)
905 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_NewPackedObj(ptr, sz, type)
906
907
908 /* Runtime API */
909
910 #define SWIG_GetModule(clientdata) SWIG_Perl_GetModule(clientdata)
911 #define SWIG_SetModule(clientdata, pointer) SWIG_Perl_SetModule(pointer)
912
913
914 /* Error manipulation */
915
916 #define SWIG_ErrorType(code) SWIG_Perl_ErrorType(code)
917 #define SWIG_Error(code, msg) sv_setpvf(get_sv("@", GV_ADD), "%s %s", SWIG_ErrorType(code), msg)
918 #define SWIG_fail goto fail
919
920 /* Perl-specific SWIG API */
921
922 #define SWIG_MakePtr(sv, ptr, type, flags) SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
923 #define SWIG_MakePackedObj(sv, p, s, type) SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
924 #define SWIG_SetError(str) SWIG_Error(SWIG_RuntimeError, str)
925
926
927 #define SWIG_PERL_DECL_ARGS_1(arg1) (SWIG_PERL_OBJECT_DECL arg1)
928 #define SWIG_PERL_CALL_ARGS_1(arg1) (SWIG_PERL_OBJECT_CALL arg1)
929 #define SWIG_PERL_DECL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_DECL arg1, arg2)
930 #define SWIG_PERL_CALL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_CALL arg1, arg2)
931
932 /* -----------------------------------------------------------------------------
933 * pointers/data manipulation
934 * ----------------------------------------------------------------------------- */
935
936 /* For backward compatibility only */
937 #define SWIG_POINTER_EXCEPTION 0
938
939 #ifdef __cplusplus
940 extern "C" {
941 #endif
942
943 #define SWIG_OWNER SWIG_POINTER_OWN
944 #define SWIG_SHADOW SWIG_OWNER << 1
945
946 #define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
947
948 /* SWIG Perl macros */
949
950 /* Macro to declare an XS function */
951 #ifndef XSPROTO
952 # define XSPROTO(name) void name(pTHX_ CV* cv)
953 #endif
954
955 /* Macro to call an XS function */
956 #ifdef PERL_OBJECT
957 # define SWIG_CALLXS(_name) _name(cv,pPerl)
958 #else
959 # ifndef MULTIPLICITY
960 # define SWIG_CALLXS(_name) _name(cv)
961 # else
962 # define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
963 # endif
964 #endif
965
966 #ifdef PERL_OBJECT
967 #define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this;
968
969 #ifdef __cplusplus
970 extern "C" {
971 #endif
972 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
973 #ifdef __cplusplus
974 }
975 #endif
976
977 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
978 #define SWIGCLASS_STATIC
979
980 #else /* PERL_OBJECT */
981
982 #define MAGIC_PPERL
983 #define SWIGCLASS_STATIC static SWIGUNUSED
984
985 #ifndef MULTIPLICITY
986 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
987
988 #ifdef __cplusplus
989 extern "C" {
990 #endif
991 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
992 #ifdef __cplusplus
993 }
994 #endif
995
996 #else /* MULTIPLICITY */
997
998 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
999
1000 #ifdef __cplusplus
1001 extern "C" {
1002 #endif
1003 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
1004 #ifdef __cplusplus
1005 }
1006 #endif
1007
1008 #endif /* MULTIPLICITY */
1009 #endif /* PERL_OBJECT */
1010
1011 # ifdef PERL_OBJECT
1012 # define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
SWIG_Perl_croak_null(CPerlObj * pPerl)1013 static void SWIG_Perl_croak_null(CPerlObj *pPerl)
1014 # else
1015 static void SWIG_croak_null()
1016 # endif
1017 {
1018 SV *err = get_sv("@", GV_ADD);
1019 # if (PERL_VERSION < 6)
1020 croak("%_", err);
1021 # else
1022 if (sv_isobject(err))
1023 croak(0);
1024 else
1025 croak("%s", SvPV_nolen(err));
1026 # endif
1027 }
1028
1029
1030 /*
1031 Define how strict is the cast between strings and integers/doubles
1032 when overloading between these types occurs.
1033
1034 The default is making it as strict as possible by using SWIG_AddCast
1035 when needed.
1036
1037 You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
1038 disable the SWIG_AddCast, making the casting between string and
1039 numbers less strict.
1040
1041 In the end, we try to solve the overloading between strings and
1042 numerical types in the more natural way, but if you can avoid it,
1043 well, avoid it using %rename, for example.
1044 */
1045 #ifndef SWIG_PERL_NO_STRICT_STR2NUM
1046 # ifndef SWIG_PERL_STRICT_STR2NUM
1047 # define SWIG_PERL_STRICT_STR2NUM
1048 # endif
1049 #endif
1050 #ifdef SWIG_PERL_STRICT_STR2NUM
1051 /* string takes precedence */
1052 #define SWIG_Str2NumCast(x) SWIG_AddCast(x)
1053 #else
1054 /* number takes precedence */
1055 #define SWIG_Str2NumCast(x) x
1056 #endif
1057
1058
1059
1060 #include <stdlib.h>
1061
1062 SWIGRUNTIME const char *
SWIG_Perl_TypeProxyName(const swig_type_info * type)1063 SWIG_Perl_TypeProxyName(const swig_type_info *type) {
1064 if (!type) return NULL;
1065 if (type->clientdata != NULL) {
1066 return (const char*) type->clientdata;
1067 }
1068 else {
1069 return type->name;
1070 }
1071 }
1072
1073 /* Identical to SWIG_TypeCheck, except for strcmp comparison */
1074 SWIGRUNTIME swig_cast_info *
SWIG_TypeProxyCheck(const char * c,swig_type_info * ty)1075 SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
1076 if (ty) {
1077 swig_cast_info *iter = ty->cast;
1078 while (iter) {
1079 if (strcmp(SWIG_Perl_TypeProxyName(iter->type), c) == 0) {
1080 if (iter == ty->cast)
1081 return iter;
1082 /* Move iter to the top of the linked list */
1083 iter->prev->next = iter->next;
1084 if (iter->next)
1085 iter->next->prev = iter->prev;
1086 iter->next = ty->cast;
1087 iter->prev = 0;
1088 if (ty->cast) ty->cast->prev = iter;
1089 ty->cast = iter;
1090 return iter;
1091 }
1092 iter = iter->next;
1093 }
1094 }
1095 return 0;
1096 }
1097
1098 /* Function for getting a pointer value */
1099
1100 SWIGRUNTIME int
SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV * sv,void ** ptr,swig_type_info * _t,int flags,int * own)1101 SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
1102 swig_cast_info *tc;
1103 void *voidptr = (void *)0;
1104 SV *tsv = 0;
1105
1106 if (own)
1107 *own = 0;
1108
1109 /* If magical, apply more magic */
1110 if (SvGMAGICAL(sv))
1111 mg_get(sv);
1112
1113 /* Check to see if this is an object */
1114 if (sv_isobject(sv)) {
1115 IV tmp = 0;
1116 tsv = (SV*) SvRV(sv);
1117 if ((SvTYPE(tsv) == SVt_PVHV)) {
1118 MAGIC *mg;
1119 if (SvMAGICAL(tsv)) {
1120 mg = mg_find(tsv,'P');
1121 if (mg) {
1122 sv = mg->mg_obj;
1123 if (sv_isobject(sv)) {
1124 tsv = (SV*)SvRV(sv);
1125 tmp = SvIV(tsv);
1126 }
1127 }
1128 } else {
1129 return SWIG_ERROR;
1130 }
1131 } else {
1132 tmp = SvIV(tsv);
1133 }
1134 voidptr = INT2PTR(void *,tmp);
1135 } else if (! SvOK(sv)) { /* Check for undef */
1136 *(ptr) = (void *) 0;
1137 return SWIG_OK;
1138 } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
1139 if (!SvROK(sv)) {
1140 /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value. */
1141 if (SvIOK(sv)) {
1142 return SWIG_ERROR;
1143 } else {
1144 /* NULL pointer (reference to undef). */
1145 *(ptr) = (void *) 0;
1146 return SWIG_OK;
1147 }
1148 } else {
1149 return SWIG_ERROR;
1150 }
1151 } else { /* Don't know what it is */
1152 return SWIG_ERROR;
1153 }
1154 if (_t) {
1155 /* Now see if the types match */
1156 char *_c = HvNAME(SvSTASH(SvRV(sv)));
1157 tc = SWIG_TypeProxyCheck(_c,_t);
1158 #ifdef SWIG_DIRECTORS
1159 if (!tc && !sv_derived_from(sv,SWIG_Perl_TypeProxyName(_t))) {
1160 #else
1161 if (!tc) {
1162 #endif
1163 return SWIG_ERROR;
1164 }
1165 {
1166 int newmemory = 0;
1167 *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1168 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1169 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1170 if (own)
1171 *own = *own | SWIG_CAST_NEW_MEMORY;
1172 }
1173 }
1174 } else {
1175 *ptr = voidptr;
1176 }
1177
1178 /*
1179 * DISOWN implementation: we need a perl guru to check this one.
1180 */
1181 if (tsv && (flags & SWIG_POINTER_DISOWN)) {
1182 /*
1183 * almost copy paste code from below SWIG_POINTER_OWN setting
1184 */
1185 SV *obj = sv;
1186 HV *stash = SvSTASH(SvRV(obj));
1187 GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1188 if (isGV(gv)) {
1189 HV *hv = GvHVn(gv);
1190 /*
1191 * To set ownership (see below), a newSViv(1) entry is added.
1192 * Hence, to remove ownership, we delete the entry.
1193 */
1194 if (hv_exists_ent(hv, obj, 0)) {
1195 hv_delete_ent(hv, obj, 0, 0);
1196 }
1197 }
1198 }
1199 return SWIG_OK;
1200 }
1201
1202 SWIGRUNTIME int
1203 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
1204 return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
1205 }
1206
1207 SWIGRUNTIME void
1208 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
1209 if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
1210 SV *self;
1211 SV *obj=newSV(0);
1212 HV *hash=newHV();
1213 HV *stash;
1214 sv_setref_pv(obj, SWIG_Perl_TypeProxyName(t), ptr);
1215 stash=SvSTASH(SvRV(obj));
1216 if (flags & SWIG_POINTER_OWN) {
1217 HV *hv;
1218 GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1219 if (!isGV(gv))
1220 gv_init(gv, stash, "OWNER", 5, FALSE);
1221 hv=GvHVn(gv);
1222 hv_store_ent(hv, obj, newSViv(1), 0);
1223 }
1224 sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
1225 SvREFCNT_dec(obj);
1226 self=newRV_noinc((SV *)hash);
1227 sv_setsv(sv, self);
1228 SvREFCNT_dec((SV *)self);
1229 sv_bless(sv, stash);
1230 }
1231 else {
1232 sv_setref_pv(sv, SWIG_Perl_TypeProxyName(t), ptr);
1233 }
1234 }
1235
1236 SWIGRUNTIMEINLINE SV *
1237 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
1238 SV *result = sv_newmortal();
1239 SWIG_MakePtr(result, ptr, t, flags);
1240 return result;
1241 }
1242
1243 SWIGRUNTIME void
1244 SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
1245 char result[1024];
1246 char *r = result;
1247 if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
1248 *(r++) = '_';
1249 r = SWIG_PackData(r,ptr,sz);
1250 strcpy(r,SWIG_Perl_TypeProxyName(type));
1251 sv_setpv(sv, result);
1252 }
1253
1254 SWIGRUNTIME SV *
1255 SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
1256 SV *result = sv_newmortal();
1257 SWIG_Perl_MakePackedObj(result, ptr, sz, type);
1258 return result;
1259 }
1260
1261 /* Convert a packed value value */
1262 SWIGRUNTIME int
1263 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
1264 swig_cast_info *tc;
1265 const char *c = 0;
1266
1267 if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
1268 c = SvPV_nolen(obj);
1269 /* Pointer values must start with leading underscore */
1270 if (*c != '_') return SWIG_ERROR;
1271 c++;
1272 c = SWIG_UnpackData(c,ptr,sz);
1273 if (ty) {
1274 tc = SWIG_TypeCheck(c,ty);
1275 if (!tc) return SWIG_ERROR;
1276 }
1277 return SWIG_OK;
1278 }
1279
1280
1281 /* Macros for low-level exception handling */
1282 #define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
1283
1284
1285 typedef XSPROTO(SwigPerlWrapper);
1286 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
1287
1288 /* Structure for command table */
1289 typedef struct {
1290 const char *name;
1291 SwigPerlWrapperPtr wrapper;
1292 } swig_command_info;
1293
1294 /* Information for constant table */
1295
1296 #define SWIG_INT 1
1297 #define SWIG_FLOAT 2
1298 #define SWIG_STRING 3
1299 #define SWIG_POINTER 4
1300 #define SWIG_BINARY 5
1301
1302 /* Constant information structure */
1303 typedef struct swig_constant_info {
1304 int type;
1305 const char *name;
1306 long lvalue;
1307 double dvalue;
1308 void *pvalue;
1309 swig_type_info **ptype;
1310 } swig_constant_info;
1311
1312
1313 /* Structure for variable table */
1314 typedef struct {
1315 const char *name;
1316 SwigMagicFunc set;
1317 SwigMagicFunc get;
1318 swig_type_info **type;
1319 } swig_variable_info;
1320
1321 /* Magic variable code */
1322 #ifndef PERL_OBJECT
1323 # ifdef __cplusplus
1324 # define swig_create_magic(s,a,b,c) _swig_create_magic(s,const_cast<char*>(a),b,c)
1325 # else
1326 # define swig_create_magic(s,a,b,c) _swig_create_magic(s,(char*)(a),b,c)
1327 # endif
1328 # ifndef MULTIPLICITY
1329 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
1330 # else
1331 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
1332 # endif
1333 #else
1334 # define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
1335 SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
1336 #endif
1337 {
1338 MAGIC *mg;
1339 sv_magic(sv,sv,'U',name,strlen(name));
1340 mg = mg_find(sv,'U');
1341 mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1342 mg->mg_virtual->svt_get = (SwigMagicFunc) get;
1343 mg->mg_virtual->svt_set = (SwigMagicFunc) set;
1344 mg->mg_virtual->svt_len = 0;
1345 mg->mg_virtual->svt_clear = 0;
1346 mg->mg_virtual->svt_free = 0;
1347 }
1348
1349
1350 SWIGRUNTIME swig_module_info *
1351 SWIG_Perl_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
1352 static void *type_pointer = (void *)0;
1353 SV *pointer;
1354
1355 /* first check if pointer already created */
1356 if (!type_pointer) {
1357 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
1358 if (pointer && SvOK(pointer)) {
1359 type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
1360 }
1361 }
1362
1363 return (swig_module_info *) type_pointer;
1364 }
1365
1366 SWIGRUNTIME void
1367 SWIG_Perl_SetModule(swig_module_info *module) {
1368 SV *pointer;
1369
1370 /* create a new pointer */
1371 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
1372 sv_setiv(pointer, PTR2IV(module));
1373 }
1374
1375 #ifdef __cplusplus
1376 }
1377 #endif
1378
1379 /* Workaround perl5 global namespace pollution. Note that undefining library
1380 * functions like fopen will not solve the problem on all platforms as fopen
1381 * might be a macro on Windows but not necessarily on other operating systems. */
1382 #ifdef do_open
1383 #undef do_open
1384 #endif
1385 #ifdef do_close
1386 #undef do_close
1387 #endif
1388 #ifdef do_exec
1389 #undef do_exec
1390 #endif
1391 #ifdef scalar
1392 #undef scalar
1393 #endif
1394 #ifdef list
1395 #undef list
1396 #endif
1397 #ifdef apply
1398 #undef apply
1399 #endif
1400 #ifdef convert
1401 #undef convert
1402 #endif
1403 #ifdef Error
1404 #undef Error
1405 #endif
1406 #ifdef form
1407 #undef form
1408 #endif
1409 #ifdef vform
1410 #undef vform
1411 #endif
1412 #ifdef LABEL
1413 #undef LABEL
1414 #endif
1415 #ifdef METHOD
1416 #undef METHOD
1417 #endif
1418 #ifdef Move
1419 #undef Move
1420 #endif
1421 #ifdef yylex
1422 #undef yylex
1423 #endif
1424 #ifdef yyparse
1425 #undef yyparse
1426 #endif
1427 #ifdef yyerror
1428 #undef yyerror
1429 #endif
1430 #ifdef invert
1431 #undef invert
1432 #endif
1433 #ifdef ref
1434 #undef ref
1435 #endif
1436 #ifdef read
1437 #undef read
1438 #endif
1439 #ifdef write
1440 #undef write
1441 #endif
1442 #ifdef eof
1443 #undef eof
1444 #endif
1445 #ifdef close
1446 #undef close
1447 #endif
1448 #ifdef rewind
1449 #undef rewind
1450 #endif
1451 #ifdef free
1452 #undef free
1453 #endif
1454 #ifdef malloc
1455 #undef malloc
1456 #endif
1457 #ifdef calloc
1458 #undef calloc
1459 #endif
1460 #ifdef Stat
1461 #undef Stat
1462 #endif
1463 #ifdef check
1464 #undef check
1465 #endif
1466 #ifdef seekdir
1467 #undef seekdir
1468 #endif
1469 #ifdef open
1470 #undef open
1471 #endif
1472 #ifdef readdir
1473 #undef readdir
1474 #endif
1475 #ifdef bind
1476 #undef bind
1477 #endif
1478 #ifdef access
1479 #undef access
1480 #endif
1481 #ifdef stat
1482 #undef stat
1483 #endif
1484 #ifdef seed
1485 #undef seed
1486 #endif
1487
1488 #ifdef bool
1489 /* Leave if macro is from C99 stdbool.h */
1490 #ifndef __bool_true_false_are_defined
1491
1492 #endif
1493 #endif
1494
1495
1496
1497
1498 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1499
1500 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1501
1502
1503
1504 #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
1505
1506
1507 /* -------- TYPES TABLE (BEGIN) -------- */
1508
1509 #define SWIGTYPE_p_DirectTCPAddr swig_types[0]
1510 #define SWIGTYPE_p_Xfer swig_types[1]
1511 #define SWIGTYPE_p_XferElement swig_types[2]
1512 #define SWIGTYPE_p_amglue_Source swig_types[3]
1513 #define SWIGTYPE_p_char swig_types[4]
1514 #define SWIGTYPE_p_double swig_types[5]
1515 #define SWIGTYPE_p_float swig_types[6]
1516 #define SWIGTYPE_p_gint64 swig_types[7]
1517 #define SWIGTYPE_p_gsize swig_types[8]
1518 #define SWIGTYPE_p_guint32 swig_types[9]
1519 #define SWIGTYPE_p_guint64 swig_types[10]
1520 #define SWIGTYPE_p_int swig_types[11]
1521 #define SWIGTYPE_p_p_XferElement swig_types[12]
1522 #define SWIGTYPE_p_p_char swig_types[13]
1523 #define SWIGTYPE_p_p_void swig_types[14]
1524 #define SWIGTYPE_p_unsigned_char swig_types[15]
1525 static swig_type_info *swig_types[17];
1526 static swig_module_info swig_module = {swig_types, 16, 0, 0, 0, 0};
1527 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1528 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1529
1530 /* -------- TYPES TABLE (END) -------- */
1531
1532 #define SWIG_init boot_Amanda__Xfer
1533
1534 #define SWIG_name "Amanda::Xferc::boot_Amanda__Xfer"
1535 #define SWIG_prefix "Amanda::Xferc::"
1536
1537 #define SWIGVERSION 0x030007
1538 #define SWIG_VERSION SWIGVERSION
1539
1540
1541 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1542 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1543
1544
1545 #ifdef __cplusplus
1546 extern "C"
1547 #endif
1548 #ifndef PERL_OBJECT
1549 #ifndef MULTIPLICITY
1550 SWIGEXPORT void SWIG_init (CV* cv);
1551 #else
1552 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1553 #endif
1554 #else
1555 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1556 #endif
1557
1558
1559 #include "amglue.h"
1560
1561
1562 #include "amglue.h"
1563
1564
1565 #include "amglue.h"
1566
1567
1568 #include "glib-util.h"
1569 #include "amxfer.h"
1570 #include "amanda.h"
1571 #include "sockaddr-util.h"
1572
1573
1574 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(long value)1575 SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value)
1576 {
1577 SV *sv;
1578 if (value >= IV_MIN && value <= IV_MAX)
1579 sv = newSViv(value);
1580 else
1581 sv = newSVpvf("%ld", value);
1582 return sv_2mortal(sv);
1583 }
1584
1585
1586 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(int value)1587 SWIG_From_int SWIG_PERL_DECL_ARGS_1(int value)
1588 {
1589 return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
1590 }
1591
1592
1593 /* Given an XMsg, return a hashref representing the message as a pure-perl
1594 * object. The object is new, has refcount 1, and is totally independent of
1595 * the underlying XMsg.
1596 *
1597 * Reflecting the XMsg directly into Perl avoids the need to reference-count
1598 * the XMsg objects themselves, which can simply be freed after a callback
1599 * completes. The overhead of creating a hash is likely equivalent to or
1600 * less than the overhead that would be consumed with SWIG's swig_$field_get
1601 * accessors, assuming that perl code examines most of the fields in a message.
1602 *
1603 * @param msg: the message to represent
1604 * @returns: a perl SV
1605 */
1606 static SV *
new_sv_for_xmsg(XMsg * msg)1607 new_sv_for_xmsg(
1608 XMsg *msg)
1609 {
1610 static HV *amanda_xfer_msg_stash = NULL;
1611 HV *hash = newHV();
1612 SV *rv = newRV_noinc((SV *)hash);
1613
1614 /* bless the rv as an Amanda::Xfer::Msg object */
1615 if (!amanda_xfer_msg_stash) {
1616 amanda_xfer_msg_stash = gv_stashpv("Amanda::Xfer::Msg", GV_ADD);
1617 }
1618 sv_bless(rv, amanda_xfer_msg_stash);
1619
1620 /* TODO: consider optimizing by precomputing the hash values of
1621 * the keys? */
1622
1623 /* elt */
1624 hv_store(hash, "elt", 3, new_sv_for_xfer_element(msg->elt), 0);
1625
1626 /* type */
1627 hv_store(hash, "type", 4, newSViv(msg->type), 0);
1628
1629 /* type */
1630 hv_store(hash, "version", 7, newSViv(msg->version), 0);
1631
1632 /* message */
1633 if (msg->message)
1634 hv_store(hash, "message", 7, newSVpv(msg->message, 0), 0);
1635
1636 /* successful */
1637 hv_store(hash, "successful", 10, newSViv(msg->successful), 0);
1638
1639 /* eom */
1640 hv_store(hash, "eom", 3, newSViv(msg->eom), 0);
1641
1642 /* eof */
1643 hv_store(hash, "eof", 3, newSViv(msg->eof), 0);
1644
1645 /* size */
1646 hv_store(hash, "size", 4, amglue_newSVu64(msg->size), 0);
1647
1648 /* duration */
1649 hv_store(hash, "duration", 8, newSVnv(msg->duration), 0);
1650
1651 /* partnum */
1652 hv_store(hash, "partnum", 7, amglue_newSVu64(msg->partnum), 0);
1653
1654 /* fileno */
1655 hv_store(hash, "fileno", 6, amglue_newSVu64(msg->fileno), 0);
1656
1657 return rv;
1658 }
1659
1660
1661 #include <limits.h>
1662 #if !defined(SWIG_NO_LLONG_MAX)
1663 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1664 # define LLONG_MAX __LONG_LONG_MAX__
1665 # define LLONG_MIN (-LLONG_MAX - 1LL)
1666 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1667 # endif
1668 #endif
1669
1670
1671 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,double * val)1672 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1673 {
1674 if (SvNIOK(obj)) {
1675 if (val) *val = SvNV(obj);
1676 return SWIG_OK;
1677 } else if (SvIOK(obj)) {
1678 if (val) *val = (double) SvIV(obj);
1679 return SWIG_AddCast(SWIG_OK);
1680 } else {
1681 const char *nptr = SvPV_nolen(obj);
1682 if (nptr) {
1683 char *endptr;
1684 double v;
1685 errno = 0;
1686 v = strtod(nptr, &endptr);
1687 if (errno == ERANGE) {
1688 errno = 0;
1689 return SWIG_OverflowError;
1690 } else {
1691 if (*endptr == '\0') {
1692 if (val) *val = v;
1693 return SWIG_Str2NumCast(SWIG_OK);
1694 }
1695 }
1696 }
1697 }
1698 return SWIG_TypeError;
1699 }
1700
1701
1702 #include <float.h>
1703
1704
1705 #include <math.h>
1706
1707
1708 SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double * d,double min,double max)1709 SWIG_CanCastAsInteger(double *d, double min, double max) {
1710 double x = *d;
1711 if ((min <= x && x <= max)) {
1712 double fx = floor(x);
1713 double cx = ceil(x);
1714 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1715 if ((errno == EDOM) || (errno == ERANGE)) {
1716 errno = 0;
1717 } else {
1718 double summ, reps, diff;
1719 if (rd < x) {
1720 diff = x - rd;
1721 } else if (rd > x) {
1722 diff = rd - x;
1723 } else {
1724 return 1;
1725 }
1726 summ = rd + x;
1727 reps = diff/summ;
1728 if (reps < 8*DBL_EPSILON) {
1729 *d = rd;
1730 return 1;
1731 }
1732 }
1733 }
1734 return 0;
1735 }
1736
1737
1738 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned long * val)1739 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
1740 {
1741 if (SvUOK(obj)) {
1742 UV v = SvUV(obj);
1743 if (v <= ULONG_MAX) {
1744 if (val) *val = v;
1745 return SWIG_OK;
1746 }
1747 return SWIG_OverflowError;
1748 } else if (SvIOK(obj)) {
1749 IV v = SvIV(obj);
1750 if (v >= 0 && v <= ULONG_MAX) {
1751 if (val) *val = v;
1752 return SWIG_OK;
1753 }
1754 return SWIG_OverflowError;
1755 } else {
1756 int dispatch = 0;
1757 const char *nptr = SvPV_nolen(obj);
1758 if (nptr) {
1759 char *endptr;
1760 unsigned long v;
1761 errno = 0;
1762 v = strtoul(nptr, &endptr,0);
1763 if (errno == ERANGE) {
1764 errno = 0;
1765 return SWIG_OverflowError;
1766 } else {
1767 if (*endptr == '\0') {
1768 if (val) *val = v;
1769 return SWIG_Str2NumCast(SWIG_OK);
1770 }
1771 }
1772 }
1773 if (!dispatch) {
1774 double d;
1775 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1776 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
1777 if (val) *val = (unsigned long)(d);
1778 return res;
1779 }
1780 }
1781 }
1782 return SWIG_TypeError;
1783 }
1784
1785
1786 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned int * val)1787 SWIG_AsVal_unsigned_SS_int SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned int *val)
1788 {
1789 unsigned long v;
1790 int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1791 if (SWIG_IsOK(res)) {
1792 if ((v > UINT_MAX)) {
1793 return SWIG_OverflowError;
1794 } else {
1795 if (val) *val = (unsigned int)(v);
1796 }
1797 }
1798 return res;
1799 }
1800
1801
1802 SWIGINTERNINLINE SV *
SWIG_FromCharPtrAndSize(const char * carray,size_t size)1803 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1804 {
1805 SV *obj = sv_newmortal();
1806 if (carray) {
1807 sv_setpvn(obj, carray, size);
1808 } else {
1809 sv_setsv(obj, &PL_sv_undef);
1810 }
1811 return obj;
1812 }
1813
1814
1815 SWIGINTERNINLINE SV *
SWIG_FromCharPtr(const char * cptr)1816 SWIG_FromCharPtr(const char *cptr)
1817 {
1818 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1819 }
1820
1821
1822 /* SWIG wants to treat this as a function */
1823 #define xfer_get_status(xfer) ((xfer)->status)
1824
1825
same_elements(XferElement * a,XferElement * b)1826 static gboolean same_elements(
1827 XferElement *a,
1828 XferElement *b)
1829 {
1830 return a == b;
1831 }
1832
1833
1834 SWIGINTERNINLINE int
SWIG_PERL_DECL_ARGS_2(SV * obj,size_t * val)1835 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
1836 {
1837 unsigned long v;
1838 int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
1839 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
1840 return res;
1841 }
1842
1843
1844 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,long * val)1845 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1846 {
1847 if (SvUOK(obj)) {
1848 UV v = SvUV(obj);
1849 if (v <= LONG_MAX) {
1850 if (val) *val = v;
1851 return SWIG_OK;
1852 }
1853 return SWIG_OverflowError;
1854 } else if (SvIOK(obj)) {
1855 IV v = SvIV(obj);
1856 if (v >= LONG_MIN && v <= LONG_MAX) {
1857 if(val) *val = v;
1858 return SWIG_OK;
1859 }
1860 return SWIG_OverflowError;
1861 } else {
1862 int dispatch = 0;
1863 const char *nptr = SvPV_nolen(obj);
1864 if (nptr) {
1865 char *endptr;
1866 long v;
1867 errno = 0;
1868 v = strtol(nptr, &endptr,0);
1869 if (errno == ERANGE) {
1870 errno = 0;
1871 return SWIG_OverflowError;
1872 } else {
1873 if (*endptr == '\0') {
1874 if (val) *val = v;
1875 return SWIG_Str2NumCast(SWIG_OK);
1876 }
1877 }
1878 }
1879 if (!dispatch) {
1880 double d;
1881 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1882 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1883 if (val) *val = (long)(d);
1884 return res;
1885 }
1886 }
1887 }
1888 return SWIG_TypeError;
1889 }
1890
1891
1892 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,int * val)1893 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1894 {
1895 long v;
1896 int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1897 if (SWIG_IsOK(res)) {
1898 if ((v < INT_MIN || v > INT_MAX)) {
1899 return SWIG_OverflowError;
1900 } else {
1901 if (val) *val = (int)(v);
1902 }
1903 }
1904 return res;
1905 }
1906
1907
1908 static DirectTCPAddr *
xfer_source_directtcp_listen_get_addrs(XferElement * elt)1909 xfer_source_directtcp_listen_get_addrs(XferElement *elt) {
1910 return elt->input_listen_addrs;
1911 }
1912
1913
1914 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned char * val)1915 SWIG_AsVal_unsigned_SS_char SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned char *val)
1916 {
1917 unsigned long v;
1918 int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1919 if (SWIG_IsOK(res)) {
1920 if ((v > UCHAR_MAX)) {
1921 return SWIG_OverflowError;
1922 } else {
1923 if (val) *val = (unsigned char)(v);
1924 }
1925 }
1926 return res;
1927 }
1928
1929
1930 static DirectTCPAddr *
xfer_dest_directtcp_listen_get_addrs(XferElement * elt)1931 xfer_dest_directtcp_listen_get_addrs(XferElement *elt) {
1932 return elt->output_listen_addrs;
1933 }
1934
1935
1936 static gboolean
xmsgsource_perl_callback(gpointer data,struct XMsg * msg,Xfer * xfer)1937 xmsgsource_perl_callback(
1938 gpointer data,
1939 struct XMsg *msg,
1940 Xfer *xfer)
1941 {
1942 dSP;
1943 amglue_Source *src = (amglue_Source *)data;
1944 SV *src_sv = NULL;
1945 SV *msg_sv = NULL;
1946 SV *xfer_sv = NULL;
1947
1948 /* keep the source around long enough for the call to finish */
1949 amglue_source_ref(src);
1950 g_assert(src->callback_sv != NULL);
1951
1952 ENTER;
1953 SAVETMPS;
1954
1955 /* create a new SV pointing to 'src', and increase its refcount
1956 * accordingly. */
1957 amglue_source_ref(src);
1958 src_sv = SWIG_NewPointerObj(src, SWIGTYPE_p_amglue_Source,
1959 SWIG_OWNER | SWIG_SHADOW);
1960 SvREFCNT_inc(src_sv);
1961
1962 msg_sv = new_sv_for_xmsg(msg);
1963 xfer_sv = new_sv_for_xfer(xfer);
1964
1965 PUSHMARK(SP);
1966 XPUSHs(sv_2mortal(src_sv));
1967 XPUSHs(sv_2mortal(msg_sv));
1968 XPUSHs(sv_2mortal(xfer_sv));
1969 PUTBACK;
1970
1971 call_sv(src->callback_sv, G_EVAL|G_DISCARD);
1972
1973 FREETMPS;
1974 LEAVE;
1975
1976 /* we no longer need the src */
1977 amglue_source_unref(src);
1978 src = NULL;
1979
1980 /* these may be gone, so NULL them out */
1981 src_sv = NULL;
1982 msg_sv = NULL;
1983 xfer_sv = NULL;
1984
1985 /* check for an uncaught 'die'. If we don't do this, then Perl will longjmp()
1986 * over the GMainLoop mechanics, leaving GMainLoop in an inconsistent (locked)
1987 * state. */
1988 if (SvTRUE(ERRSV)) {
1989 /* We handle this just the way the default 'die' handler in Amanda::Debug
1990 * does, but since Amanda's debug support may not yet be running, we back
1991 * it up with an exit() */
1992 g_critical("%s", SvPV_nolen(ERRSV));
1993 exit(1);
1994 }
1995
1996 return TRUE;
1997 }
1998
1999
2000 amglue_Source *
xfer_get_amglue_source(Xfer * xfer)2001 xfer_get_amglue_source(
2002 Xfer *xfer)
2003 {
2004 return amglue_source_get(xfer_get_source(xfer),
2005 (GSourceFunc)xmsgsource_perl_callback);
2006 }
2007
2008 #ifdef __cplusplus
2009 extern "C" {
2010 #endif
2011
2012 #ifdef PERL_OBJECT
2013 #define MAGIC_CLASS _wrap_Amanda__Xfer_var::
2014 class _wrap_Amanda__Xfer_var : public CPerlObj {
2015 public:
2016 #else
2017 #define MAGIC_CLASS
2018 #endif
swig_magic_readonly(pTHX_ SV * SWIGUNUSEDPARM (sv),MAGIC * SWIGUNUSEDPARM (mg))2019 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
2020 MAGIC_PPERL
2021 croak("Value is read-only.");
2022 return 0;
2023 }
2024
2025
2026 #ifdef PERL_OBJECT
2027 };
2028 #endif
2029
2030 #ifdef __cplusplus
2031 }
2032 #endif
2033
2034 #ifdef __cplusplus
2035 extern "C" {
2036 #endif
XS(_wrap_xfer_new)2037 XS(_wrap_xfer_new) {
2038 {
2039 XferElement **arg1 = (XferElement **) 0 ;
2040 unsigned int arg2 ;
2041 int argvi = 0;
2042 Xfer *result = 0 ;
2043 dXSARGS;
2044
2045 if ((items < 1) || (items > 1)) {
2046 SWIG_croak("Usage: xfer_new(elementlist,nelements);");
2047 }
2048 {
2049 AV *av;
2050 unsigned int i;
2051
2052 /* check that it's an arrayref */
2053 if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
2054 SWIG_exception(SWIG_TypeError, "Expected an arrayref");
2055 }
2056 av = (AV *)SvRV(ST(0));
2057
2058 /* allocate memory for arg1 */
2059 arg2 = av_len(av)+1; /* av_len(av) is like $#av */
2060 arg1 = g_new(XferElement *, arg2);
2061
2062 /* extract the underlying XferElement objects and add pointers to
2063 * them, "borrowing" the caller's references for the moment. */
2064 for (i = 0; i < arg2; i++) {
2065 SV **sv = av_fetch(av, i, 0);
2066 XferElement *elt = sv? xfer_element_from_sv(*sv):NULL;
2067
2068 if (!elt) {
2069 SWIG_exception(SWIG_TypeError, "Expected an arrayref of Amanda::Xfer::Element objects");
2070 }
2071 arg1[i] = elt;
2072 }
2073 }
2074 result = (Xfer *)xfer_new(arg1,arg2);
2075 {
2076 ST(argvi) = sv_2mortal(new_sv_for_xfer(result));
2077 argvi++;
2078 }
2079 {
2080 /* free the element vector allocated in the (in) typemap */
2081 g_free(arg1);
2082 }
2083 {
2084 xfer_unref(result);
2085 }
2086 XSRETURN(argvi);
2087 fail:
2088 {
2089 /* free the element vector allocated in the (in) typemap */
2090 g_free(arg1);
2091 }
2092 SWIG_croak_null();
2093 }
2094 }
2095
2096
XS(_wrap_xfer_unref)2097 XS(_wrap_xfer_unref) {
2098 {
2099 Xfer *arg1 = (Xfer *) 0 ;
2100 int argvi = 0;
2101 dXSARGS;
2102
2103 if ((items < 1) || (items > 1)) {
2104 SWIG_croak("Usage: xfer_unref(Xfer *);");
2105 }
2106 {
2107 arg1 = xfer_from_sv(ST(0));
2108 }
2109 xfer_unref(arg1);
2110 ST(argvi) = sv_newmortal();
2111
2112 XSRETURN(argvi);
2113 fail:
2114
2115 SWIG_croak_null();
2116 }
2117 }
2118
2119
XS(_wrap_xfer_get_status)2120 XS(_wrap_xfer_get_status) {
2121 {
2122 Xfer *arg1 = (Xfer *) 0 ;
2123 int argvi = 0;
2124 xfer_status result;
2125 dXSARGS;
2126
2127 if ((items < 1) || (items > 1)) {
2128 SWIG_croak("Usage: xfer_get_status(xfer);");
2129 }
2130 {
2131 arg1 = xfer_from_sv(ST(0));
2132 }
2133 result = (xfer_status)xfer_get_status(arg1);
2134 {
2135 SV *for_stack;
2136 SP += argvi; PUTBACK;
2137 for_stack = sv_2mortal(amglue_newSVi64(result));
2138 SPAGAIN; SP -= argvi;
2139 ST(argvi) = for_stack;
2140 argvi++;
2141 }
2142
2143 XSRETURN(argvi);
2144 fail:
2145
2146 SWIG_croak_null();
2147 }
2148 }
2149
2150
XS(_wrap_xfer_repr)2151 XS(_wrap_xfer_repr) {
2152 {
2153 Xfer *arg1 = (Xfer *) 0 ;
2154 int argvi = 0;
2155 char *result = 0 ;
2156 dXSARGS;
2157
2158 if ((items < 1) || (items > 1)) {
2159 SWIG_croak("Usage: xfer_repr(xfer);");
2160 }
2161 {
2162 arg1 = xfer_from_sv(ST(0));
2163 }
2164 result = (char *)xfer_repr(arg1);
2165 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2166
2167 XSRETURN(argvi);
2168 fail:
2169
2170 SWIG_croak_null();
2171 }
2172 }
2173
2174
XS(_wrap_xfer_start)2175 XS(_wrap_xfer_start) {
2176 {
2177 Xfer *arg1 = (Xfer *) 0 ;
2178 gint64 arg2 ;
2179 gint64 arg3 ;
2180 int argvi = 0;
2181 dXSARGS;
2182
2183 if ((items < 3) || (items > 3)) {
2184 SWIG_croak("Usage: xfer_start(xfer,offset,size);");
2185 }
2186 {
2187 arg1 = xfer_from_sv(ST(0));
2188 }
2189 {
2190 arg2 = amglue_SvI64(ST(1));
2191 }
2192 {
2193 arg3 = amglue_SvI64(ST(2));
2194 }
2195 xfer_start(arg1,arg2,arg3);
2196 ST(argvi) = sv_newmortal();
2197
2198 XSRETURN(argvi);
2199 fail:
2200
2201 SWIG_croak_null();
2202 }
2203 }
2204
2205
XS(_wrap_xfer_cancel)2206 XS(_wrap_xfer_cancel) {
2207 {
2208 Xfer *arg1 = (Xfer *) 0 ;
2209 int argvi = 0;
2210 dXSARGS;
2211
2212 if ((items < 1) || (items > 1)) {
2213 SWIG_croak("Usage: xfer_cancel(xfer);");
2214 }
2215 {
2216 arg1 = xfer_from_sv(ST(0));
2217 }
2218 xfer_cancel(arg1);
2219 ST(argvi) = sv_newmortal();
2220
2221 XSRETURN(argvi);
2222 fail:
2223
2224 SWIG_croak_null();
2225 }
2226 }
2227
2228
XS(_wrap_xfer_element_unref)2229 XS(_wrap_xfer_element_unref) {
2230 {
2231 XferElement *arg1 = (XferElement *) 0 ;
2232 int argvi = 0;
2233 dXSARGS;
2234
2235 if ((items < 1) || (items > 1)) {
2236 SWIG_croak("Usage: xfer_element_unref(elt);");
2237 }
2238 {
2239 arg1 = xfer_element_from_sv(ST(0));
2240 }
2241 xfer_element_unref(arg1);
2242 ST(argvi) = sv_newmortal();
2243
2244 XSRETURN(argvi);
2245 fail:
2246
2247 SWIG_croak_null();
2248 }
2249 }
2250
2251
XS(_wrap_xfer_element_repr)2252 XS(_wrap_xfer_element_repr) {
2253 {
2254 XferElement *arg1 = (XferElement *) 0 ;
2255 int argvi = 0;
2256 char *result = 0 ;
2257 dXSARGS;
2258
2259 if ((items < 1) || (items > 1)) {
2260 SWIG_croak("Usage: xfer_element_repr(elt);");
2261 }
2262 {
2263 arg1 = xfer_element_from_sv(ST(0));
2264 }
2265 result = (char *)xfer_element_repr(arg1);
2266 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2267
2268 XSRETURN(argvi);
2269 fail:
2270
2271 SWIG_croak_null();
2272 }
2273 }
2274
2275
XS(_wrap_same_elements)2276 XS(_wrap_same_elements) {
2277 {
2278 XferElement *arg1 = (XferElement *) 0 ;
2279 XferElement *arg2 = (XferElement *) 0 ;
2280 int argvi = 0;
2281 gboolean result;
2282 dXSARGS;
2283
2284 if ((items < 2) || (items > 2)) {
2285 SWIG_croak("Usage: same_elements(a,b);");
2286 }
2287 {
2288 arg1 = xfer_element_from_sv(ST(0));
2289 }
2290 {
2291 arg2 = xfer_element_from_sv(ST(1));
2292 }
2293 result = (gboolean)same_elements(arg1,arg2);
2294 {
2295 if (result)
2296 ST(argvi) = &PL_sv_yes;
2297 else
2298 ST(argvi) = &PL_sv_no;
2299 argvi++;
2300 }
2301
2302
2303 XSRETURN(argvi);
2304 fail:
2305
2306
2307 SWIG_croak_null();
2308 }
2309 }
2310
2311
XS(_wrap_xfer_source_random)2312 XS(_wrap_xfer_source_random) {
2313 {
2314 guint64 arg1 ;
2315 guint32 arg2 ;
2316 int argvi = 0;
2317 XferElement *result = 0 ;
2318 dXSARGS;
2319
2320 if ((items < 2) || (items > 2)) {
2321 SWIG_croak("Usage: xfer_source_random(length,seed);");
2322 }
2323 {
2324 arg1 = amglue_SvU64(ST(0));
2325 }
2326 {
2327 arg2 = amglue_SvU32(ST(1));
2328 }
2329 result = (XferElement *)xfer_source_random(arg1,arg2);
2330 {
2331 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2332 argvi++;
2333 }
2334 {
2335 xfer_element_unref(result);
2336 }
2337 XSRETURN(argvi);
2338 fail:
2339 SWIG_croak_null();
2340 }
2341 }
2342
2343
XS(_wrap_xfer_source_random_get_seed)2344 XS(_wrap_xfer_source_random_get_seed) {
2345 {
2346 XferElement *arg1 = (XferElement *) 0 ;
2347 int argvi = 0;
2348 guint32 result;
2349 dXSARGS;
2350
2351 if ((items < 1) || (items > 1)) {
2352 SWIG_croak("Usage: xfer_source_random_get_seed(self);");
2353 }
2354 {
2355 arg1 = xfer_element_from_sv(ST(0));
2356 }
2357 result = xfer_source_random_get_seed(arg1);
2358 {
2359 SV *for_stack;
2360 SP += argvi; PUTBACK;
2361 for_stack = sv_2mortal(amglue_newSVu64(result));
2362 SPAGAIN; SP -= argvi;
2363 ST(argvi) = for_stack;
2364 argvi++;
2365 }
2366
2367 XSRETURN(argvi);
2368 fail:
2369
2370 SWIG_croak_null();
2371 }
2372 }
2373
2374
XS(_wrap_xfer_source_pattern)2375 XS(_wrap_xfer_source_pattern) {
2376 {
2377 guint64 arg1 ;
2378 void *arg2 = (void *) 0 ;
2379 size_t arg3 ;
2380 int argvi = 0;
2381 XferElement *result = 0 ;
2382 dXSARGS;
2383
2384 if ((items < 2) || (items > 2)) {
2385 SWIG_croak("Usage: xfer_source_pattern(length,pattern,pattern_length);");
2386 }
2387 {
2388 arg1 = amglue_SvU64(ST(0));
2389 }
2390 {
2391 size_t len;
2392 char * pat;
2393
2394 pat = SvPV(ST(1), len);
2395 arg2 = g_memdup(pat, len);
2396 arg3 = len;
2397 }
2398 result = (XferElement *)xfer_source_pattern(arg1,arg2,arg3);
2399 {
2400 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2401 argvi++;
2402 }
2403 {
2404 xfer_element_unref(result);
2405 }
2406 XSRETURN(argvi);
2407 fail:
2408 SWIG_croak_null();
2409 }
2410 }
2411
2412
XS(_wrap_xfer_source_fd)2413 XS(_wrap_xfer_source_fd) {
2414 {
2415 int arg1 ;
2416 int argvi = 0;
2417 XferElement *result = 0 ;
2418 dXSARGS;
2419
2420 if ((items < 1) || (items > 1)) {
2421 SWIG_croak("Usage: xfer_source_fd(fd);");
2422 }
2423 {
2424 IO *io = NULL;
2425 PerlIO *pio = NULL;
2426 int fd = -1;
2427
2428 if (SvIOK(ST(0))) {
2429 /* plain old integer */
2430 arg1 = SvIV(ST(0));
2431 } else {
2432 /* try extracting as filehandle */
2433
2434 /* note: sv_2io may call die() */
2435 io = sv_2io(ST(0));
2436 if (io) {
2437 pio = IoIFP(io);
2438 }
2439 if (pio) {
2440 fd = PerlIO_fileno(pio);
2441 }
2442 if (fd >= 0) {
2443 arg1 = fd;
2444 } else {
2445 SWIG_exception(SWIG_TypeError, "Expected integer file descriptor "
2446 "or file handle for argument 1");
2447 }
2448 }
2449 }
2450 result = (XferElement *)xfer_source_fd(arg1);
2451 {
2452 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2453 argvi++;
2454 }
2455
2456 {
2457 xfer_element_unref(result);
2458 }
2459 XSRETURN(argvi);
2460 fail:
2461
2462 SWIG_croak_null();
2463 }
2464 }
2465
2466
XS(_wrap_xfer_source_directtcp_listen)2467 XS(_wrap_xfer_source_directtcp_listen) {
2468 {
2469 int argvi = 0;
2470 XferElement *result = 0 ;
2471 dXSARGS;
2472
2473 if ((items < 0) || (items > 0)) {
2474 SWIG_croak("Usage: xfer_source_directtcp_listen();");
2475 }
2476 result = (XferElement *)xfer_source_directtcp_listen();
2477 {
2478 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2479 argvi++;
2480 }
2481 {
2482 xfer_element_unref(result);
2483 }
2484 XSRETURN(argvi);
2485 fail:
2486 SWIG_croak_null();
2487 }
2488 }
2489
2490
XS(_wrap_xfer_source_directtcp_listen_get_addrs)2491 XS(_wrap_xfer_source_directtcp_listen_get_addrs) {
2492 {
2493 XferElement *arg1 = (XferElement *) 0 ;
2494 int argvi = 0;
2495 DirectTCPAddr *result = 0 ;
2496 dXSARGS;
2497
2498 if ((items < 1) || (items > 1)) {
2499 SWIG_croak("Usage: xfer_source_directtcp_listen_get_addrs(elt);");
2500 }
2501 {
2502 arg1 = xfer_element_from_sv(ST(0));
2503 }
2504 result = (DirectTCPAddr *)xfer_source_directtcp_listen_get_addrs(arg1);
2505 {
2506 /* we assume this is an *array* of addresses, and return an arrayref or, if
2507 * the result is NULL, undef. */
2508 DirectTCPAddr *iter = result;
2509 AV *av;
2510 int i;
2511
2512 i = 0;
2513 av = newAV();
2514 while (iter && SU_GET_FAMILY(iter) != 0) {
2515 char *addr = str_sockaddr_no_port(iter);
2516 AV *tuple = newAV();
2517
2518 g_assert(NULL != av_store(tuple, 0, newSVpv(addr, 0)));
2519 g_assert(NULL != av_store(tuple, 1, newSViv(SU_GET_PORT(iter))));
2520 g_assert(NULL != av_store(av, i++, newRV_noinc((SV *)tuple)));
2521 iter++;
2522 }
2523
2524 ST(argvi) = newRV_noinc((SV *)av);
2525 argvi++;
2526 }
2527
2528 XSRETURN(argvi);
2529 fail:
2530
2531 SWIG_croak_null();
2532 }
2533 }
2534
2535
XS(_wrap_xfer_source_directtcp_connect)2536 XS(_wrap_xfer_source_directtcp_connect) {
2537 {
2538 DirectTCPAddr *arg1 = (DirectTCPAddr *) 0 ;
2539 int argvi = 0;
2540 XferElement *result = 0 ;
2541 dXSARGS;
2542
2543 if ((items < 1) || (items > 1)) {
2544 SWIG_croak("Usage: xfer_source_directtcp_connect(addrs);");
2545 }
2546 {
2547 AV *addrs_av;
2548 int num_addrs, i;
2549
2550 if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
2551 SWIG_exception_fail(SWIG_TypeError, "must provide an arrayref of DirectTCPAddrs");
2552 }
2553 addrs_av = (AV *)SvRV(ST(0));
2554 num_addrs = av_len(addrs_av)+1;
2555
2556 arg1 = g_new0(DirectTCPAddr, num_addrs+1);
2557
2558 for (i = 0; i < num_addrs; i++) {
2559 SV **svp = av_fetch(addrs_av, i, 0);
2560 AV *addr_av;
2561 sockaddr_union addr;
2562 IV port;
2563
2564 if (!svp || !SvROK(*svp) || SvTYPE(SvRV(*svp)) != SVt_PVAV
2565 || av_len((AV *)SvRV(*svp))+1 != 2) {
2566 SWIG_exception_fail(SWIG_TypeError, "each DirectTCPAddr must be a 2-element arrayref");
2567 }
2568
2569 addr_av = (AV *)SvRV(*svp);
2570
2571 /* get address */
2572 svp = av_fetch(addr_av, 0, 0);
2573 if (!svp || !SvPOK(*svp) || !str_to_sockaddr(SvPV_nolen(*svp), &addr)) {
2574 SWIG_exception_fail(SWIG_TypeError, "invalid IPv4 addr in address");
2575 }
2576
2577 /* get port */
2578 svp = av_fetch(addr_av, 1, 0);
2579 if (!svp || !SvIOK(*svp) || (port = SvIV(*svp)) <= 0 || port >= 65536) {
2580 SWIG_exception_fail(SWIG_TypeError, "invalid port in address");
2581 }
2582 SU_SET_PORT(&addr, port);
2583
2584 copy_sockaddr(arg1, &addr);
2585 }
2586 }
2587 result = (XferElement *)xfer_source_directtcp_connect(arg1);
2588 {
2589 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2590 argvi++;
2591 }
2592
2593 {
2594 xfer_element_unref(result);
2595 }
2596 XSRETURN(argvi);
2597 fail:
2598
2599 SWIG_croak_null();
2600 }
2601 }
2602
2603
XS(_wrap_xfer_filter_xor)2604 XS(_wrap_xfer_filter_xor) {
2605 {
2606 unsigned char arg1 ;
2607 unsigned char val1 ;
2608 int ecode1 = 0 ;
2609 int argvi = 0;
2610 XferElement *result = 0 ;
2611 dXSARGS;
2612
2613 if ((items < 1) || (items > 1)) {
2614 SWIG_croak("Usage: xfer_filter_xor(xor_key);");
2615 }
2616 ecode1 = SWIG_AsVal_unsigned_SS_char SWIG_PERL_CALL_ARGS_2(ST(0), &val1);
2617 if (!SWIG_IsOK(ecode1)) {
2618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "xfer_filter_xor" "', argument " "1"" of type '" "unsigned char""'");
2619 }
2620 arg1 = (unsigned char)(val1);
2621 result = (XferElement *)xfer_filter_xor(arg1);
2622 {
2623 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2624 argvi++;
2625 }
2626
2627 {
2628 xfer_element_unref(result);
2629 }
2630 XSRETURN(argvi);
2631 fail:
2632
2633 SWIG_croak_null();
2634 }
2635 }
2636
2637
XS(_wrap_xfer_filter_process)2638 XS(_wrap_xfer_filter_process) {
2639 {
2640 gchar **arg1 = (gchar **) 0 ;
2641 gboolean arg2 ;
2642 gboolean arg3 ;
2643 gboolean arg4 ;
2644 gboolean arg5 ;
2645 int argvi = 0;
2646 XferElement *result = 0 ;
2647 dXSARGS;
2648
2649 if ((items < 5) || (items > 5)) {
2650 SWIG_croak("Usage: xfer_filter_process(argv,need_root,must_drain,cancel_on_success,ignore_broken_pipe);");
2651 }
2652 {
2653 AV *av;
2654 unsigned int len;
2655 unsigned int i;
2656
2657 /* check that it's an arrayref */
2658 if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
2659 SWIG_exception(SWIG_TypeError, "Expected a non-empty arrayref");
2660 }
2661 av = (AV *)SvRV(ST(0));
2662
2663 /* allocate memory for arg1 */
2664 len = av_len(av)+1; /* av_len(av) is like $#av */
2665 if (!len) {
2666 SWIG_exception(SWIG_TypeError, "Expected a non-empty arrayref");
2667 }
2668 arg1 = g_new0(gchar *, len+1);
2669
2670 for (i = 0; i < len; i++) {
2671 SV **sv = av_fetch(av, i, 0);
2672 g_assert(sv != NULL);
2673 arg1[i] = g_strdup(SvPV_nolen(*sv));
2674 }
2675
2676 /* final element is already NULL due to g_new0; xfer_filter_process takes
2677 * care of freeing this array, so we don't have to */
2678 }
2679 {
2680 arg2 = SvTRUE(ST(1));
2681 }
2682 {
2683 arg3 = SvTRUE(ST(2));
2684 }
2685 {
2686 arg4 = SvTRUE(ST(3));
2687 }
2688 {
2689 arg5 = SvTRUE(ST(4));
2690 }
2691 result = (XferElement *)xfer_filter_process(arg1,arg2,arg3,arg4,arg5);
2692 {
2693 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2694 argvi++;
2695 }
2696
2697
2698
2699
2700
2701 {
2702 xfer_element_unref(result);
2703 }
2704 XSRETURN(argvi);
2705 fail:
2706
2707
2708
2709
2710
2711 SWIG_croak_null();
2712 }
2713 }
2714
2715
XS(_wrap_get_err_fd)2716 XS(_wrap_get_err_fd) {
2717 {
2718 XferElement *arg1 = (XferElement *) 0 ;
2719 int argvi = 0;
2720 int result;
2721 dXSARGS;
2722
2723 if ((items < 1) || (items > 1)) {
2724 SWIG_croak("Usage: get_err_fd(elt);");
2725 }
2726 {
2727 arg1 = xfer_element_from_sv(ST(0));
2728 }
2729 result = (int)get_err_fd(arg1);
2730 {
2731 SV *for_stack;
2732 SP += argvi; PUTBACK;
2733 for_stack = sv_2mortal(amglue_newSVi64(result));
2734 SPAGAIN; SP -= argvi;
2735 ST(argvi) = for_stack;
2736 argvi++;
2737 }
2738
2739 XSRETURN(argvi);
2740 fail:
2741
2742 SWIG_croak_null();
2743 }
2744 }
2745
2746
XS(_wrap_xfer_dest_null)2747 XS(_wrap_xfer_dest_null) {
2748 {
2749 guint32 arg1 ;
2750 int argvi = 0;
2751 XferElement *result = 0 ;
2752 dXSARGS;
2753
2754 if ((items < 1) || (items > 1)) {
2755 SWIG_croak("Usage: xfer_dest_null(prng_seed);");
2756 }
2757 {
2758 arg1 = amglue_SvU32(ST(0));
2759 }
2760 result = (XferElement *)xfer_dest_null(arg1);
2761 {
2762 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2763 argvi++;
2764 }
2765 {
2766 xfer_element_unref(result);
2767 }
2768 XSRETURN(argvi);
2769 fail:
2770 SWIG_croak_null();
2771 }
2772 }
2773
2774
XS(_wrap_xfer_dest_buffer)2775 XS(_wrap_xfer_dest_buffer) {
2776 {
2777 gsize arg1 ;
2778 int argvi = 0;
2779 XferElement *result = 0 ;
2780 dXSARGS;
2781
2782 if ((items < 1) || (items > 1)) {
2783 SWIG_croak("Usage: xfer_dest_buffer(max_size);");
2784 }
2785 {
2786 if (sizeof(gsize) == 1) {
2787 arg1 = amglue_SvU8(ST(0));
2788 } else if (sizeof(gsize) == 2) {
2789 arg1 = amglue_SvU16(ST(0));
2790 } else if (sizeof(gsize) == 4) {
2791 arg1 = amglue_SvU32(ST(0));
2792 } else if (sizeof(gsize) == 8) {
2793 arg1 = amglue_SvU64(ST(0));
2794 } else {
2795 croak("Unexpected gsize >64 bits?"); /* should be optimized out unless sizeof(gsize) > 8 */
2796 }
2797 }
2798 result = (XferElement *)xfer_dest_buffer(arg1);
2799 {
2800 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2801 argvi++;
2802 }
2803 {
2804 xfer_element_unref(result);
2805 }
2806 XSRETURN(argvi);
2807 fail:
2808 SWIG_croak_null();
2809 }
2810 }
2811
2812
XS(_wrap_xfer_dest_buffer_get)2813 XS(_wrap_xfer_dest_buffer_get) {
2814 {
2815 XferElement *arg1 = (XferElement *) 0 ;
2816 gpointer *arg2 = (gpointer *) 0 ;
2817 gsize *arg3 = (gsize *) 0 ;
2818 gpointer temp2 = 0 ;
2819 gsize tempn2 ;
2820 int argvi = 0;
2821 dXSARGS;
2822
2823 arg2 = &temp2; arg3 = &tempn2;
2824 if ((items < 1) || (items > 1)) {
2825 SWIG_croak("Usage: xfer_dest_buffer_get(elt,size);");
2826 }
2827 {
2828 arg1 = xfer_element_from_sv(ST(0));
2829 }
2830 xfer_dest_buffer_get(arg1,arg2,arg3);
2831 ST(argvi) = sv_newmortal();
2832 if (*arg2) {
2833 if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_FromCharPtrAndSize(*arg2,*arg3); argvi++ ;
2834 ;
2835 }
2836
2837
2838 XSRETURN(argvi);
2839 fail:
2840
2841
2842 SWIG_croak_null();
2843 }
2844 }
2845
2846
XS(_wrap_xfer_dest_fd)2847 XS(_wrap_xfer_dest_fd) {
2848 {
2849 int arg1 ;
2850 int argvi = 0;
2851 XferElement *result = 0 ;
2852 dXSARGS;
2853
2854 if ((items < 1) || (items > 1)) {
2855 SWIG_croak("Usage: xfer_dest_fd(fd);");
2856 }
2857 {
2858 IO *io = NULL;
2859 PerlIO *pio = NULL;
2860 int fd = -1;
2861
2862 if (SvIOK(ST(0))) {
2863 /* plain old integer */
2864 arg1 = SvIV(ST(0));
2865 } else {
2866 /* try extracting as filehandle */
2867
2868 /* note: sv_2io may call die() */
2869 io = sv_2io(ST(0));
2870 if (io) {
2871 pio = IoIFP(io);
2872 }
2873 if (pio) {
2874 fd = PerlIO_fileno(pio);
2875 }
2876 if (fd >= 0) {
2877 arg1 = fd;
2878 } else {
2879 SWIG_exception(SWIG_TypeError, "Expected integer file descriptor "
2880 "or file handle for argument 1");
2881 }
2882 }
2883 }
2884 result = (XferElement *)xfer_dest_fd(arg1);
2885 {
2886 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2887 argvi++;
2888 }
2889
2890 {
2891 xfer_element_unref(result);
2892 }
2893 XSRETURN(argvi);
2894 fail:
2895
2896 SWIG_croak_null();
2897 }
2898 }
2899
2900
XS(_wrap_xfer_dest_directtcp_listen)2901 XS(_wrap_xfer_dest_directtcp_listen) {
2902 {
2903 int argvi = 0;
2904 XferElement *result = 0 ;
2905 dXSARGS;
2906
2907 if ((items < 0) || (items > 0)) {
2908 SWIG_croak("Usage: xfer_dest_directtcp_listen();");
2909 }
2910 result = (XferElement *)xfer_dest_directtcp_listen();
2911 {
2912 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
2913 argvi++;
2914 }
2915 {
2916 xfer_element_unref(result);
2917 }
2918 XSRETURN(argvi);
2919 fail:
2920 SWIG_croak_null();
2921 }
2922 }
2923
2924
XS(_wrap_xfer_dest_directtcp_listen_get_addrs)2925 XS(_wrap_xfer_dest_directtcp_listen_get_addrs) {
2926 {
2927 XferElement *arg1 = (XferElement *) 0 ;
2928 int argvi = 0;
2929 DirectTCPAddr *result = 0 ;
2930 dXSARGS;
2931
2932 if ((items < 1) || (items > 1)) {
2933 SWIG_croak("Usage: xfer_dest_directtcp_listen_get_addrs(elt);");
2934 }
2935 {
2936 arg1 = xfer_element_from_sv(ST(0));
2937 }
2938 result = (DirectTCPAddr *)xfer_dest_directtcp_listen_get_addrs(arg1);
2939 {
2940 /* we assume this is an *array* of addresses, and return an arrayref or, if
2941 * the result is NULL, undef. */
2942 DirectTCPAddr *iter = result;
2943 AV *av;
2944 int i;
2945
2946 i = 0;
2947 av = newAV();
2948 while (iter && SU_GET_FAMILY(iter) != 0) {
2949 char *addr = str_sockaddr_no_port(iter);
2950 AV *tuple = newAV();
2951
2952 g_assert(NULL != av_store(tuple, 0, newSVpv(addr, 0)));
2953 g_assert(NULL != av_store(tuple, 1, newSViv(SU_GET_PORT(iter))));
2954 g_assert(NULL != av_store(av, i++, newRV_noinc((SV *)tuple)));
2955 iter++;
2956 }
2957
2958 ST(argvi) = newRV_noinc((SV *)av);
2959 argvi++;
2960 }
2961
2962 XSRETURN(argvi);
2963 fail:
2964
2965 SWIG_croak_null();
2966 }
2967 }
2968
2969
XS(_wrap_xfer_dest_directtcp_connect)2970 XS(_wrap_xfer_dest_directtcp_connect) {
2971 {
2972 DirectTCPAddr *arg1 = (DirectTCPAddr *) 0 ;
2973 int argvi = 0;
2974 XferElement *result = 0 ;
2975 dXSARGS;
2976
2977 if ((items < 1) || (items > 1)) {
2978 SWIG_croak("Usage: xfer_dest_directtcp_connect(addrs);");
2979 }
2980 {
2981 AV *addrs_av;
2982 int num_addrs, i;
2983
2984 if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
2985 SWIG_exception_fail(SWIG_TypeError, "must provide an arrayref of DirectTCPAddrs");
2986 }
2987 addrs_av = (AV *)SvRV(ST(0));
2988 num_addrs = av_len(addrs_av)+1;
2989
2990 arg1 = g_new0(DirectTCPAddr, num_addrs+1);
2991
2992 for (i = 0; i < num_addrs; i++) {
2993 SV **svp = av_fetch(addrs_av, i, 0);
2994 AV *addr_av;
2995 sockaddr_union addr;
2996 IV port;
2997
2998 if (!svp || !SvROK(*svp) || SvTYPE(SvRV(*svp)) != SVt_PVAV
2999 || av_len((AV *)SvRV(*svp))+1 != 2) {
3000 SWIG_exception_fail(SWIG_TypeError, "each DirectTCPAddr must be a 2-element arrayref");
3001 }
3002
3003 addr_av = (AV *)SvRV(*svp);
3004
3005 /* get address */
3006 svp = av_fetch(addr_av, 0, 0);
3007 if (!svp || !SvPOK(*svp) || !str_to_sockaddr(SvPV_nolen(*svp), &addr)) {
3008 SWIG_exception_fail(SWIG_TypeError, "invalid IPv4 addr in address");
3009 }
3010
3011 /* get port */
3012 svp = av_fetch(addr_av, 1, 0);
3013 if (!svp || !SvIOK(*svp) || (port = SvIV(*svp)) <= 0 || port >= 65536) {
3014 SWIG_exception_fail(SWIG_TypeError, "invalid port in address");
3015 }
3016 SU_SET_PORT(&addr, port);
3017
3018 copy_sockaddr(arg1, &addr);
3019 }
3020 }
3021 result = (XferElement *)xfer_dest_directtcp_connect(arg1);
3022 {
3023 ST(argvi) = sv_2mortal(new_sv_for_xfer_element(result));
3024 argvi++;
3025 }
3026
3027 {
3028 xfer_element_unref(result);
3029 }
3030 XSRETURN(argvi);
3031 fail:
3032
3033 SWIG_croak_null();
3034 }
3035 }
3036
3037
XS(_wrap_xfer_get_amglue_source)3038 XS(_wrap_xfer_get_amglue_source) {
3039 {
3040 Xfer *arg1 = (Xfer *) 0 ;
3041 int argvi = 0;
3042 amglue_Source *result = 0 ;
3043 dXSARGS;
3044
3045 if ((items < 1) || (items > 1)) {
3046 SWIG_croak("Usage: xfer_get_amglue_source(xfer);");
3047 }
3048 {
3049 arg1 = xfer_from_sv(ST(0));
3050 }
3051 result = (amglue_Source *)xfer_get_amglue_source(arg1);
3052 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_amglue_Source, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3053
3054 XSRETURN(argvi);
3055 fail:
3056
3057 SWIG_croak_null();
3058 }
3059 }
3060
3061
3062
3063 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3064
3065 static swig_type_info _swigt__p_DirectTCPAddr = {"_p_DirectTCPAddr", "DirectTCPAddr *", 0, 0, (void*)0, 0};
3066 static swig_type_info _swigt__p_Xfer = {"_p_Xfer", "Xfer *", 0, 0, (void*)0, 0};
3067 static swig_type_info _swigt__p_XferElement = {"_p_XferElement", "XferElement *", 0, 0, (void*)0, 0};
3068 static swig_type_info _swigt__p_amglue_Source = {"_p_amglue_Source", "amglue_Source *", 0, 0, (void*)"Amanda::MainLoop::Source", 0};
3069 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
3070 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
3071 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
3072 static swig_type_info _swigt__p_gint64 = {"_p_gint64", "gint64 *", 0, 0, (void*)0, 0};
3073 static swig_type_info _swigt__p_gsize = {"_p_gsize", "gsize *", 0, 0, (void*)0, 0};
3074 static swig_type_info _swigt__p_guint32 = {"_p_guint32", "guint32 *", 0, 0, (void*)0, 0};
3075 static swig_type_info _swigt__p_guint64 = {"_p_guint64", "guint64 *", 0, 0, (void*)0, 0};
3076 static swig_type_info _swigt__p_int = {"_p_int", "xmsg_type *|int *|GIOCondition *|xfer_status *|gboolean *", 0, 0, (void*)0, 0};
3077 static swig_type_info _swigt__p_p_XferElement = {"_p_p_XferElement", "XferElement **", 0, 0, (void*)0, 0};
3078 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **|gchar **", 0, 0, (void*)0, 0};
3079 static swig_type_info _swigt__p_p_void = {"_p_p_void", "gpointer *|void **", 0, 0, (void*)0, 0};
3080 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
3081
3082 static swig_type_info *swig_type_initial[] = {
3083 &_swigt__p_DirectTCPAddr,
3084 &_swigt__p_Xfer,
3085 &_swigt__p_XferElement,
3086 &_swigt__p_amglue_Source,
3087 &_swigt__p_char,
3088 &_swigt__p_double,
3089 &_swigt__p_float,
3090 &_swigt__p_gint64,
3091 &_swigt__p_gsize,
3092 &_swigt__p_guint32,
3093 &_swigt__p_guint64,
3094 &_swigt__p_int,
3095 &_swigt__p_p_XferElement,
3096 &_swigt__p_p_char,
3097 &_swigt__p_p_void,
3098 &_swigt__p_unsigned_char,
3099 };
3100
3101 static swig_cast_info _swigc__p_DirectTCPAddr[] = { {&_swigt__p_DirectTCPAddr, 0, 0, 0},{0, 0, 0, 0}};
3102 static swig_cast_info _swigc__p_Xfer[] = { {&_swigt__p_Xfer, 0, 0, 0},{0, 0, 0, 0}};
3103 static swig_cast_info _swigc__p_XferElement[] = { {&_swigt__p_XferElement, 0, 0, 0},{0, 0, 0, 0}};
3104 static swig_cast_info _swigc__p_amglue_Source[] = { {&_swigt__p_amglue_Source, 0, 0, 0},{0, 0, 0, 0}};
3105 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3106 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
3107 static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
3108 static swig_cast_info _swigc__p_gint64[] = { {&_swigt__p_gint64, 0, 0, 0},{0, 0, 0, 0}};
3109 static swig_cast_info _swigc__p_gsize[] = { {&_swigt__p_gsize, 0, 0, 0},{0, 0, 0, 0}};
3110 static swig_cast_info _swigc__p_guint32[] = { {&_swigt__p_guint32, 0, 0, 0},{0, 0, 0, 0}};
3111 static swig_cast_info _swigc__p_guint64[] = { {&_swigt__p_guint64, 0, 0, 0},{0, 0, 0, 0}};
3112 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
3113 static swig_cast_info _swigc__p_p_XferElement[] = { {&_swigt__p_p_XferElement, 0, 0, 0},{0, 0, 0, 0}};
3114 static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
3115 static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
3116 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
3117
3118 static swig_cast_info *swig_cast_initial[] = {
3119 _swigc__p_DirectTCPAddr,
3120 _swigc__p_Xfer,
3121 _swigc__p_XferElement,
3122 _swigc__p_amglue_Source,
3123 _swigc__p_char,
3124 _swigc__p_double,
3125 _swigc__p_float,
3126 _swigc__p_gint64,
3127 _swigc__p_gsize,
3128 _swigc__p_guint32,
3129 _swigc__p_guint64,
3130 _swigc__p_int,
3131 _swigc__p_p_XferElement,
3132 _swigc__p_p_char,
3133 _swigc__p_p_void,
3134 _swigc__p_unsigned_char,
3135 };
3136
3137
3138 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3139
3140 static swig_constant_info swig_constants[] = {
3141 {0,0,0,0,0,0}
3142 };
3143 #ifdef __cplusplus
3144 }
3145 #endif
3146 static swig_variable_info swig_variables[] = {
3147 {0,0,0,0}
3148 };
3149 static swig_command_info swig_commands[] = {
3150 {"Amanda::Xferc::xfer_new", _wrap_xfer_new},
3151 {"Amanda::Xferc::xfer_unref", _wrap_xfer_unref},
3152 {"Amanda::Xferc::xfer_get_status", _wrap_xfer_get_status},
3153 {"Amanda::Xferc::xfer_repr", _wrap_xfer_repr},
3154 {"Amanda::Xferc::xfer_start", _wrap_xfer_start},
3155 {"Amanda::Xferc::xfer_cancel", _wrap_xfer_cancel},
3156 {"Amanda::Xferc::xfer_element_unref", _wrap_xfer_element_unref},
3157 {"Amanda::Xferc::xfer_element_repr", _wrap_xfer_element_repr},
3158 {"Amanda::Xferc::same_elements", _wrap_same_elements},
3159 {"Amanda::Xferc::xfer_source_random", _wrap_xfer_source_random},
3160 {"Amanda::Xferc::xfer_source_random_get_seed", _wrap_xfer_source_random_get_seed},
3161 {"Amanda::Xferc::xfer_source_pattern", _wrap_xfer_source_pattern},
3162 {"Amanda::Xferc::xfer_source_fd", _wrap_xfer_source_fd},
3163 {"Amanda::Xferc::xfer_source_directtcp_listen", _wrap_xfer_source_directtcp_listen},
3164 {"Amanda::Xferc::xfer_source_directtcp_listen_get_addrs", _wrap_xfer_source_directtcp_listen_get_addrs},
3165 {"Amanda::Xferc::xfer_source_directtcp_connect", _wrap_xfer_source_directtcp_connect},
3166 {"Amanda::Xferc::xfer_filter_xor", _wrap_xfer_filter_xor},
3167 {"Amanda::Xferc::xfer_filter_process", _wrap_xfer_filter_process},
3168 {"Amanda::Xferc::get_err_fd", _wrap_get_err_fd},
3169 {"Amanda::Xferc::xfer_dest_null", _wrap_xfer_dest_null},
3170 {"Amanda::Xferc::xfer_dest_buffer", _wrap_xfer_dest_buffer},
3171 {"Amanda::Xferc::xfer_dest_buffer_get", _wrap_xfer_dest_buffer_get},
3172 {"Amanda::Xferc::xfer_dest_fd", _wrap_xfer_dest_fd},
3173 {"Amanda::Xferc::xfer_dest_directtcp_listen", _wrap_xfer_dest_directtcp_listen},
3174 {"Amanda::Xferc::xfer_dest_directtcp_listen_get_addrs", _wrap_xfer_dest_directtcp_listen_get_addrs},
3175 {"Amanda::Xferc::xfer_dest_directtcp_connect", _wrap_xfer_dest_directtcp_connect},
3176 {"Amanda::Xferc::xfer_get_amglue_source", _wrap_xfer_get_amglue_source},
3177 {0,0}
3178 };
3179 /* -----------------------------------------------------------------------------
3180 * Type initialization:
3181 * This problem is tough by the requirement that no dynamic
3182 * memory is used. Also, since swig_type_info structures store pointers to
3183 * swig_cast_info structures and swig_cast_info structures store pointers back
3184 * to swig_type_info structures, we need some lookup code at initialization.
3185 * The idea is that swig generates all the structures that are needed.
3186 * The runtime then collects these partially filled structures.
3187 * The SWIG_InitializeModule function takes these initial arrays out of
3188 * swig_module, and does all the lookup, filling in the swig_module.types
3189 * array with the correct data and linking the correct swig_cast_info
3190 * structures together.
3191 *
3192 * The generated swig_type_info structures are assigned statically to an initial
3193 * array. We just loop through that array, and handle each type individually.
3194 * First we lookup if this type has been already loaded, and if so, use the
3195 * loaded structure instead of the generated one. Then we have to fill in the
3196 * cast linked list. The cast data is initially stored in something like a
3197 * two-dimensional array. Each row corresponds to a type (there are the same
3198 * number of rows as there are in the swig_type_initial array). Each entry in
3199 * a column is one of the swig_cast_info structures for that type.
3200 * The cast_initial array is actually an array of arrays, because each row has
3201 * a variable number of columns. So to actually build the cast linked list,
3202 * we find the array of casts associated with the type, and loop through it
3203 * adding the casts to the list. The one last trick we need to do is making
3204 * sure the type pointer in the swig_cast_info struct is correct.
3205 *
3206 * First off, we lookup the cast->type name to see if it is already loaded.
3207 * There are three cases to handle:
3208 * 1) If the cast->type has already been loaded AND the type we are adding
3209 * casting info to has not been loaded (it is in this module), THEN we
3210 * replace the cast->type pointer with the type pointer that has already
3211 * been loaded.
3212 * 2) If BOTH types (the one we are adding casting info to, and the
3213 * cast->type) are loaded, THEN the cast info has already been loaded by
3214 * the previous module so we just ignore it.
3215 * 3) Finally, if cast->type has not already been loaded, then we add that
3216 * swig_cast_info to the linked list (because the cast->type) pointer will
3217 * be correct.
3218 * ----------------------------------------------------------------------------- */
3219
3220 #ifdef __cplusplus
3221 extern "C" {
3222 #if 0
3223 } /* c-mode */
3224 #endif
3225 #endif
3226
3227 #if 0
3228 #define SWIGRUNTIME_DEBUG
3229 #endif
3230
3231
3232 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)3233 SWIG_InitializeModule(void *clientdata) {
3234 size_t i;
3235 swig_module_info *module_head, *iter;
3236 int init;
3237
3238 /* check to see if the circular list has been setup, if not, set it up */
3239 if (swig_module.next==0) {
3240 /* Initialize the swig_module */
3241 swig_module.type_initial = swig_type_initial;
3242 swig_module.cast_initial = swig_cast_initial;
3243 swig_module.next = &swig_module;
3244 init = 1;
3245 } else {
3246 init = 0;
3247 }
3248
3249 /* Try and load any already created modules */
3250 module_head = SWIG_GetModule(clientdata);
3251 if (!module_head) {
3252 /* This is the first module loaded for this interpreter */
3253 /* so set the swig module into the interpreter */
3254 SWIG_SetModule(clientdata, &swig_module);
3255 } else {
3256 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
3257 iter=module_head;
3258 do {
3259 if (iter==&swig_module) {
3260 /* Our module is already in the list, so there's nothing more to do. */
3261 return;
3262 }
3263 iter=iter->next;
3264 } while (iter!= module_head);
3265
3266 /* otherwise we must add our module into the list */
3267 swig_module.next = module_head->next;
3268 module_head->next = &swig_module;
3269 }
3270
3271 /* When multiple interpreters are used, a module could have already been initialized in
3272 a different interpreter, but not yet have a pointer in this interpreter.
3273 In this case, we do not want to continue adding types... everything should be
3274 set up already */
3275 if (init == 0) return;
3276
3277 /* Now work on filling in swig_module.types */
3278 #ifdef SWIGRUNTIME_DEBUG
3279 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
3280 #endif
3281 for (i = 0; i < swig_module.size; ++i) {
3282 swig_type_info *type = 0;
3283 swig_type_info *ret;
3284 swig_cast_info *cast;
3285
3286 #ifdef SWIGRUNTIME_DEBUG
3287 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3288 #endif
3289
3290 /* if there is another module already loaded */
3291 if (swig_module.next != &swig_module) {
3292 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3293 }
3294 if (type) {
3295 /* Overwrite clientdata field */
3296 #ifdef SWIGRUNTIME_DEBUG
3297 printf("SWIG_InitializeModule: found type %s\n", type->name);
3298 #endif
3299 if (swig_module.type_initial[i]->clientdata) {
3300 type->clientdata = swig_module.type_initial[i]->clientdata;
3301 #ifdef SWIGRUNTIME_DEBUG
3302 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3303 #endif
3304 }
3305 } else {
3306 type = swig_module.type_initial[i];
3307 }
3308
3309 /* Insert casting types */
3310 cast = swig_module.cast_initial[i];
3311 while (cast->type) {
3312 /* Don't need to add information already in the list */
3313 ret = 0;
3314 #ifdef SWIGRUNTIME_DEBUG
3315 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3316 #endif
3317 if (swig_module.next != &swig_module) {
3318 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3319 #ifdef SWIGRUNTIME_DEBUG
3320 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3321 #endif
3322 }
3323 if (ret) {
3324 if (type == swig_module.type_initial[i]) {
3325 #ifdef SWIGRUNTIME_DEBUG
3326 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3327 #endif
3328 cast->type = ret;
3329 ret = 0;
3330 } else {
3331 /* Check for casting already in the list */
3332 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3333 #ifdef SWIGRUNTIME_DEBUG
3334 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3335 #endif
3336 if (!ocast) ret = 0;
3337 }
3338 }
3339
3340 if (!ret) {
3341 #ifdef SWIGRUNTIME_DEBUG
3342 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3343 #endif
3344 if (type->cast) {
3345 type->cast->prev = cast;
3346 cast->next = type->cast;
3347 }
3348 type->cast = cast;
3349 }
3350 cast++;
3351 }
3352 /* Set entry in modules->types array equal to the type */
3353 swig_module.types[i] = type;
3354 }
3355 swig_module.types[i] = 0;
3356
3357 #ifdef SWIGRUNTIME_DEBUG
3358 printf("**** SWIG_InitializeModule: Cast List ******\n");
3359 for (i = 0; i < swig_module.size; ++i) {
3360 int j = 0;
3361 swig_cast_info *cast = swig_module.cast_initial[i];
3362 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3363 while (cast->type) {
3364 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3365 cast++;
3366 ++j;
3367 }
3368 printf("---- Total casts: %d\n",j);
3369 }
3370 printf("**** SWIG_InitializeModule: Cast List ******\n");
3371 #endif
3372 }
3373
3374 /* This function will propagate the clientdata field of type to
3375 * any new swig_type_info structures that have been added into the list
3376 * of equivalent types. It is like calling
3377 * SWIG_TypeClientData(type, clientdata) a second time.
3378 */
3379 SWIGRUNTIME void
SWIG_PropagateClientData(void)3380 SWIG_PropagateClientData(void) {
3381 size_t i;
3382 swig_cast_info *equiv;
3383 static int init_run = 0;
3384
3385 if (init_run) return;
3386 init_run = 1;
3387
3388 for (i = 0; i < swig_module.size; i++) {
3389 if (swig_module.types[i]->clientdata) {
3390 equiv = swig_module.types[i]->cast;
3391 while (equiv) {
3392 if (!equiv->converter) {
3393 if (equiv->type && !equiv->type->clientdata)
3394 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
3395 }
3396 equiv = equiv->next;
3397 }
3398 }
3399 }
3400 }
3401
3402 #ifdef __cplusplus
3403 #if 0
3404 {
3405 /* c-mode */
3406 #endif
3407 }
3408 #endif
3409
3410
3411
3412 #if defined(__cplusplus) && ! defined(XSPROTO)
3413 extern "C"
3414 #endif
3415
XS(SWIG_init)3416 XS(SWIG_init) {
3417 dXSARGS;
3418 int i;
3419
3420 SWIG_InitializeModule(0);
3421
3422 /* Install commands */
3423 for (i = 0; swig_commands[i].name; i++) {
3424 /* Casts only needed for Perl < 5.10. */
3425 #ifdef __cplusplus
3426 newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
3427 #else
3428 newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
3429 #endif
3430 }
3431
3432 /* Install variables */
3433 for (i = 0; swig_variables[i].name; i++) {
3434 SV *sv;
3435 sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
3436 if (swig_variables[i].type) {
3437 SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
3438 } else {
3439 sv_setiv(sv,(IV) 0);
3440 }
3441 swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
3442 }
3443
3444 /* Install constant */
3445 for (i = 0; swig_constants[i].type; i++) {
3446 SV *sv;
3447 sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
3448 switch(swig_constants[i].type) {
3449 case SWIG_INT:
3450 sv_setiv(sv, (IV) swig_constants[i].lvalue);
3451 break;
3452 case SWIG_FLOAT:
3453 sv_setnv(sv, (double) swig_constants[i].dvalue);
3454 break;
3455 case SWIG_STRING:
3456 sv_setpv(sv, (const char *) swig_constants[i].pvalue);
3457 break;
3458 case SWIG_POINTER:
3459 SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
3460 break;
3461 case SWIG_BINARY:
3462 SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
3463 break;
3464 default:
3465 break;
3466 }
3467 SvREADONLY_on(sv);
3468 }
3469
3470
3471 /* We need GType and GThread initialized to use xfers */
3472 glib_init();
3473
3474 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3475 SV *sv = get_sv((char*) SWIG_prefix "XFER_INIT", TRUE | 0x2 | GV_ADDMULTI);
3476 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(XFER_INIT)));
3477 SvREADONLY_on(sv);
3478 } while(0) /*@SWIG@*/;
3479 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3480 SV *sv = get_sv((char*) SWIG_prefix "XFER_START", TRUE | 0x2 | GV_ADDMULTI);
3481 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(XFER_START)));
3482 SvREADONLY_on(sv);
3483 } while(0) /*@SWIG@*/;
3484 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3485 SV *sv = get_sv((char*) SWIG_prefix "XFER_RUNNING", TRUE | 0x2 | GV_ADDMULTI);
3486 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(XFER_RUNNING)));
3487 SvREADONLY_on(sv);
3488 } while(0) /*@SWIG@*/;
3489 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3490 SV *sv = get_sv((char*) SWIG_prefix "XFER_DONE", TRUE | 0x2 | GV_ADDMULTI);
3491 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(XFER_DONE)));
3492 SvREADONLY_on(sv);
3493 } while(0) /*@SWIG@*/;
3494 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3495 SV *sv = get_sv((char*) SWIG_prefix "XMSG_INFO", TRUE | 0x2 | GV_ADDMULTI);
3496 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(XMSG_INFO)));
3497 SvREADONLY_on(sv);
3498 } while(0) /*@SWIG@*/;
3499 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3500 SV *sv = get_sv((char*) SWIG_prefix "XMSG_ERROR", TRUE | 0x2 | GV_ADDMULTI);
3501 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(XMSG_ERROR)));
3502 SvREADONLY_on(sv);
3503 } while(0) /*@SWIG@*/;
3504 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3505 SV *sv = get_sv((char*) SWIG_prefix "XMSG_DONE", TRUE | 0x2 | GV_ADDMULTI);
3506 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(XMSG_DONE)));
3507 SvREADONLY_on(sv);
3508 } while(0) /*@SWIG@*/;
3509 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3510 SV *sv = get_sv((char*) SWIG_prefix "XMSG_CANCEL", TRUE | 0x2 | GV_ADDMULTI);
3511 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(XMSG_CANCEL)));
3512 SvREADONLY_on(sv);
3513 } while(0) /*@SWIG@*/;
3514 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3515 SV *sv = get_sv((char*) SWIG_prefix "XMSG_PART_DONE", TRUE | 0x2 | GV_ADDMULTI);
3516 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(XMSG_PART_DONE)));
3517 SvREADONLY_on(sv);
3518 } while(0) /*@SWIG@*/;
3519 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
3520 SV *sv = get_sv((char*) SWIG_prefix "XMSG_READY", TRUE | 0x2 | GV_ADDMULTI);
3521 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(XMSG_READY)));
3522 SvREADONLY_on(sv);
3523 } while(0) /*@SWIG@*/;
3524 ST(0) = &PL_sv_yes;
3525 XSRETURN(1);
3526 }
3527
3528