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_GSList swig_types[0]
1510 #define SWIGTYPE_p_a_STRMAX__char swig_types[1]
1511 #define SWIGTYPE_p_a_dle_s swig_types[2]
1512 #define SWIGTYPE_p_am_sl_t swig_types[3]
1513 #define SWIGTYPE_p_char swig_types[4]
1514 #define SWIGTYPE_p_data_path_t swig_types[5]
1515 #define SWIGTYPE_p_dle_t swig_types[6]
1516 #define SWIGTYPE_p_double swig_types[7]
1517 #define SWIGTYPE_p_dumpfile_t swig_types[8]
1518 #define SWIGTYPE_p_estimatelist_t swig_types[9]
1519 #define SWIGTYPE_p_float swig_types[10]
1520 #define SWIGTYPE_p_int swig_types[11]
1521 #define SWIGTYPE_p_levellist_t swig_types[12]
1522 #define SWIGTYPE_p_off_t swig_types[13]
1523 #define SWIGTYPE_p_proplist_t swig_types[14]
1524 #define SWIGTYPE_p_scriptlist_t swig_types[15]
1525 #define SWIGTYPE_p_unsigned_char swig_types[16]
1526 static swig_type_info *swig_types[18];
1527 static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0};
1528 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1529 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1530
1531 /* -------- TYPES TABLE (END) -------- */
1532
1533 #define SWIG_init boot_Amanda__Header
1534
1535 #define SWIG_name "Amanda::Headerc::boot_Amanda__Header"
1536 #define SWIG_prefix "Amanda::Headerc::"
1537
1538 #define SWIGVERSION 0x030007
1539 #define SWIG_VERSION SWIGVERSION
1540
1541
1542 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1543 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1544
1545
1546 #ifdef __cplusplus
1547 extern "C"
1548 #endif
1549 #ifndef PERL_OBJECT
1550 #ifndef MULTIPLICITY
1551 SWIGEXPORT void SWIG_init (CV* cv);
1552 #else
1553 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1554 #endif
1555 #else
1556 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1557 #endif
1558
1559
1560 #include "amglue.h"
1561
1562
1563 #include "amglue.h"
1564
1565
1566 #include "amglue.h"
1567
1568
1569 #include "fileheader.h"
1570
1571
1572 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(long value)1573 SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value)
1574 {
1575 SV *sv;
1576 if (value >= IV_MIN && value <= IV_MAX)
1577 sv = newSViv(value);
1578 else
1579 sv = newSVpvf("%ld", value);
1580 return sv_2mortal(sv);
1581 }
1582
1583
1584 SWIGINTERNINLINE SV *
SWIG_PERL_DECL_ARGS_1(int value)1585 SWIG_From_int SWIG_PERL_DECL_ARGS_1(int value)
1586 {
1587 return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
1588 }
1589
1590
1591 #include <limits.h>
1592 #if !defined(SWIG_NO_LLONG_MAX)
1593 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1594 # define LLONG_MAX __LONG_LONG_MAX__
1595 # define LLONG_MIN (-LLONG_MAX - 1LL)
1596 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1597 # endif
1598 #endif
1599
1600
1601 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,double * val)1602 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1603 {
1604 if (SvNIOK(obj)) {
1605 if (val) *val = SvNV(obj);
1606 return SWIG_OK;
1607 } else if (SvIOK(obj)) {
1608 if (val) *val = (double) SvIV(obj);
1609 return SWIG_AddCast(SWIG_OK);
1610 } else {
1611 const char *nptr = SvPV_nolen(obj);
1612 if (nptr) {
1613 char *endptr;
1614 double v;
1615 errno = 0;
1616 v = strtod(nptr, &endptr);
1617 if (errno == ERANGE) {
1618 errno = 0;
1619 return SWIG_OverflowError;
1620 } else {
1621 if (*endptr == '\0') {
1622 if (val) *val = v;
1623 return SWIG_Str2NumCast(SWIG_OK);
1624 }
1625 }
1626 }
1627 }
1628 return SWIG_TypeError;
1629 }
1630
1631
1632 #include <float.h>
1633
1634
1635 #include <math.h>
1636
1637
1638 SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double * d,double min,double max)1639 SWIG_CanCastAsInteger(double *d, double min, double max) {
1640 double x = *d;
1641 if ((min <= x && x <= max)) {
1642 double fx = floor(x);
1643 double cx = ceil(x);
1644 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1645 if ((errno == EDOM) || (errno == ERANGE)) {
1646 errno = 0;
1647 } else {
1648 double summ, reps, diff;
1649 if (rd < x) {
1650 diff = x - rd;
1651 } else if (rd > x) {
1652 diff = rd - x;
1653 } else {
1654 return 1;
1655 }
1656 summ = rd + x;
1657 reps = diff/summ;
1658 if (reps < 8*DBL_EPSILON) {
1659 *d = rd;
1660 return 1;
1661 }
1662 }
1663 }
1664 return 0;
1665 }
1666
1667
1668 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,long * val)1669 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1670 {
1671 if (SvUOK(obj)) {
1672 UV v = SvUV(obj);
1673 if (v <= LONG_MAX) {
1674 if (val) *val = v;
1675 return SWIG_OK;
1676 }
1677 return SWIG_OverflowError;
1678 } else if (SvIOK(obj)) {
1679 IV v = SvIV(obj);
1680 if (v >= LONG_MIN && v <= LONG_MAX) {
1681 if(val) *val = v;
1682 return SWIG_OK;
1683 }
1684 return SWIG_OverflowError;
1685 } else {
1686 int dispatch = 0;
1687 const char *nptr = SvPV_nolen(obj);
1688 if (nptr) {
1689 char *endptr;
1690 long v;
1691 errno = 0;
1692 v = strtol(nptr, &endptr,0);
1693 if (errno == ERANGE) {
1694 errno = 0;
1695 return SWIG_OverflowError;
1696 } else {
1697 if (*endptr == '\0') {
1698 if (val) *val = v;
1699 return SWIG_Str2NumCast(SWIG_OK);
1700 }
1701 }
1702 }
1703 if (!dispatch) {
1704 double d;
1705 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1706 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1707 if (val) *val = (long)(d);
1708 return res;
1709 }
1710 }
1711 }
1712 return SWIG_TypeError;
1713 }
1714
1715
1716 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,int * val)1717 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1718 {
1719 long v;
1720 int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1721 if (SWIG_IsOK(res)) {
1722 if ((v < INT_MIN || v > INT_MAX)) {
1723 return SWIG_OverflowError;
1724 } else {
1725 if (val) *val = (int)(v);
1726 }
1727 }
1728 return res;
1729 }
1730
1731
1732 SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)1733 SWIG_pchar_descriptor(void)
1734 {
1735 static int init = 0;
1736 static swig_type_info* info = 0;
1737 if (!init) {
1738 info = SWIG_TypeQuery("_p_char");
1739 init = 1;
1740 }
1741 return info;
1742 }
1743
1744
1745 SWIGINTERN int
SWIG_AsCharPtrAndSize(SV * obj,char ** cptr,size_t * psize,int * alloc)1746 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1747 {
1748 if (SvMAGICAL(obj)) {
1749 SV *tmp = sv_newmortal();
1750 SvSetSV(tmp, obj);
1751 obj = tmp;
1752 }
1753 if (SvPOK(obj)) {
1754 STRLEN len = 0;
1755 char *cstr = SvPV(obj, len);
1756 size_t size = len + 1;
1757 if (cptr) {
1758 if (alloc) {
1759 if (*alloc == SWIG_NEWOBJ) {
1760 *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1761 } else {
1762 *cptr = cstr;
1763 *alloc = SWIG_OLDOBJ;
1764 }
1765 }
1766 }
1767 if (psize) *psize = size;
1768 return SWIG_OK;
1769 } else {
1770 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1771 if (pchar_descriptor) {
1772 char* vptr = 0;
1773 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1774 if (cptr) *cptr = vptr;
1775 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1776 if (alloc) *alloc = SWIG_OLDOBJ;
1777 return SWIG_OK;
1778 }
1779 }
1780 }
1781 return SWIG_TypeError;
1782 }
1783
1784
1785 SWIGINTERN int
SWIG_AsCharArray(SV * obj,char * val,size_t size)1786 SWIG_AsCharArray(SV * obj, char *val, size_t size)
1787 {
1788 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
1789 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
1790 if (SWIG_IsOK(res)) {
1791 /* special case of single char conversion when we don't need space for NUL */
1792 if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
1793 if (csize <= size) {
1794 if (val) {
1795 if (csize) memcpy(val, cptr, csize*sizeof(char));
1796 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
1797 }
1798 if (alloc == SWIG_NEWOBJ) {
1799 free((char*)cptr);
1800 res = SWIG_DelNewMask(res);
1801 }
1802 return res;
1803 }
1804 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
1805 }
1806 return SWIG_TypeError;
1807 }
1808
1809
1810 SWIGINTERNINLINE SV *
SWIG_FromCharPtrAndSize(const char * carray,size_t size)1811 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1812 {
1813 SV *obj = sv_newmortal();
1814 if (carray) {
1815 sv_setpvn(obj, carray, size);
1816 } else {
1817 sv_setsv(obj, &PL_sv_undef);
1818 }
1819 return obj;
1820 }
1821
1822
1823 size_t
SWIG_strnlen(const char * s,size_t maxlen)1824 SWIG_strnlen(const char* s, size_t maxlen)
1825 {
1826 const char *p;
1827 for (p = s; maxlen-- && *p; p++)
1828 ;
1829 return p - s;
1830 }
1831
1832
1833
1834
1835
1836 SWIGINTERNINLINE SV *
SWIG_FromCharPtr(const char * cptr)1837 SWIG_FromCharPtr(const char *cptr)
1838 {
1839 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1840 }
1841
1842
1843 SWIGINTERN int
SWIG_PERL_DECL_ARGS_2(SV * obj,unsigned long * val)1844 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
1845 {
1846 if (SvUOK(obj)) {
1847 UV v = SvUV(obj);
1848 if (v <= ULONG_MAX) {
1849 if (val) *val = v;
1850 return SWIG_OK;
1851 }
1852 return SWIG_OverflowError;
1853 } else if (SvIOK(obj)) {
1854 IV v = SvIV(obj);
1855 if (v >= 0 && v <= ULONG_MAX) {
1856 if (val) *val = v;
1857 return SWIG_OK;
1858 }
1859 return SWIG_OverflowError;
1860 } else {
1861 int dispatch = 0;
1862 const char *nptr = SvPV_nolen(obj);
1863 if (nptr) {
1864 char *endptr;
1865 unsigned long v;
1866 errno = 0;
1867 v = strtoul(nptr, &endptr,0);
1868 if (errno == ERANGE) {
1869 errno = 0;
1870 return SWIG_OverflowError;
1871 } else {
1872 if (*endptr == '\0') {
1873 if (val) *val = v;
1874 return SWIG_Str2NumCast(SWIG_OK);
1875 }
1876 }
1877 }
1878 if (!dispatch) {
1879 double d;
1880 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1881 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
1882 if (val) *val = (unsigned long)(d);
1883 return res;
1884 }
1885 }
1886 }
1887 return SWIG_TypeError;
1888 }
1889
1890
1891 SWIGINTERNINLINE int
SWIG_PERL_DECL_ARGS_2(SV * obj,size_t * val)1892 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
1893 {
1894 unsigned long v;
1895 int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
1896 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
1897 return res;
1898 }
1899
new_dumpfile_t(void)1900 SWIGINTERN dumpfile_t *new_dumpfile_t(void){
1901 dumpfile_t *df = g_new(dumpfile_t, 1);
1902 fh_init(df);
1903 /* some default values */
1904 df->totalparts = -1;
1905 df->partnum = 1;
1906 return df;
1907 }
delete_dumpfile_t(dumpfile_t * self)1908 SWIGINTERN void delete_dumpfile_t(dumpfile_t *self){
1909 dumpfile_free(self);
1910 }
dumpfile_t_to_string(dumpfile_t * self,size_t min_size,size_t max_size)1911 SWIGINTERN SV *dumpfile_t_to_string(dumpfile_t *self,size_t min_size,size_t max_size){
1912 size_t size = min_size;
1913 char *result;
1914
1915 result = build_header(self, &size, max_size);
1916 if (!result) {
1917 /* header didn't fit -> return undef; */
1918 return &PL_sv_undef;
1919 } else {
1920 STRLEN strlen_size = (STRLEN)size;
1921 SV *sv;
1922 g_assert((size_t)strlen_size == size); /* check for casting overflow */
1923 sv = sv_2mortal(newSVpvn(result, (STRLEN)size));
1924 g_free(result);
1925 return sv;
1926 }
1927 }
dumpfile_t_debug_dump(dumpfile_t * self)1928 SWIGINTERN void dumpfile_t_debug_dump(dumpfile_t *self){
1929 dump_dumpfile_t(self);
1930 }
dumpfile_t_summary(dumpfile_t * self)1931 SWIGINTERN char *dumpfile_t_summary(dumpfile_t *self){
1932 return summarize_header(self);
1933 }
1934
C_from_string(const char * string)1935 static dumpfile_t *C_from_string(const char *string) {
1936 dumpfile_t *result = g_new(dumpfile_t, 1);
1937 parse_file_header(string, result, strlen(string));
1938 return result;
1939 }
1940
1941
1942 #include "amxml.h"
1943
new_dle_t(char * dle_str)1944 SWIGINTERN dle_t *new_dle_t(char *dle_str){
1945 char *errmsg = NULL;
1946 dle_t *dle;
1947 dle = amxml_parse_node_CHAR(dle_str, &errmsg);
1948 amfree(errmsg);
1949
1950 return dle;
1951 }
delete_dle_t(dle_t * self)1952 SWIGINTERN void delete_dle_t(dle_t *self){
1953 amfree(self);
1954 }
1955 #ifdef __cplusplus
1956 extern "C" {
1957 #endif
1958
1959 #ifdef PERL_OBJECT
1960 #define MAGIC_CLASS _wrap_Amanda__Header_var::
1961 class _wrap_Amanda__Header_var : public CPerlObj {
1962 public:
1963 #else
1964 #define MAGIC_CLASS
1965 #endif
swig_magic_readonly(pTHX_ SV * SWIGUNUSEDPARM (sv),MAGIC * SWIGUNUSEDPARM (mg))1966 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
1967 MAGIC_PPERL
1968 croak("Value is read-only.");
1969 return 0;
1970 }
1971
1972
1973 #ifdef PERL_OBJECT
1974 };
1975 #endif
1976
1977 #ifdef __cplusplus
1978 }
1979 #endif
1980
1981 #ifdef __cplusplus
1982 extern "C" {
1983 #endif
XS(_wrap_Header_type_set)1984 XS(_wrap_Header_type_set) {
1985 {
1986 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1987 filetype_t arg2 ;
1988 void *argp1 = 0 ;
1989 int res1 = 0 ;
1990 int argvi = 0;
1991 dXSARGS;
1992
1993 if ((items < 2) || (items > 2)) {
1994 SWIG_croak("Usage: Header_type_set(self,type);");
1995 }
1996 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
1997 if (!SWIG_IsOK(res1)) {
1998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_type_set" "', argument " "1"" of type '" "dumpfile_t *""'");
1999 }
2000 arg1 = (dumpfile_t *)(argp1);
2001 {
2002 if (sizeof(signed int) == 1) {
2003 arg2 = amglue_SvI8(ST(1));
2004 } else if (sizeof(signed int) == 2) {
2005 arg2 = amglue_SvI16(ST(1));
2006 } else if (sizeof(signed int) == 4) {
2007 arg2 = amglue_SvI32(ST(1));
2008 } else if (sizeof(signed int) == 8) {
2009 arg2 = amglue_SvI64(ST(1));
2010 } else {
2011 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2012 }
2013 }
2014 if (arg1) (arg1)->type = arg2;
2015 ST(argvi) = sv_newmortal();
2016
2017
2018 XSRETURN(argvi);
2019 fail:
2020
2021
2022 SWIG_croak_null();
2023 }
2024 }
2025
2026
XS(_wrap_Header_type_get)2027 XS(_wrap_Header_type_get) {
2028 {
2029 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2030 void *argp1 = 0 ;
2031 int res1 = 0 ;
2032 int argvi = 0;
2033 filetype_t result;
2034 dXSARGS;
2035
2036 if ((items < 1) || (items > 1)) {
2037 SWIG_croak("Usage: Header_type_get(self);");
2038 }
2039 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2040 if (!SWIG_IsOK(res1)) {
2041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_type_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2042 }
2043 arg1 = (dumpfile_t *)(argp1);
2044 result = (filetype_t) ((arg1)->type);
2045 {
2046 SV *for_stack;
2047 SP += argvi; PUTBACK;
2048 for_stack = sv_2mortal(amglue_newSVi64(result));
2049 SPAGAIN; SP -= argvi;
2050 ST(argvi) = for_stack;
2051 argvi++;
2052 }
2053
2054 XSRETURN(argvi);
2055 fail:
2056
2057 SWIG_croak_null();
2058 }
2059 }
2060
2061
XS(_wrap_Header_datestamp_set)2062 XS(_wrap_Header_datestamp_set) {
2063 {
2064 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2065 char *arg2 ;
2066 void *argp1 = 0 ;
2067 int res1 = 0 ;
2068 char temp2[STRMAX] ;
2069 int res2 ;
2070 int argvi = 0;
2071 dXSARGS;
2072
2073 if ((items < 2) || (items > 2)) {
2074 SWIG_croak("Usage: Header_datestamp_set(self,datestamp);");
2075 }
2076 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2077 if (!SWIG_IsOK(res1)) {
2078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_datestamp_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2079 }
2080 arg1 = (dumpfile_t *)(argp1);
2081 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2082 if (!SWIG_IsOK(res2)) {
2083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_datestamp_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2084 }
2085 arg2 = (char *)(temp2);
2086 {
2087 strncpy(arg1->datestamp, arg2, STRMAX);
2088 if (arg1->datestamp[STRMAX-1] != '\0')
2089 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2090 }
2091 ST(argvi) = sv_newmortal();
2092
2093
2094 XSRETURN(argvi);
2095 fail:
2096
2097
2098 SWIG_croak_null();
2099 }
2100 }
2101
2102
XS(_wrap_Header_datestamp_get)2103 XS(_wrap_Header_datestamp_get) {
2104 {
2105 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2106 void *argp1 = 0 ;
2107 int res1 = 0 ;
2108 int argvi = 0;
2109 char *result = 0 ;
2110 dXSARGS;
2111
2112 if ((items < 1) || (items > 1)) {
2113 SWIG_croak("Usage: Header_datestamp_get(self);");
2114 }
2115 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2116 if (!SWIG_IsOK(res1)) {
2117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_datestamp_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2118 }
2119 arg1 = (dumpfile_t *)(argp1);
2120 result = (char *) ((arg1)->datestamp);
2121 {
2122 size_t size = SWIG_strnlen(result, STRMAX);
2123
2124
2125
2126 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2127 }
2128
2129 XSRETURN(argvi);
2130 fail:
2131
2132 SWIG_croak_null();
2133 }
2134 }
2135
2136
XS(_wrap_Header_dumplevel_set)2137 XS(_wrap_Header_dumplevel_set) {
2138 {
2139 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2140 int arg2 ;
2141 void *argp1 = 0 ;
2142 int res1 = 0 ;
2143 int argvi = 0;
2144 dXSARGS;
2145
2146 if ((items < 2) || (items > 2)) {
2147 SWIG_croak("Usage: Header_dumplevel_set(self,dumplevel);");
2148 }
2149 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2150 if (!SWIG_IsOK(res1)) {
2151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dumplevel_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2152 }
2153 arg1 = (dumpfile_t *)(argp1);
2154 {
2155 if (sizeof(signed int) == 1) {
2156 arg2 = amglue_SvI8(ST(1));
2157 } else if (sizeof(signed int) == 2) {
2158 arg2 = amglue_SvI16(ST(1));
2159 } else if (sizeof(signed int) == 4) {
2160 arg2 = amglue_SvI32(ST(1));
2161 } else if (sizeof(signed int) == 8) {
2162 arg2 = amglue_SvI64(ST(1));
2163 } else {
2164 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2165 }
2166 }
2167 if (arg1) (arg1)->dumplevel = arg2;
2168 ST(argvi) = sv_newmortal();
2169
2170
2171 XSRETURN(argvi);
2172 fail:
2173
2174
2175 SWIG_croak_null();
2176 }
2177 }
2178
2179
XS(_wrap_Header_dumplevel_get)2180 XS(_wrap_Header_dumplevel_get) {
2181 {
2182 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2183 void *argp1 = 0 ;
2184 int res1 = 0 ;
2185 int argvi = 0;
2186 int result;
2187 dXSARGS;
2188
2189 if ((items < 1) || (items > 1)) {
2190 SWIG_croak("Usage: Header_dumplevel_get(self);");
2191 }
2192 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2193 if (!SWIG_IsOK(res1)) {
2194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dumplevel_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2195 }
2196 arg1 = (dumpfile_t *)(argp1);
2197 result = (int) ((arg1)->dumplevel);
2198 {
2199 SV *for_stack;
2200 SP += argvi; PUTBACK;
2201 for_stack = sv_2mortal(amglue_newSVi64(result));
2202 SPAGAIN; SP -= argvi;
2203 ST(argvi) = for_stack;
2204 argvi++;
2205 }
2206
2207 XSRETURN(argvi);
2208 fail:
2209
2210 SWIG_croak_null();
2211 }
2212 }
2213
2214
XS(_wrap_Header_compressed_set)2215 XS(_wrap_Header_compressed_set) {
2216 {
2217 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2218 int arg2 ;
2219 void *argp1 = 0 ;
2220 int res1 = 0 ;
2221 int argvi = 0;
2222 dXSARGS;
2223
2224 if ((items < 2) || (items > 2)) {
2225 SWIG_croak("Usage: Header_compressed_set(self,compressed);");
2226 }
2227 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2228 if (!SWIG_IsOK(res1)) {
2229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_compressed_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2230 }
2231 arg1 = (dumpfile_t *)(argp1);
2232 {
2233 if (sizeof(signed int) == 1) {
2234 arg2 = amglue_SvI8(ST(1));
2235 } else if (sizeof(signed int) == 2) {
2236 arg2 = amglue_SvI16(ST(1));
2237 } else if (sizeof(signed int) == 4) {
2238 arg2 = amglue_SvI32(ST(1));
2239 } else if (sizeof(signed int) == 8) {
2240 arg2 = amglue_SvI64(ST(1));
2241 } else {
2242 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2243 }
2244 }
2245 if (arg1) (arg1)->compressed = arg2;
2246 ST(argvi) = sv_newmortal();
2247
2248
2249 XSRETURN(argvi);
2250 fail:
2251
2252
2253 SWIG_croak_null();
2254 }
2255 }
2256
2257
XS(_wrap_Header_compressed_get)2258 XS(_wrap_Header_compressed_get) {
2259 {
2260 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2261 void *argp1 = 0 ;
2262 int res1 = 0 ;
2263 int argvi = 0;
2264 int result;
2265 dXSARGS;
2266
2267 if ((items < 1) || (items > 1)) {
2268 SWIG_croak("Usage: Header_compressed_get(self);");
2269 }
2270 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2271 if (!SWIG_IsOK(res1)) {
2272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_compressed_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2273 }
2274 arg1 = (dumpfile_t *)(argp1);
2275 result = (int) ((arg1)->compressed);
2276 {
2277 SV *for_stack;
2278 SP += argvi; PUTBACK;
2279 for_stack = sv_2mortal(amglue_newSVi64(result));
2280 SPAGAIN; SP -= argvi;
2281 ST(argvi) = for_stack;
2282 argvi++;
2283 }
2284
2285 XSRETURN(argvi);
2286 fail:
2287
2288 SWIG_croak_null();
2289 }
2290 }
2291
2292
XS(_wrap_Header_encrypted_set)2293 XS(_wrap_Header_encrypted_set) {
2294 {
2295 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2296 int arg2 ;
2297 void *argp1 = 0 ;
2298 int res1 = 0 ;
2299 int argvi = 0;
2300 dXSARGS;
2301
2302 if ((items < 2) || (items > 2)) {
2303 SWIG_croak("Usage: Header_encrypted_set(self,encrypted);");
2304 }
2305 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2306 if (!SWIG_IsOK(res1)) {
2307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypted_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2308 }
2309 arg1 = (dumpfile_t *)(argp1);
2310 {
2311 if (sizeof(signed int) == 1) {
2312 arg2 = amglue_SvI8(ST(1));
2313 } else if (sizeof(signed int) == 2) {
2314 arg2 = amglue_SvI16(ST(1));
2315 } else if (sizeof(signed int) == 4) {
2316 arg2 = amglue_SvI32(ST(1));
2317 } else if (sizeof(signed int) == 8) {
2318 arg2 = amglue_SvI64(ST(1));
2319 } else {
2320 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2321 }
2322 }
2323 if (arg1) (arg1)->encrypted = arg2;
2324 ST(argvi) = sv_newmortal();
2325
2326
2327 XSRETURN(argvi);
2328 fail:
2329
2330
2331 SWIG_croak_null();
2332 }
2333 }
2334
2335
XS(_wrap_Header_encrypted_get)2336 XS(_wrap_Header_encrypted_get) {
2337 {
2338 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2339 void *argp1 = 0 ;
2340 int res1 = 0 ;
2341 int argvi = 0;
2342 int result;
2343 dXSARGS;
2344
2345 if ((items < 1) || (items > 1)) {
2346 SWIG_croak("Usage: Header_encrypted_get(self);");
2347 }
2348 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2349 if (!SWIG_IsOK(res1)) {
2350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypted_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2351 }
2352 arg1 = (dumpfile_t *)(argp1);
2353 result = (int) ((arg1)->encrypted);
2354 {
2355 SV *for_stack;
2356 SP += argvi; PUTBACK;
2357 for_stack = sv_2mortal(amglue_newSVi64(result));
2358 SPAGAIN; SP -= argvi;
2359 ST(argvi) = for_stack;
2360 argvi++;
2361 }
2362
2363 XSRETURN(argvi);
2364 fail:
2365
2366 SWIG_croak_null();
2367 }
2368 }
2369
2370
XS(_wrap_Header_comp_suffix_set)2371 XS(_wrap_Header_comp_suffix_set) {
2372 {
2373 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2374 char *arg2 ;
2375 void *argp1 = 0 ;
2376 int res1 = 0 ;
2377 char temp2[STRMAX] ;
2378 int res2 ;
2379 int argvi = 0;
2380 dXSARGS;
2381
2382 if ((items < 2) || (items > 2)) {
2383 SWIG_croak("Usage: Header_comp_suffix_set(self,comp_suffix);");
2384 }
2385 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2386 if (!SWIG_IsOK(res1)) {
2387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_comp_suffix_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2388 }
2389 arg1 = (dumpfile_t *)(argp1);
2390 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2391 if (!SWIG_IsOK(res2)) {
2392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_comp_suffix_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2393 }
2394 arg2 = (char *)(temp2);
2395 {
2396 strncpy(arg1->comp_suffix, arg2, STRMAX);
2397 if (arg1->comp_suffix[STRMAX-1] != '\0')
2398 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2399 }
2400 ST(argvi) = sv_newmortal();
2401
2402
2403 XSRETURN(argvi);
2404 fail:
2405
2406
2407 SWIG_croak_null();
2408 }
2409 }
2410
2411
XS(_wrap_Header_comp_suffix_get)2412 XS(_wrap_Header_comp_suffix_get) {
2413 {
2414 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2415 void *argp1 = 0 ;
2416 int res1 = 0 ;
2417 int argvi = 0;
2418 char *result = 0 ;
2419 dXSARGS;
2420
2421 if ((items < 1) || (items > 1)) {
2422 SWIG_croak("Usage: Header_comp_suffix_get(self);");
2423 }
2424 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2425 if (!SWIG_IsOK(res1)) {
2426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_comp_suffix_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2427 }
2428 arg1 = (dumpfile_t *)(argp1);
2429 result = (char *) ((arg1)->comp_suffix);
2430 {
2431 size_t size = SWIG_strnlen(result, STRMAX);
2432
2433
2434
2435 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2436 }
2437
2438 XSRETURN(argvi);
2439 fail:
2440
2441 SWIG_croak_null();
2442 }
2443 }
2444
2445
XS(_wrap_Header_encrypt_suffix_set)2446 XS(_wrap_Header_encrypt_suffix_set) {
2447 {
2448 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2449 char *arg2 ;
2450 void *argp1 = 0 ;
2451 int res1 = 0 ;
2452 char temp2[STRMAX] ;
2453 int res2 ;
2454 int argvi = 0;
2455 dXSARGS;
2456
2457 if ((items < 2) || (items > 2)) {
2458 SWIG_croak("Usage: Header_encrypt_suffix_set(self,encrypt_suffix);");
2459 }
2460 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2461 if (!SWIG_IsOK(res1)) {
2462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypt_suffix_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2463 }
2464 arg1 = (dumpfile_t *)(argp1);
2465 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2466 if (!SWIG_IsOK(res2)) {
2467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_encrypt_suffix_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2468 }
2469 arg2 = (char *)(temp2);
2470 {
2471 strncpy(arg1->encrypt_suffix, arg2, STRMAX);
2472 if (arg1->encrypt_suffix[STRMAX-1] != '\0')
2473 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2474 }
2475 ST(argvi) = sv_newmortal();
2476
2477
2478 XSRETURN(argvi);
2479 fail:
2480
2481
2482 SWIG_croak_null();
2483 }
2484 }
2485
2486
XS(_wrap_Header_encrypt_suffix_get)2487 XS(_wrap_Header_encrypt_suffix_get) {
2488 {
2489 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2490 void *argp1 = 0 ;
2491 int res1 = 0 ;
2492 int argvi = 0;
2493 char *result = 0 ;
2494 dXSARGS;
2495
2496 if ((items < 1) || (items > 1)) {
2497 SWIG_croak("Usage: Header_encrypt_suffix_get(self);");
2498 }
2499 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2500 if (!SWIG_IsOK(res1)) {
2501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypt_suffix_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2502 }
2503 arg1 = (dumpfile_t *)(argp1);
2504 result = (char *) ((arg1)->encrypt_suffix);
2505 {
2506 size_t size = SWIG_strnlen(result, STRMAX);
2507
2508
2509
2510 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2511 }
2512
2513 XSRETURN(argvi);
2514 fail:
2515
2516 SWIG_croak_null();
2517 }
2518 }
2519
2520
XS(_wrap_Header_name_set)2521 XS(_wrap_Header_name_set) {
2522 {
2523 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2524 char *arg2 ;
2525 void *argp1 = 0 ;
2526 int res1 = 0 ;
2527 char temp2[STRMAX] ;
2528 int res2 ;
2529 int argvi = 0;
2530 dXSARGS;
2531
2532 if ((items < 2) || (items > 2)) {
2533 SWIG_croak("Usage: Header_name_set(self,name);");
2534 }
2535 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2536 if (!SWIG_IsOK(res1)) {
2537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_name_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2538 }
2539 arg1 = (dumpfile_t *)(argp1);
2540 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2541 if (!SWIG_IsOK(res2)) {
2542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_name_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2543 }
2544 arg2 = (char *)(temp2);
2545 {
2546 strncpy(arg1->name, arg2, STRMAX);
2547 if (arg1->name[STRMAX-1] != '\0')
2548 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2549 }
2550 ST(argvi) = sv_newmortal();
2551
2552
2553 XSRETURN(argvi);
2554 fail:
2555
2556
2557 SWIG_croak_null();
2558 }
2559 }
2560
2561
XS(_wrap_Header_name_get)2562 XS(_wrap_Header_name_get) {
2563 {
2564 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2565 void *argp1 = 0 ;
2566 int res1 = 0 ;
2567 int argvi = 0;
2568 char *result = 0 ;
2569 dXSARGS;
2570
2571 if ((items < 1) || (items > 1)) {
2572 SWIG_croak("Usage: Header_name_get(self);");
2573 }
2574 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2575 if (!SWIG_IsOK(res1)) {
2576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_name_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2577 }
2578 arg1 = (dumpfile_t *)(argp1);
2579 result = (char *) ((arg1)->name);
2580 {
2581 size_t size = SWIG_strnlen(result, STRMAX);
2582
2583
2584
2585 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2586 }
2587
2588 XSRETURN(argvi);
2589 fail:
2590
2591 SWIG_croak_null();
2592 }
2593 }
2594
2595
XS(_wrap_Header_disk_set)2596 XS(_wrap_Header_disk_set) {
2597 {
2598 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2599 char *arg2 ;
2600 void *argp1 = 0 ;
2601 int res1 = 0 ;
2602 char temp2[STRMAX] ;
2603 int res2 ;
2604 int argvi = 0;
2605 dXSARGS;
2606
2607 if ((items < 2) || (items > 2)) {
2608 SWIG_croak("Usage: Header_disk_set(self,disk);");
2609 }
2610 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2611 if (!SWIG_IsOK(res1)) {
2612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_disk_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2613 }
2614 arg1 = (dumpfile_t *)(argp1);
2615 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2616 if (!SWIG_IsOK(res2)) {
2617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_disk_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2618 }
2619 arg2 = (char *)(temp2);
2620 {
2621 strncpy(arg1->disk, arg2, STRMAX);
2622 if (arg1->disk[STRMAX-1] != '\0')
2623 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2624 }
2625 ST(argvi) = sv_newmortal();
2626
2627
2628 XSRETURN(argvi);
2629 fail:
2630
2631
2632 SWIG_croak_null();
2633 }
2634 }
2635
2636
XS(_wrap_Header_disk_get)2637 XS(_wrap_Header_disk_get) {
2638 {
2639 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2640 void *argp1 = 0 ;
2641 int res1 = 0 ;
2642 int argvi = 0;
2643 char *result = 0 ;
2644 dXSARGS;
2645
2646 if ((items < 1) || (items > 1)) {
2647 SWIG_croak("Usage: Header_disk_get(self);");
2648 }
2649 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2650 if (!SWIG_IsOK(res1)) {
2651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_disk_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2652 }
2653 arg1 = (dumpfile_t *)(argp1);
2654 result = (char *) ((arg1)->disk);
2655 {
2656 size_t size = SWIG_strnlen(result, STRMAX);
2657
2658
2659
2660 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2661 }
2662
2663 XSRETURN(argvi);
2664 fail:
2665
2666 SWIG_croak_null();
2667 }
2668 }
2669
2670
XS(_wrap_Header_program_set)2671 XS(_wrap_Header_program_set) {
2672 {
2673 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2674 char *arg2 ;
2675 void *argp1 = 0 ;
2676 int res1 = 0 ;
2677 char temp2[STRMAX] ;
2678 int res2 ;
2679 int argvi = 0;
2680 dXSARGS;
2681
2682 if ((items < 2) || (items > 2)) {
2683 SWIG_croak("Usage: Header_program_set(self,program);");
2684 }
2685 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2686 if (!SWIG_IsOK(res1)) {
2687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_program_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2688 }
2689 arg1 = (dumpfile_t *)(argp1);
2690 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2691 if (!SWIG_IsOK(res2)) {
2692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_program_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2693 }
2694 arg2 = (char *)(temp2);
2695 {
2696 strncpy(arg1->program, arg2, STRMAX);
2697 if (arg1->program[STRMAX-1] != '\0')
2698 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2699 }
2700 ST(argvi) = sv_newmortal();
2701
2702
2703 XSRETURN(argvi);
2704 fail:
2705
2706
2707 SWIG_croak_null();
2708 }
2709 }
2710
2711
XS(_wrap_Header_program_get)2712 XS(_wrap_Header_program_get) {
2713 {
2714 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2715 void *argp1 = 0 ;
2716 int res1 = 0 ;
2717 int argvi = 0;
2718 char *result = 0 ;
2719 dXSARGS;
2720
2721 if ((items < 1) || (items > 1)) {
2722 SWIG_croak("Usage: Header_program_get(self);");
2723 }
2724 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2725 if (!SWIG_IsOK(res1)) {
2726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_program_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2727 }
2728 arg1 = (dumpfile_t *)(argp1);
2729 result = (char *) ((arg1)->program);
2730 {
2731 size_t size = SWIG_strnlen(result, STRMAX);
2732
2733
2734
2735 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2736 }
2737
2738 XSRETURN(argvi);
2739 fail:
2740
2741 SWIG_croak_null();
2742 }
2743 }
2744
2745
XS(_wrap_Header_application_set)2746 XS(_wrap_Header_application_set) {
2747 {
2748 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2749 char *arg2 ;
2750 void *argp1 = 0 ;
2751 int res1 = 0 ;
2752 char temp2[STRMAX] ;
2753 int res2 ;
2754 int argvi = 0;
2755 dXSARGS;
2756
2757 if ((items < 2) || (items > 2)) {
2758 SWIG_croak("Usage: Header_application_set(self,application);");
2759 }
2760 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2761 if (!SWIG_IsOK(res1)) {
2762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_application_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2763 }
2764 arg1 = (dumpfile_t *)(argp1);
2765 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2766 if (!SWIG_IsOK(res2)) {
2767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_application_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2768 }
2769 arg2 = (char *)(temp2);
2770 {
2771 strncpy(arg1->application, arg2, STRMAX);
2772 if (arg1->application[STRMAX-1] != '\0')
2773 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2774 }
2775 ST(argvi) = sv_newmortal();
2776
2777
2778 XSRETURN(argvi);
2779 fail:
2780
2781
2782 SWIG_croak_null();
2783 }
2784 }
2785
2786
XS(_wrap_Header_application_get)2787 XS(_wrap_Header_application_get) {
2788 {
2789 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2790 void *argp1 = 0 ;
2791 int res1 = 0 ;
2792 int argvi = 0;
2793 char *result = 0 ;
2794 dXSARGS;
2795
2796 if ((items < 1) || (items > 1)) {
2797 SWIG_croak("Usage: Header_application_get(self);");
2798 }
2799 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2800 if (!SWIG_IsOK(res1)) {
2801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_application_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2802 }
2803 arg1 = (dumpfile_t *)(argp1);
2804 result = (char *) ((arg1)->application);
2805 {
2806 size_t size = SWIG_strnlen(result, STRMAX);
2807
2808
2809
2810 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2811 }
2812
2813 XSRETURN(argvi);
2814 fail:
2815
2816 SWIG_croak_null();
2817 }
2818 }
2819
2820
XS(_wrap_Header_srvcompprog_set)2821 XS(_wrap_Header_srvcompprog_set) {
2822 {
2823 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2824 char *arg2 ;
2825 void *argp1 = 0 ;
2826 int res1 = 0 ;
2827 char temp2[STRMAX] ;
2828 int res2 ;
2829 int argvi = 0;
2830 dXSARGS;
2831
2832 if ((items < 2) || (items > 2)) {
2833 SWIG_croak("Usage: Header_srvcompprog_set(self,srvcompprog);");
2834 }
2835 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2836 if (!SWIG_IsOK(res1)) {
2837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srvcompprog_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2838 }
2839 arg1 = (dumpfile_t *)(argp1);
2840 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2841 if (!SWIG_IsOK(res2)) {
2842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srvcompprog_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2843 }
2844 arg2 = (char *)(temp2);
2845 {
2846 strncpy(arg1->srvcompprog, arg2, STRMAX);
2847 if (arg1->srvcompprog[STRMAX-1] != '\0')
2848 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2849 }
2850 ST(argvi) = sv_newmortal();
2851
2852
2853 XSRETURN(argvi);
2854 fail:
2855
2856
2857 SWIG_croak_null();
2858 }
2859 }
2860
2861
XS(_wrap_Header_srvcompprog_get)2862 XS(_wrap_Header_srvcompprog_get) {
2863 {
2864 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2865 void *argp1 = 0 ;
2866 int res1 = 0 ;
2867 int argvi = 0;
2868 char *result = 0 ;
2869 dXSARGS;
2870
2871 if ((items < 1) || (items > 1)) {
2872 SWIG_croak("Usage: Header_srvcompprog_get(self);");
2873 }
2874 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2875 if (!SWIG_IsOK(res1)) {
2876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srvcompprog_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2877 }
2878 arg1 = (dumpfile_t *)(argp1);
2879 result = (char *) ((arg1)->srvcompprog);
2880 {
2881 size_t size = SWIG_strnlen(result, STRMAX);
2882
2883
2884
2885 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2886 }
2887
2888 XSRETURN(argvi);
2889 fail:
2890
2891 SWIG_croak_null();
2892 }
2893 }
2894
2895
XS(_wrap_Header_clntcompprog_set)2896 XS(_wrap_Header_clntcompprog_set) {
2897 {
2898 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2899 char *arg2 ;
2900 void *argp1 = 0 ;
2901 int res1 = 0 ;
2902 char temp2[STRMAX] ;
2903 int res2 ;
2904 int argvi = 0;
2905 dXSARGS;
2906
2907 if ((items < 2) || (items > 2)) {
2908 SWIG_croak("Usage: Header_clntcompprog_set(self,clntcompprog);");
2909 }
2910 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2911 if (!SWIG_IsOK(res1)) {
2912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clntcompprog_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2913 }
2914 arg1 = (dumpfile_t *)(argp1);
2915 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2916 if (!SWIG_IsOK(res2)) {
2917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clntcompprog_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2918 }
2919 arg2 = (char *)(temp2);
2920 {
2921 strncpy(arg1->clntcompprog, arg2, STRMAX);
2922 if (arg1->clntcompprog[STRMAX-1] != '\0')
2923 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2924 }
2925 ST(argvi) = sv_newmortal();
2926
2927
2928 XSRETURN(argvi);
2929 fail:
2930
2931
2932 SWIG_croak_null();
2933 }
2934 }
2935
2936
XS(_wrap_Header_clntcompprog_get)2937 XS(_wrap_Header_clntcompprog_get) {
2938 {
2939 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2940 void *argp1 = 0 ;
2941 int res1 = 0 ;
2942 int argvi = 0;
2943 char *result = 0 ;
2944 dXSARGS;
2945
2946 if ((items < 1) || (items > 1)) {
2947 SWIG_croak("Usage: Header_clntcompprog_get(self);");
2948 }
2949 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2950 if (!SWIG_IsOK(res1)) {
2951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clntcompprog_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2952 }
2953 arg1 = (dumpfile_t *)(argp1);
2954 result = (char *) ((arg1)->clntcompprog);
2955 {
2956 size_t size = SWIG_strnlen(result, STRMAX);
2957
2958
2959
2960 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2961 }
2962
2963 XSRETURN(argvi);
2964 fail:
2965
2966 SWIG_croak_null();
2967 }
2968 }
2969
2970
XS(_wrap_Header_srv_encrypt_set)2971 XS(_wrap_Header_srv_encrypt_set) {
2972 {
2973 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2974 char *arg2 ;
2975 void *argp1 = 0 ;
2976 int res1 = 0 ;
2977 char temp2[STRMAX] ;
2978 int res2 ;
2979 int argvi = 0;
2980 dXSARGS;
2981
2982 if ((items < 2) || (items > 2)) {
2983 SWIG_croak("Usage: Header_srv_encrypt_set(self,srv_encrypt);");
2984 }
2985 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2986 if (!SWIG_IsOK(res1)) {
2987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_encrypt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2988 }
2989 arg1 = (dumpfile_t *)(argp1);
2990 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2991 if (!SWIG_IsOK(res2)) {
2992 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srv_encrypt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2993 }
2994 arg2 = (char *)(temp2);
2995 {
2996 strncpy(arg1->srv_encrypt, arg2, STRMAX);
2997 if (arg1->srv_encrypt[STRMAX-1] != '\0')
2998 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2999 }
3000 ST(argvi) = sv_newmortal();
3001
3002
3003 XSRETURN(argvi);
3004 fail:
3005
3006
3007 SWIG_croak_null();
3008 }
3009 }
3010
3011
XS(_wrap_Header_srv_encrypt_get)3012 XS(_wrap_Header_srv_encrypt_get) {
3013 {
3014 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3015 void *argp1 = 0 ;
3016 int res1 = 0 ;
3017 int argvi = 0;
3018 char *result = 0 ;
3019 dXSARGS;
3020
3021 if ((items < 1) || (items > 1)) {
3022 SWIG_croak("Usage: Header_srv_encrypt_get(self);");
3023 }
3024 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3025 if (!SWIG_IsOK(res1)) {
3026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_encrypt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3027 }
3028 arg1 = (dumpfile_t *)(argp1);
3029 result = (char *) ((arg1)->srv_encrypt);
3030 {
3031 size_t size = SWIG_strnlen(result, STRMAX);
3032
3033
3034
3035 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3036 }
3037
3038 XSRETURN(argvi);
3039 fail:
3040
3041 SWIG_croak_null();
3042 }
3043 }
3044
3045
XS(_wrap_Header_clnt_encrypt_set)3046 XS(_wrap_Header_clnt_encrypt_set) {
3047 {
3048 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3049 char *arg2 ;
3050 void *argp1 = 0 ;
3051 int res1 = 0 ;
3052 char temp2[STRMAX] ;
3053 int res2 ;
3054 int argvi = 0;
3055 dXSARGS;
3056
3057 if ((items < 2) || (items > 2)) {
3058 SWIG_croak("Usage: Header_clnt_encrypt_set(self,clnt_encrypt);");
3059 }
3060 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3061 if (!SWIG_IsOK(res1)) {
3062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_encrypt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3063 }
3064 arg1 = (dumpfile_t *)(argp1);
3065 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3066 if (!SWIG_IsOK(res2)) {
3067 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clnt_encrypt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3068 }
3069 arg2 = (char *)(temp2);
3070 {
3071 strncpy(arg1->clnt_encrypt, arg2, STRMAX);
3072 if (arg1->clnt_encrypt[STRMAX-1] != '\0')
3073 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3074 }
3075 ST(argvi) = sv_newmortal();
3076
3077
3078 XSRETURN(argvi);
3079 fail:
3080
3081
3082 SWIG_croak_null();
3083 }
3084 }
3085
3086
XS(_wrap_Header_clnt_encrypt_get)3087 XS(_wrap_Header_clnt_encrypt_get) {
3088 {
3089 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3090 void *argp1 = 0 ;
3091 int res1 = 0 ;
3092 int argvi = 0;
3093 char *result = 0 ;
3094 dXSARGS;
3095
3096 if ((items < 1) || (items > 1)) {
3097 SWIG_croak("Usage: Header_clnt_encrypt_get(self);");
3098 }
3099 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3100 if (!SWIG_IsOK(res1)) {
3101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_encrypt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3102 }
3103 arg1 = (dumpfile_t *)(argp1);
3104 result = (char *) ((arg1)->clnt_encrypt);
3105 {
3106 size_t size = SWIG_strnlen(result, STRMAX);
3107
3108
3109
3110 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3111 }
3112
3113 XSRETURN(argvi);
3114 fail:
3115
3116 SWIG_croak_null();
3117 }
3118 }
3119
3120
XS(_wrap_Header_recover_cmd_set)3121 XS(_wrap_Header_recover_cmd_set) {
3122 {
3123 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3124 char *arg2 ;
3125 void *argp1 = 0 ;
3126 int res1 = 0 ;
3127 char temp2[STRMAX] ;
3128 int res2 ;
3129 int argvi = 0;
3130 dXSARGS;
3131
3132 if ((items < 2) || (items > 2)) {
3133 SWIG_croak("Usage: Header_recover_cmd_set(self,recover_cmd);");
3134 }
3135 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3136 if (!SWIG_IsOK(res1)) {
3137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_recover_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3138 }
3139 arg1 = (dumpfile_t *)(argp1);
3140 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3141 if (!SWIG_IsOK(res2)) {
3142 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_recover_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3143 }
3144 arg2 = (char *)(temp2);
3145 {
3146 strncpy(arg1->recover_cmd, arg2, STRMAX);
3147 if (arg1->recover_cmd[STRMAX-1] != '\0')
3148 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3149 }
3150 ST(argvi) = sv_newmortal();
3151
3152
3153 XSRETURN(argvi);
3154 fail:
3155
3156
3157 SWIG_croak_null();
3158 }
3159 }
3160
3161
XS(_wrap_Header_recover_cmd_get)3162 XS(_wrap_Header_recover_cmd_get) {
3163 {
3164 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3165 void *argp1 = 0 ;
3166 int res1 = 0 ;
3167 int argvi = 0;
3168 char *result = 0 ;
3169 dXSARGS;
3170
3171 if ((items < 1) || (items > 1)) {
3172 SWIG_croak("Usage: Header_recover_cmd_get(self);");
3173 }
3174 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3175 if (!SWIG_IsOK(res1)) {
3176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_recover_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3177 }
3178 arg1 = (dumpfile_t *)(argp1);
3179 result = (char *) ((arg1)->recover_cmd);
3180 {
3181 size_t size = SWIG_strnlen(result, STRMAX);
3182
3183
3184
3185 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3186 }
3187
3188 XSRETURN(argvi);
3189 fail:
3190
3191 SWIG_croak_null();
3192 }
3193 }
3194
3195
XS(_wrap_Header_uncompress_cmd_set)3196 XS(_wrap_Header_uncompress_cmd_set) {
3197 {
3198 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3199 char *arg2 ;
3200 void *argp1 = 0 ;
3201 int res1 = 0 ;
3202 char temp2[STRMAX] ;
3203 int res2 ;
3204 int argvi = 0;
3205 dXSARGS;
3206
3207 if ((items < 2) || (items > 2)) {
3208 SWIG_croak("Usage: Header_uncompress_cmd_set(self,uncompress_cmd);");
3209 }
3210 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3211 if (!SWIG_IsOK(res1)) {
3212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_uncompress_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3213 }
3214 arg1 = (dumpfile_t *)(argp1);
3215 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3216 if (!SWIG_IsOK(res2)) {
3217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_uncompress_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3218 }
3219 arg2 = (char *)(temp2);
3220 {
3221 strncpy(arg1->uncompress_cmd, arg2, STRMAX);
3222 if (arg1->uncompress_cmd[STRMAX-1] != '\0')
3223 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3224 }
3225 ST(argvi) = sv_newmortal();
3226
3227
3228 XSRETURN(argvi);
3229 fail:
3230
3231
3232 SWIG_croak_null();
3233 }
3234 }
3235
3236
XS(_wrap_Header_uncompress_cmd_get)3237 XS(_wrap_Header_uncompress_cmd_get) {
3238 {
3239 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3240 void *argp1 = 0 ;
3241 int res1 = 0 ;
3242 int argvi = 0;
3243 char *result = 0 ;
3244 dXSARGS;
3245
3246 if ((items < 1) || (items > 1)) {
3247 SWIG_croak("Usage: Header_uncompress_cmd_get(self);");
3248 }
3249 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3250 if (!SWIG_IsOK(res1)) {
3251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_uncompress_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3252 }
3253 arg1 = (dumpfile_t *)(argp1);
3254 result = (char *) ((arg1)->uncompress_cmd);
3255 {
3256 size_t size = SWIG_strnlen(result, STRMAX);
3257
3258
3259
3260 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3261 }
3262
3263 XSRETURN(argvi);
3264 fail:
3265
3266 SWIG_croak_null();
3267 }
3268 }
3269
3270
XS(_wrap_Header_decrypt_cmd_set)3271 XS(_wrap_Header_decrypt_cmd_set) {
3272 {
3273 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3274 char *arg2 ;
3275 void *argp1 = 0 ;
3276 int res1 = 0 ;
3277 char temp2[STRMAX] ;
3278 int res2 ;
3279 int argvi = 0;
3280 dXSARGS;
3281
3282 if ((items < 2) || (items > 2)) {
3283 SWIG_croak("Usage: Header_decrypt_cmd_set(self,decrypt_cmd);");
3284 }
3285 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3286 if (!SWIG_IsOK(res1)) {
3287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_decrypt_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3288 }
3289 arg1 = (dumpfile_t *)(argp1);
3290 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3291 if (!SWIG_IsOK(res2)) {
3292 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_decrypt_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3293 }
3294 arg2 = (char *)(temp2);
3295 {
3296 strncpy(arg1->decrypt_cmd, arg2, STRMAX);
3297 if (arg1->decrypt_cmd[STRMAX-1] != '\0')
3298 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3299 }
3300 ST(argvi) = sv_newmortal();
3301
3302
3303 XSRETURN(argvi);
3304 fail:
3305
3306
3307 SWIG_croak_null();
3308 }
3309 }
3310
3311
XS(_wrap_Header_decrypt_cmd_get)3312 XS(_wrap_Header_decrypt_cmd_get) {
3313 {
3314 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3315 void *argp1 = 0 ;
3316 int res1 = 0 ;
3317 int argvi = 0;
3318 char *result = 0 ;
3319 dXSARGS;
3320
3321 if ((items < 1) || (items > 1)) {
3322 SWIG_croak("Usage: Header_decrypt_cmd_get(self);");
3323 }
3324 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3325 if (!SWIG_IsOK(res1)) {
3326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_decrypt_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3327 }
3328 arg1 = (dumpfile_t *)(argp1);
3329 result = (char *) ((arg1)->decrypt_cmd);
3330 {
3331 size_t size = SWIG_strnlen(result, STRMAX);
3332
3333
3334
3335 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3336 }
3337
3338 XSRETURN(argvi);
3339 fail:
3340
3341 SWIG_croak_null();
3342 }
3343 }
3344
3345
XS(_wrap_Header_srv_decrypt_opt_set)3346 XS(_wrap_Header_srv_decrypt_opt_set) {
3347 {
3348 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3349 char *arg2 ;
3350 void *argp1 = 0 ;
3351 int res1 = 0 ;
3352 char temp2[STRMAX] ;
3353 int res2 ;
3354 int argvi = 0;
3355 dXSARGS;
3356
3357 if ((items < 2) || (items > 2)) {
3358 SWIG_croak("Usage: Header_srv_decrypt_opt_set(self,srv_decrypt_opt);");
3359 }
3360 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3361 if (!SWIG_IsOK(res1)) {
3362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_decrypt_opt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3363 }
3364 arg1 = (dumpfile_t *)(argp1);
3365 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3366 if (!SWIG_IsOK(res2)) {
3367 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srv_decrypt_opt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3368 }
3369 arg2 = (char *)(temp2);
3370 {
3371 strncpy(arg1->srv_decrypt_opt, arg2, STRMAX);
3372 if (arg1->srv_decrypt_opt[STRMAX-1] != '\0')
3373 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3374 }
3375 ST(argvi) = sv_newmortal();
3376
3377
3378 XSRETURN(argvi);
3379 fail:
3380
3381
3382 SWIG_croak_null();
3383 }
3384 }
3385
3386
XS(_wrap_Header_srv_decrypt_opt_get)3387 XS(_wrap_Header_srv_decrypt_opt_get) {
3388 {
3389 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3390 void *argp1 = 0 ;
3391 int res1 = 0 ;
3392 int argvi = 0;
3393 char *result = 0 ;
3394 dXSARGS;
3395
3396 if ((items < 1) || (items > 1)) {
3397 SWIG_croak("Usage: Header_srv_decrypt_opt_get(self);");
3398 }
3399 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3400 if (!SWIG_IsOK(res1)) {
3401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_decrypt_opt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3402 }
3403 arg1 = (dumpfile_t *)(argp1);
3404 result = (char *) ((arg1)->srv_decrypt_opt);
3405 {
3406 size_t size = SWIG_strnlen(result, STRMAX);
3407
3408
3409
3410 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3411 }
3412
3413 XSRETURN(argvi);
3414 fail:
3415
3416 SWIG_croak_null();
3417 }
3418 }
3419
3420
XS(_wrap_Header_clnt_decrypt_opt_set)3421 XS(_wrap_Header_clnt_decrypt_opt_set) {
3422 {
3423 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3424 char *arg2 ;
3425 void *argp1 = 0 ;
3426 int res1 = 0 ;
3427 char temp2[STRMAX] ;
3428 int res2 ;
3429 int argvi = 0;
3430 dXSARGS;
3431
3432 if ((items < 2) || (items > 2)) {
3433 SWIG_croak("Usage: Header_clnt_decrypt_opt_set(self,clnt_decrypt_opt);");
3434 }
3435 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3436 if (!SWIG_IsOK(res1)) {
3437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_decrypt_opt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3438 }
3439 arg1 = (dumpfile_t *)(argp1);
3440 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3441 if (!SWIG_IsOK(res2)) {
3442 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clnt_decrypt_opt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3443 }
3444 arg2 = (char *)(temp2);
3445 {
3446 strncpy(arg1->clnt_decrypt_opt, arg2, STRMAX);
3447 if (arg1->clnt_decrypt_opt[STRMAX-1] != '\0')
3448 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3449 }
3450 ST(argvi) = sv_newmortal();
3451
3452
3453 XSRETURN(argvi);
3454 fail:
3455
3456
3457 SWIG_croak_null();
3458 }
3459 }
3460
3461
XS(_wrap_Header_clnt_decrypt_opt_get)3462 XS(_wrap_Header_clnt_decrypt_opt_get) {
3463 {
3464 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3465 void *argp1 = 0 ;
3466 int res1 = 0 ;
3467 int argvi = 0;
3468 char *result = 0 ;
3469 dXSARGS;
3470
3471 if ((items < 1) || (items > 1)) {
3472 SWIG_croak("Usage: Header_clnt_decrypt_opt_get(self);");
3473 }
3474 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3475 if (!SWIG_IsOK(res1)) {
3476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_decrypt_opt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3477 }
3478 arg1 = (dumpfile_t *)(argp1);
3479 result = (char *) ((arg1)->clnt_decrypt_opt);
3480 {
3481 size_t size = SWIG_strnlen(result, STRMAX);
3482
3483
3484
3485 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3486 }
3487
3488 XSRETURN(argvi);
3489 fail:
3490
3491 SWIG_croak_null();
3492 }
3493 }
3494
3495
XS(_wrap_Header_cont_filename_set)3496 XS(_wrap_Header_cont_filename_set) {
3497 {
3498 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3499 char *arg2 ;
3500 void *argp1 = 0 ;
3501 int res1 = 0 ;
3502 char temp2[STRMAX] ;
3503 int res2 ;
3504 int argvi = 0;
3505 dXSARGS;
3506
3507 if ((items < 2) || (items > 2)) {
3508 SWIG_croak("Usage: Header_cont_filename_set(self,cont_filename);");
3509 }
3510 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3511 if (!SWIG_IsOK(res1)) {
3512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_cont_filename_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3513 }
3514 arg1 = (dumpfile_t *)(argp1);
3515 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3516 if (!SWIG_IsOK(res2)) {
3517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_cont_filename_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3518 }
3519 arg2 = (char *)(temp2);
3520 {
3521 strncpy(arg1->cont_filename, arg2, STRMAX);
3522 if (arg1->cont_filename[STRMAX-1] != '\0')
3523 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3524 }
3525 ST(argvi) = sv_newmortal();
3526
3527
3528 XSRETURN(argvi);
3529 fail:
3530
3531
3532 SWIG_croak_null();
3533 }
3534 }
3535
3536
XS(_wrap_Header_cont_filename_get)3537 XS(_wrap_Header_cont_filename_get) {
3538 {
3539 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3540 void *argp1 = 0 ;
3541 int res1 = 0 ;
3542 int argvi = 0;
3543 char *result = 0 ;
3544 dXSARGS;
3545
3546 if ((items < 1) || (items > 1)) {
3547 SWIG_croak("Usage: Header_cont_filename_get(self);");
3548 }
3549 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3550 if (!SWIG_IsOK(res1)) {
3551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_cont_filename_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3552 }
3553 arg1 = (dumpfile_t *)(argp1);
3554 result = (char *) ((arg1)->cont_filename);
3555 {
3556 size_t size = SWIG_strnlen(result, STRMAX);
3557
3558
3559
3560 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3561 }
3562
3563 XSRETURN(argvi);
3564 fail:
3565
3566 SWIG_croak_null();
3567 }
3568 }
3569
3570
XS(_wrap_Header_dle_str_set)3571 XS(_wrap_Header_dle_str_set) {
3572 {
3573 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3574 char *arg2 = (char *) 0 ;
3575 void *argp1 = 0 ;
3576 int res1 = 0 ;
3577 int res2 ;
3578 char *buf2 = 0 ;
3579 int alloc2 = 0 ;
3580 int argvi = 0;
3581 dXSARGS;
3582
3583 if ((items < 2) || (items > 2)) {
3584 SWIG_croak("Usage: Header_dle_str_set(self,dle_str);");
3585 }
3586 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3587 if (!SWIG_IsOK(res1)) {
3588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dle_str_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3589 }
3590 arg1 = (dumpfile_t *)(argp1);
3591 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3592 if (!SWIG_IsOK(res2)) {
3593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_dle_str_set" "', argument " "2"" of type '" "char *""'");
3594 }
3595 arg2 = (char *)(buf2);
3596 if (arg1->dle_str) free((char*)arg1->dle_str);
3597 if (arg2) {
3598 size_t size = strlen((const char *)(arg2)) + 1;
3599 arg1->dle_str = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
3600 } else {
3601 arg1->dle_str = 0;
3602 }
3603 ST(argvi) = sv_newmortal();
3604
3605 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3606 XSRETURN(argvi);
3607 fail:
3608
3609 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3610 SWIG_croak_null();
3611 }
3612 }
3613
3614
XS(_wrap_Header_dle_str_get)3615 XS(_wrap_Header_dle_str_get) {
3616 {
3617 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3618 void *argp1 = 0 ;
3619 int res1 = 0 ;
3620 int argvi = 0;
3621 char *result = 0 ;
3622 dXSARGS;
3623
3624 if ((items < 1) || (items > 1)) {
3625 SWIG_croak("Usage: Header_dle_str_get(self);");
3626 }
3627 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3628 if (!SWIG_IsOK(res1)) {
3629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dle_str_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3630 }
3631 arg1 = (dumpfile_t *)(argp1);
3632 result = (char *) ((arg1)->dle_str);
3633 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3634
3635 XSRETURN(argvi);
3636 fail:
3637
3638 SWIG_croak_null();
3639 }
3640 }
3641
3642
XS(_wrap_Header_is_partial_set)3643 XS(_wrap_Header_is_partial_set) {
3644 {
3645 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3646 int arg2 ;
3647 void *argp1 = 0 ;
3648 int res1 = 0 ;
3649 int argvi = 0;
3650 dXSARGS;
3651
3652 if ((items < 2) || (items > 2)) {
3653 SWIG_croak("Usage: Header_is_partial_set(self,is_partial);");
3654 }
3655 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3656 if (!SWIG_IsOK(res1)) {
3657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_is_partial_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3658 }
3659 arg1 = (dumpfile_t *)(argp1);
3660 {
3661 if (sizeof(signed int) == 1) {
3662 arg2 = amglue_SvI8(ST(1));
3663 } else if (sizeof(signed int) == 2) {
3664 arg2 = amglue_SvI16(ST(1));
3665 } else if (sizeof(signed int) == 4) {
3666 arg2 = amglue_SvI32(ST(1));
3667 } else if (sizeof(signed int) == 8) {
3668 arg2 = amglue_SvI64(ST(1));
3669 } else {
3670 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3671 }
3672 }
3673 if (arg1) (arg1)->is_partial = arg2;
3674 ST(argvi) = sv_newmortal();
3675
3676
3677 XSRETURN(argvi);
3678 fail:
3679
3680
3681 SWIG_croak_null();
3682 }
3683 }
3684
3685
XS(_wrap_Header_is_partial_get)3686 XS(_wrap_Header_is_partial_get) {
3687 {
3688 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3689 void *argp1 = 0 ;
3690 int res1 = 0 ;
3691 int argvi = 0;
3692 int result;
3693 dXSARGS;
3694
3695 if ((items < 1) || (items > 1)) {
3696 SWIG_croak("Usage: Header_is_partial_get(self);");
3697 }
3698 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3699 if (!SWIG_IsOK(res1)) {
3700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_is_partial_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3701 }
3702 arg1 = (dumpfile_t *)(argp1);
3703 result = (int) ((arg1)->is_partial);
3704 {
3705 SV *for_stack;
3706 SP += argvi; PUTBACK;
3707 for_stack = sv_2mortal(amglue_newSVi64(result));
3708 SPAGAIN; SP -= argvi;
3709 ST(argvi) = for_stack;
3710 argvi++;
3711 }
3712
3713 XSRETURN(argvi);
3714 fail:
3715
3716 SWIG_croak_null();
3717 }
3718 }
3719
3720
XS(_wrap_Header_partnum_set)3721 XS(_wrap_Header_partnum_set) {
3722 {
3723 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3724 int arg2 ;
3725 void *argp1 = 0 ;
3726 int res1 = 0 ;
3727 int argvi = 0;
3728 dXSARGS;
3729
3730 if ((items < 2) || (items > 2)) {
3731 SWIG_croak("Usage: Header_partnum_set(self,partnum);");
3732 }
3733 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3734 if (!SWIG_IsOK(res1)) {
3735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_partnum_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3736 }
3737 arg1 = (dumpfile_t *)(argp1);
3738 {
3739 if (sizeof(signed int) == 1) {
3740 arg2 = amglue_SvI8(ST(1));
3741 } else if (sizeof(signed int) == 2) {
3742 arg2 = amglue_SvI16(ST(1));
3743 } else if (sizeof(signed int) == 4) {
3744 arg2 = amglue_SvI32(ST(1));
3745 } else if (sizeof(signed int) == 8) {
3746 arg2 = amglue_SvI64(ST(1));
3747 } else {
3748 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3749 }
3750 }
3751 if (arg1) (arg1)->partnum = arg2;
3752 ST(argvi) = sv_newmortal();
3753
3754
3755 XSRETURN(argvi);
3756 fail:
3757
3758
3759 SWIG_croak_null();
3760 }
3761 }
3762
3763
XS(_wrap_Header_partnum_get)3764 XS(_wrap_Header_partnum_get) {
3765 {
3766 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3767 void *argp1 = 0 ;
3768 int res1 = 0 ;
3769 int argvi = 0;
3770 int result;
3771 dXSARGS;
3772
3773 if ((items < 1) || (items > 1)) {
3774 SWIG_croak("Usage: Header_partnum_get(self);");
3775 }
3776 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3777 if (!SWIG_IsOK(res1)) {
3778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_partnum_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3779 }
3780 arg1 = (dumpfile_t *)(argp1);
3781 result = (int) ((arg1)->partnum);
3782 {
3783 SV *for_stack;
3784 SP += argvi; PUTBACK;
3785 for_stack = sv_2mortal(amglue_newSVi64(result));
3786 SPAGAIN; SP -= argvi;
3787 ST(argvi) = for_stack;
3788 argvi++;
3789 }
3790
3791 XSRETURN(argvi);
3792 fail:
3793
3794 SWIG_croak_null();
3795 }
3796 }
3797
3798
XS(_wrap_Header_totalparts_set)3799 XS(_wrap_Header_totalparts_set) {
3800 {
3801 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3802 int arg2 ;
3803 void *argp1 = 0 ;
3804 int res1 = 0 ;
3805 int argvi = 0;
3806 dXSARGS;
3807
3808 if ((items < 2) || (items > 2)) {
3809 SWIG_croak("Usage: Header_totalparts_set(self,totalparts);");
3810 }
3811 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3812 if (!SWIG_IsOK(res1)) {
3813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_totalparts_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3814 }
3815 arg1 = (dumpfile_t *)(argp1);
3816 {
3817 if (sizeof(signed int) == 1) {
3818 arg2 = amglue_SvI8(ST(1));
3819 } else if (sizeof(signed int) == 2) {
3820 arg2 = amglue_SvI16(ST(1));
3821 } else if (sizeof(signed int) == 4) {
3822 arg2 = amglue_SvI32(ST(1));
3823 } else if (sizeof(signed int) == 8) {
3824 arg2 = amglue_SvI64(ST(1));
3825 } else {
3826 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3827 }
3828 }
3829 if (arg1) (arg1)->totalparts = arg2;
3830 ST(argvi) = sv_newmortal();
3831
3832
3833 XSRETURN(argvi);
3834 fail:
3835
3836
3837 SWIG_croak_null();
3838 }
3839 }
3840
3841
XS(_wrap_Header_totalparts_get)3842 XS(_wrap_Header_totalparts_get) {
3843 {
3844 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3845 void *argp1 = 0 ;
3846 int res1 = 0 ;
3847 int argvi = 0;
3848 int result;
3849 dXSARGS;
3850
3851 if ((items < 1) || (items > 1)) {
3852 SWIG_croak("Usage: Header_totalparts_get(self);");
3853 }
3854 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3855 if (!SWIG_IsOK(res1)) {
3856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_totalparts_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3857 }
3858 arg1 = (dumpfile_t *)(argp1);
3859 result = (int) ((arg1)->totalparts);
3860 {
3861 SV *for_stack;
3862 SP += argvi; PUTBACK;
3863 for_stack = sv_2mortal(amglue_newSVi64(result));
3864 SPAGAIN; SP -= argvi;
3865 ST(argvi) = for_stack;
3866 argvi++;
3867 }
3868
3869 XSRETURN(argvi);
3870 fail:
3871
3872 SWIG_croak_null();
3873 }
3874 }
3875
3876
XS(_wrap_Header_blocksize_set)3877 XS(_wrap_Header_blocksize_set) {
3878 {
3879 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3880 size_t arg2 ;
3881 void *argp1 = 0 ;
3882 int res1 = 0 ;
3883 int argvi = 0;
3884 dXSARGS;
3885
3886 if ((items < 2) || (items > 2)) {
3887 SWIG_croak("Usage: Header_blocksize_set(self,blocksize);");
3888 }
3889 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3890 if (!SWIG_IsOK(res1)) {
3891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_blocksize_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3892 }
3893 arg1 = (dumpfile_t *)(argp1);
3894 {
3895 if (sizeof(size_t) == 1) {
3896 arg2 = amglue_SvU8(ST(1));
3897 } else if (sizeof(size_t) == 2) {
3898 arg2 = amglue_SvU16(ST(1));
3899 } else if (sizeof(size_t) == 4) {
3900 arg2 = amglue_SvU32(ST(1));
3901 } else if (sizeof(size_t) == 8) {
3902 arg2 = amglue_SvU64(ST(1));
3903 } else {
3904 croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
3905 }
3906 }
3907 if (arg1) (arg1)->blocksize = arg2;
3908 ST(argvi) = sv_newmortal();
3909
3910
3911 XSRETURN(argvi);
3912 fail:
3913
3914
3915 SWIG_croak_null();
3916 }
3917 }
3918
3919
XS(_wrap_Header_blocksize_get)3920 XS(_wrap_Header_blocksize_get) {
3921 {
3922 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3923 void *argp1 = 0 ;
3924 int res1 = 0 ;
3925 int argvi = 0;
3926 size_t result;
3927 dXSARGS;
3928
3929 if ((items < 1) || (items > 1)) {
3930 SWIG_croak("Usage: Header_blocksize_get(self);");
3931 }
3932 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3933 if (!SWIG_IsOK(res1)) {
3934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_blocksize_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3935 }
3936 arg1 = (dumpfile_t *)(argp1);
3937 result = ((arg1)->blocksize);
3938 {
3939 SV *for_stack;
3940 SP += argvi; PUTBACK;
3941 for_stack = sv_2mortal(amglue_newSVu64(result));
3942 SPAGAIN; SP -= argvi;
3943 ST(argvi) = for_stack;
3944 argvi++;
3945 }
3946
3947 XSRETURN(argvi);
3948 fail:
3949
3950 SWIG_croak_null();
3951 }
3952 }
3953
3954
XS(_wrap_Header_orig_size_set)3955 XS(_wrap_Header_orig_size_set) {
3956 {
3957 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3958 off_t arg2 ;
3959 void *argp1 = 0 ;
3960 int res1 = 0 ;
3961 int argvi = 0;
3962 dXSARGS;
3963
3964 if ((items < 2) || (items > 2)) {
3965 SWIG_croak("Usage: Header_orig_size_set(self,orig_size);");
3966 }
3967 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3968 if (!SWIG_IsOK(res1)) {
3969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_orig_size_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3970 }
3971 arg1 = (dumpfile_t *)(argp1);
3972 {
3973 if (sizeof(off_t) == 1) {
3974 arg2 = amglue_SvU8(ST(1));
3975 } else if (sizeof(off_t) == 2) {
3976 arg2 = amglue_SvU16(ST(1));
3977 } else if (sizeof(off_t) == 4) {
3978 arg2 = amglue_SvU32(ST(1));
3979 } else if (sizeof(off_t) == 8) {
3980 arg2 = amglue_SvU64(ST(1));
3981 } else {
3982 croak("Unexpected off_t >64 bits?"); /* should be optimized out unless sizeof(off_t) > 8 */
3983 }
3984 }
3985 if (arg1) (arg1)->orig_size = arg2;
3986 ST(argvi) = sv_newmortal();
3987
3988 XSRETURN(argvi);
3989 fail:
3990
3991 SWIG_croak_null();
3992 }
3993 }
3994
3995
XS(_wrap_Header_orig_size_get)3996 XS(_wrap_Header_orig_size_get) {
3997 {
3998 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3999 void *argp1 = 0 ;
4000 int res1 = 0 ;
4001 int argvi = 0;
4002 off_t result;
4003 dXSARGS;
4004
4005 if ((items < 1) || (items > 1)) {
4006 SWIG_croak("Usage: Header_orig_size_get(self);");
4007 }
4008 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
4009 if (!SWIG_IsOK(res1)) {
4010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_orig_size_get" "', argument " "1"" of type '" "dumpfile_t *""'");
4011 }
4012 arg1 = (dumpfile_t *)(argp1);
4013 result = ((arg1)->orig_size);
4014 {
4015 SV *for_stack;
4016 SP += argvi; PUTBACK;
4017 for_stack = sv_2mortal(amglue_newSVu64(result));
4018 SPAGAIN; SP -= argvi;
4019 ST(argvi) = for_stack;
4020 argvi++;
4021 }
4022
4023 XSRETURN(argvi);
4024 fail:
4025
4026 SWIG_croak_null();
4027 }
4028 }
4029
4030
XS(_wrap_new_Header)4031 XS(_wrap_new_Header) {
4032 {
4033 int argvi = 0;
4034 dumpfile_t *result = 0 ;
4035 dXSARGS;
4036
4037 if ((items < 0) || (items > 0)) {
4038 SWIG_croak("Usage: new_Header();");
4039 }
4040 result = (dumpfile_t *)new_dumpfile_t();
4041 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
4042 XSRETURN(argvi);
4043 fail:
4044 SWIG_croak_null();
4045 }
4046 }
4047
4048
XS(_wrap_delete_Header)4049 XS(_wrap_delete_Header) {
4050 {
4051 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4052 void *argp1 = 0 ;
4053 int res1 = 0 ;
4054 int argvi = 0;
4055 dXSARGS;
4056
4057 if ((items < 1) || (items > 1)) {
4058 SWIG_croak("Usage: delete_Header(self);");
4059 }
4060 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, SWIG_POINTER_DISOWN | 0 );
4061 if (!SWIG_IsOK(res1)) {
4062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Header" "', argument " "1"" of type '" "dumpfile_t *""'");
4063 }
4064 arg1 = (dumpfile_t *)(argp1);
4065 delete_dumpfile_t(arg1);
4066 ST(argvi) = sv_newmortal();
4067
4068 XSRETURN(argvi);
4069 fail:
4070
4071 SWIG_croak_null();
4072 }
4073 }
4074
4075
XS(_wrap_Header_to_string)4076 XS(_wrap_Header_to_string) {
4077 {
4078 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4079 size_t arg2 ;
4080 size_t arg3 ;
4081 void *argp1 = 0 ;
4082 int res1 = 0 ;
4083 int argvi = 0;
4084 SV *result = 0 ;
4085 dXSARGS;
4086
4087 if ((items < 3) || (items > 3)) {
4088 SWIG_croak("Usage: Header_to_string(self,min_size,max_size);");
4089 }
4090 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
4091 if (!SWIG_IsOK(res1)) {
4092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_to_string" "', argument " "1"" of type '" "dumpfile_t *""'");
4093 }
4094 arg1 = (dumpfile_t *)(argp1);
4095 {
4096 if (sizeof(size_t) == 1) {
4097 arg2 = amglue_SvU8(ST(1));
4098 } else if (sizeof(size_t) == 2) {
4099 arg2 = amglue_SvU16(ST(1));
4100 } else if (sizeof(size_t) == 4) {
4101 arg2 = amglue_SvU32(ST(1));
4102 } else if (sizeof(size_t) == 8) {
4103 arg2 = amglue_SvU64(ST(1));
4104 } else {
4105 croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
4106 }
4107 }
4108 {
4109 if (sizeof(size_t) == 1) {
4110 arg3 = amglue_SvU8(ST(2));
4111 } else if (sizeof(size_t) == 2) {
4112 arg3 = amglue_SvU16(ST(2));
4113 } else if (sizeof(size_t) == 4) {
4114 arg3 = amglue_SvU32(ST(2));
4115 } else if (sizeof(size_t) == 8) {
4116 arg3 = amglue_SvU64(ST(2));
4117 } else {
4118 croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
4119 }
4120 }
4121 result = (SV *)dumpfile_t_to_string(arg1,arg2,arg3);
4122 ST(argvi) = result; argvi++;
4123
4124
4125
4126 XSRETURN(argvi);
4127 fail:
4128
4129
4130
4131 SWIG_croak_null();
4132 }
4133 }
4134
4135
XS(_wrap_Header_debug_dump)4136 XS(_wrap_Header_debug_dump) {
4137 {
4138 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4139 void *argp1 = 0 ;
4140 int res1 = 0 ;
4141 int argvi = 0;
4142 dXSARGS;
4143
4144 if ((items < 1) || (items > 1)) {
4145 SWIG_croak("Usage: Header_debug_dump(self);");
4146 }
4147 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
4148 if (!SWIG_IsOK(res1)) {
4149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_debug_dump" "', argument " "1"" of type '" "dumpfile_t *""'");
4150 }
4151 arg1 = (dumpfile_t *)(argp1);
4152 dumpfile_t_debug_dump(arg1);
4153 ST(argvi) = sv_newmortal();
4154
4155 XSRETURN(argvi);
4156 fail:
4157
4158 SWIG_croak_null();
4159 }
4160 }
4161
4162
XS(_wrap_Header_summary)4163 XS(_wrap_Header_summary) {
4164 {
4165 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4166 void *argp1 = 0 ;
4167 int res1 = 0 ;
4168 int argvi = 0;
4169 char *result = 0 ;
4170 dXSARGS;
4171
4172 if ((items < 1) || (items > 1)) {
4173 SWIG_croak("Usage: Header_summary(self);");
4174 }
4175 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
4176 if (!SWIG_IsOK(res1)) {
4177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_summary" "', argument " "1"" of type '" "dumpfile_t *""'");
4178 }
4179 arg1 = (dumpfile_t *)(argp1);
4180 result = (char *)dumpfile_t_summary(arg1);
4181 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4182
4183 free((char*)result);
4184 XSRETURN(argvi);
4185 fail:
4186
4187 SWIG_croak_null();
4188 }
4189 }
4190
4191
XS(_wrap_C_from_string)4192 XS(_wrap_C_from_string) {
4193 {
4194 char *arg1 = (char *) 0 ;
4195 int res1 ;
4196 char *buf1 = 0 ;
4197 int alloc1 = 0 ;
4198 int argvi = 0;
4199 dumpfile_t *result = 0 ;
4200 dXSARGS;
4201
4202 if ((items < 1) || (items > 1)) {
4203 SWIG_croak("Usage: C_from_string(string);");
4204 }
4205 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4206 if (!SWIG_IsOK(res1)) {
4207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "C_from_string" "', argument " "1"" of type '" "char const *""'");
4208 }
4209 arg1 = (char *)(buf1);
4210 result = (dumpfile_t *)C_from_string((char const *)arg1);
4211 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, 0 | SWIG_SHADOW); argvi++ ;
4212 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4213 XSRETURN(argvi);
4214 fail:
4215 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4216 SWIG_croak_null();
4217 }
4218 }
4219
4220
XS(_wrap_HeaderXML_disk_set)4221 XS(_wrap_HeaderXML_disk_set) {
4222 {
4223 dle_t *arg1 = (dle_t *) 0 ;
4224 char *arg2 = (char *) 0 ;
4225 void *argp1 = 0 ;
4226 int res1 = 0 ;
4227 int res2 ;
4228 char *buf2 = 0 ;
4229 int alloc2 = 0 ;
4230 int argvi = 0;
4231 dXSARGS;
4232
4233 if ((items < 2) || (items > 2)) {
4234 SWIG_croak("Usage: HeaderXML_disk_set(self,disk);");
4235 }
4236 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4237 if (!SWIG_IsOK(res1)) {
4238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_disk_set" "', argument " "1"" of type '" "dle_t *""'");
4239 }
4240 arg1 = (dle_t *)(argp1);
4241 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
4242 if (!SWIG_IsOK(res2)) {
4243 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_disk_set" "', argument " "2"" of type '" "char *""'");
4244 }
4245 arg2 = (char *)(buf2);
4246 if (arg1->disk) free((char*)arg1->disk);
4247 if (arg2) {
4248 size_t size = strlen((const char *)(arg2)) + 1;
4249 arg1->disk = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4250 } else {
4251 arg1->disk = 0;
4252 }
4253 ST(argvi) = sv_newmortal();
4254
4255 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4256 XSRETURN(argvi);
4257 fail:
4258
4259 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4260 SWIG_croak_null();
4261 }
4262 }
4263
4264
XS(_wrap_HeaderXML_disk_get)4265 XS(_wrap_HeaderXML_disk_get) {
4266 {
4267 dle_t *arg1 = (dle_t *) 0 ;
4268 void *argp1 = 0 ;
4269 int res1 = 0 ;
4270 int argvi = 0;
4271 char *result = 0 ;
4272 dXSARGS;
4273
4274 if ((items < 1) || (items > 1)) {
4275 SWIG_croak("Usage: HeaderXML_disk_get(self);");
4276 }
4277 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4278 if (!SWIG_IsOK(res1)) {
4279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_disk_get" "', argument " "1"" of type '" "dle_t *""'");
4280 }
4281 arg1 = (dle_t *)(argp1);
4282 result = (char *) ((arg1)->disk);
4283 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4284
4285 XSRETURN(argvi);
4286 fail:
4287
4288 SWIG_croak_null();
4289 }
4290 }
4291
4292
XS(_wrap_HeaderXML_device_set)4293 XS(_wrap_HeaderXML_device_set) {
4294 {
4295 dle_t *arg1 = (dle_t *) 0 ;
4296 char *arg2 = (char *) 0 ;
4297 void *argp1 = 0 ;
4298 int res1 = 0 ;
4299 int res2 ;
4300 char *buf2 = 0 ;
4301 int alloc2 = 0 ;
4302 int argvi = 0;
4303 dXSARGS;
4304
4305 if ((items < 2) || (items > 2)) {
4306 SWIG_croak("Usage: HeaderXML_device_set(self,device);");
4307 }
4308 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4309 if (!SWIG_IsOK(res1)) {
4310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_device_set" "', argument " "1"" of type '" "dle_t *""'");
4311 }
4312 arg1 = (dle_t *)(argp1);
4313 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
4314 if (!SWIG_IsOK(res2)) {
4315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_device_set" "', argument " "2"" of type '" "char *""'");
4316 }
4317 arg2 = (char *)(buf2);
4318 if (arg1->device) free((char*)arg1->device);
4319 if (arg2) {
4320 size_t size = strlen((const char *)(arg2)) + 1;
4321 arg1->device = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4322 } else {
4323 arg1->device = 0;
4324 }
4325 ST(argvi) = sv_newmortal();
4326
4327 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4328 XSRETURN(argvi);
4329 fail:
4330
4331 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4332 SWIG_croak_null();
4333 }
4334 }
4335
4336
XS(_wrap_HeaderXML_device_get)4337 XS(_wrap_HeaderXML_device_get) {
4338 {
4339 dle_t *arg1 = (dle_t *) 0 ;
4340 void *argp1 = 0 ;
4341 int res1 = 0 ;
4342 int argvi = 0;
4343 char *result = 0 ;
4344 dXSARGS;
4345
4346 if ((items < 1) || (items > 1)) {
4347 SWIG_croak("Usage: HeaderXML_device_get(self);");
4348 }
4349 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4350 if (!SWIG_IsOK(res1)) {
4351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_device_get" "', argument " "1"" of type '" "dle_t *""'");
4352 }
4353 arg1 = (dle_t *)(argp1);
4354 result = (char *) ((arg1)->device);
4355 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4356
4357 XSRETURN(argvi);
4358 fail:
4359
4360 SWIG_croak_null();
4361 }
4362 }
4363
4364
XS(_wrap_HeaderXML_program_is_application_api_set)4365 XS(_wrap_HeaderXML_program_is_application_api_set) {
4366 {
4367 dle_t *arg1 = (dle_t *) 0 ;
4368 int arg2 ;
4369 void *argp1 = 0 ;
4370 int res1 = 0 ;
4371 int argvi = 0;
4372 dXSARGS;
4373
4374 if ((items < 2) || (items > 2)) {
4375 SWIG_croak("Usage: HeaderXML_program_is_application_api_set(self,program_is_application_api);");
4376 }
4377 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4378 if (!SWIG_IsOK(res1)) {
4379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_program_is_application_api_set" "', argument " "1"" of type '" "dle_t *""'");
4380 }
4381 arg1 = (dle_t *)(argp1);
4382 {
4383 if (sizeof(signed int) == 1) {
4384 arg2 = amglue_SvI8(ST(1));
4385 } else if (sizeof(signed int) == 2) {
4386 arg2 = amglue_SvI16(ST(1));
4387 } else if (sizeof(signed int) == 4) {
4388 arg2 = amglue_SvI32(ST(1));
4389 } else if (sizeof(signed int) == 8) {
4390 arg2 = amglue_SvI64(ST(1));
4391 } else {
4392 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4393 }
4394 }
4395 if (arg1) (arg1)->program_is_application_api = arg2;
4396 ST(argvi) = sv_newmortal();
4397
4398
4399 XSRETURN(argvi);
4400 fail:
4401
4402
4403 SWIG_croak_null();
4404 }
4405 }
4406
4407
XS(_wrap_HeaderXML_program_is_application_api_get)4408 XS(_wrap_HeaderXML_program_is_application_api_get) {
4409 {
4410 dle_t *arg1 = (dle_t *) 0 ;
4411 void *argp1 = 0 ;
4412 int res1 = 0 ;
4413 int argvi = 0;
4414 int result;
4415 dXSARGS;
4416
4417 if ((items < 1) || (items > 1)) {
4418 SWIG_croak("Usage: HeaderXML_program_is_application_api_get(self);");
4419 }
4420 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4421 if (!SWIG_IsOK(res1)) {
4422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_program_is_application_api_get" "', argument " "1"" of type '" "dle_t *""'");
4423 }
4424 arg1 = (dle_t *)(argp1);
4425 result = (int) ((arg1)->program_is_application_api);
4426 {
4427 SV *for_stack;
4428 SP += argvi; PUTBACK;
4429 for_stack = sv_2mortal(amglue_newSVi64(result));
4430 SPAGAIN; SP -= argvi;
4431 ST(argvi) = for_stack;
4432 argvi++;
4433 }
4434
4435 XSRETURN(argvi);
4436 fail:
4437
4438 SWIG_croak_null();
4439 }
4440 }
4441
4442
XS(_wrap_HeaderXML_program_set)4443 XS(_wrap_HeaderXML_program_set) {
4444 {
4445 dle_t *arg1 = (dle_t *) 0 ;
4446 char *arg2 = (char *) 0 ;
4447 void *argp1 = 0 ;
4448 int res1 = 0 ;
4449 int res2 ;
4450 char *buf2 = 0 ;
4451 int alloc2 = 0 ;
4452 int argvi = 0;
4453 dXSARGS;
4454
4455 if ((items < 2) || (items > 2)) {
4456 SWIG_croak("Usage: HeaderXML_program_set(self,program);");
4457 }
4458 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4459 if (!SWIG_IsOK(res1)) {
4460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_program_set" "', argument " "1"" of type '" "dle_t *""'");
4461 }
4462 arg1 = (dle_t *)(argp1);
4463 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
4464 if (!SWIG_IsOK(res2)) {
4465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_program_set" "', argument " "2"" of type '" "char *""'");
4466 }
4467 arg2 = (char *)(buf2);
4468 if (arg1->program) free((char*)arg1->program);
4469 if (arg2) {
4470 size_t size = strlen((const char *)(arg2)) + 1;
4471 arg1->program = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4472 } else {
4473 arg1->program = 0;
4474 }
4475 ST(argvi) = sv_newmortal();
4476
4477 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4478 XSRETURN(argvi);
4479 fail:
4480
4481 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4482 SWIG_croak_null();
4483 }
4484 }
4485
4486
XS(_wrap_HeaderXML_program_get)4487 XS(_wrap_HeaderXML_program_get) {
4488 {
4489 dle_t *arg1 = (dle_t *) 0 ;
4490 void *argp1 = 0 ;
4491 int res1 = 0 ;
4492 int argvi = 0;
4493 char *result = 0 ;
4494 dXSARGS;
4495
4496 if ((items < 1) || (items > 1)) {
4497 SWIG_croak("Usage: HeaderXML_program_get(self);");
4498 }
4499 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4500 if (!SWIG_IsOK(res1)) {
4501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_program_get" "', argument " "1"" of type '" "dle_t *""'");
4502 }
4503 arg1 = (dle_t *)(argp1);
4504 result = (char *) ((arg1)->program);
4505 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4506
4507 XSRETURN(argvi);
4508 fail:
4509
4510 SWIG_croak_null();
4511 }
4512 }
4513
4514
XS(_wrap_HeaderXML_estimatelist_set)4515 XS(_wrap_HeaderXML_estimatelist_set) {
4516 {
4517 dle_t *arg1 = (dle_t *) 0 ;
4518 estimatelist_t arg2 ;
4519 void *argp1 = 0 ;
4520 int res1 = 0 ;
4521 void *argp2 ;
4522 int res2 = 0 ;
4523 int argvi = 0;
4524 dXSARGS;
4525
4526 if ((items < 2) || (items > 2)) {
4527 SWIG_croak("Usage: HeaderXML_estimatelist_set(self,estimatelist);");
4528 }
4529 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4530 if (!SWIG_IsOK(res1)) {
4531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_estimatelist_set" "', argument " "1"" of type '" "dle_t *""'");
4532 }
4533 arg1 = (dle_t *)(argp1);
4534 {
4535 res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_estimatelist_t, 0 );
4536 if (!SWIG_IsOK(res2)) {
4537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_estimatelist_set" "', argument " "2"" of type '" "estimatelist_t""'");
4538 }
4539 if (!argp2) {
4540 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeaderXML_estimatelist_set" "', argument " "2"" of type '" "estimatelist_t""'");
4541 } else {
4542 arg2 = *((estimatelist_t *)(argp2));
4543 }
4544 }
4545 if (arg1) (arg1)->estimatelist = arg2;
4546 ST(argvi) = sv_newmortal();
4547
4548 XSRETURN(argvi);
4549 fail:
4550
4551 SWIG_croak_null();
4552 }
4553 }
4554
4555
XS(_wrap_HeaderXML_estimatelist_get)4556 XS(_wrap_HeaderXML_estimatelist_get) {
4557 {
4558 dle_t *arg1 = (dle_t *) 0 ;
4559 void *argp1 = 0 ;
4560 int res1 = 0 ;
4561 int argvi = 0;
4562 estimatelist_t result;
4563 dXSARGS;
4564
4565 if ((items < 1) || (items > 1)) {
4566 SWIG_croak("Usage: HeaderXML_estimatelist_get(self);");
4567 }
4568 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4569 if (!SWIG_IsOK(res1)) {
4570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_estimatelist_get" "', argument " "1"" of type '" "dle_t *""'");
4571 }
4572 arg1 = (dle_t *)(argp1);
4573 result = ((arg1)->estimatelist);
4574 ST(argvi) = SWIG_NewPointerObj((estimatelist_t *)memcpy((estimatelist_t *)malloc(sizeof(estimatelist_t)),&result,sizeof(estimatelist_t)), SWIGTYPE_p_estimatelist_t, SWIG_POINTER_OWN | 0); argvi++ ;
4575
4576 XSRETURN(argvi);
4577 fail:
4578
4579 SWIG_croak_null();
4580 }
4581 }
4582
4583
XS(_wrap_HeaderXML_spindle_set)4584 XS(_wrap_HeaderXML_spindle_set) {
4585 {
4586 dle_t *arg1 = (dle_t *) 0 ;
4587 int arg2 ;
4588 void *argp1 = 0 ;
4589 int res1 = 0 ;
4590 int argvi = 0;
4591 dXSARGS;
4592
4593 if ((items < 2) || (items > 2)) {
4594 SWIG_croak("Usage: HeaderXML_spindle_set(self,spindle);");
4595 }
4596 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4597 if (!SWIG_IsOK(res1)) {
4598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_spindle_set" "', argument " "1"" of type '" "dle_t *""'");
4599 }
4600 arg1 = (dle_t *)(argp1);
4601 {
4602 if (sizeof(signed int) == 1) {
4603 arg2 = amglue_SvI8(ST(1));
4604 } else if (sizeof(signed int) == 2) {
4605 arg2 = amglue_SvI16(ST(1));
4606 } else if (sizeof(signed int) == 4) {
4607 arg2 = amglue_SvI32(ST(1));
4608 } else if (sizeof(signed int) == 8) {
4609 arg2 = amglue_SvI64(ST(1));
4610 } else {
4611 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4612 }
4613 }
4614 if (arg1) (arg1)->spindle = arg2;
4615 ST(argvi) = sv_newmortal();
4616
4617
4618 XSRETURN(argvi);
4619 fail:
4620
4621
4622 SWIG_croak_null();
4623 }
4624 }
4625
4626
XS(_wrap_HeaderXML_spindle_get)4627 XS(_wrap_HeaderXML_spindle_get) {
4628 {
4629 dle_t *arg1 = (dle_t *) 0 ;
4630 void *argp1 = 0 ;
4631 int res1 = 0 ;
4632 int argvi = 0;
4633 int result;
4634 dXSARGS;
4635
4636 if ((items < 1) || (items > 1)) {
4637 SWIG_croak("Usage: HeaderXML_spindle_get(self);");
4638 }
4639 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4640 if (!SWIG_IsOK(res1)) {
4641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_spindle_get" "', argument " "1"" of type '" "dle_t *""'");
4642 }
4643 arg1 = (dle_t *)(argp1);
4644 result = (int) ((arg1)->spindle);
4645 {
4646 SV *for_stack;
4647 SP += argvi; PUTBACK;
4648 for_stack = sv_2mortal(amglue_newSVi64(result));
4649 SPAGAIN; SP -= argvi;
4650 ST(argvi) = for_stack;
4651 argvi++;
4652 }
4653
4654 XSRETURN(argvi);
4655 fail:
4656
4657 SWIG_croak_null();
4658 }
4659 }
4660
4661
XS(_wrap_HeaderXML_compress_set)4662 XS(_wrap_HeaderXML_compress_set) {
4663 {
4664 dle_t *arg1 = (dle_t *) 0 ;
4665 int arg2 ;
4666 void *argp1 = 0 ;
4667 int res1 = 0 ;
4668 int argvi = 0;
4669 dXSARGS;
4670
4671 if ((items < 2) || (items > 2)) {
4672 SWIG_croak("Usage: HeaderXML_compress_set(self,compress);");
4673 }
4674 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4675 if (!SWIG_IsOK(res1)) {
4676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_compress_set" "', argument " "1"" of type '" "dle_t *""'");
4677 }
4678 arg1 = (dle_t *)(argp1);
4679 {
4680 if (sizeof(signed int) == 1) {
4681 arg2 = amglue_SvI8(ST(1));
4682 } else if (sizeof(signed int) == 2) {
4683 arg2 = amglue_SvI16(ST(1));
4684 } else if (sizeof(signed int) == 4) {
4685 arg2 = amglue_SvI32(ST(1));
4686 } else if (sizeof(signed int) == 8) {
4687 arg2 = amglue_SvI64(ST(1));
4688 } else {
4689 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4690 }
4691 }
4692 if (arg1) (arg1)->compress = arg2;
4693 ST(argvi) = sv_newmortal();
4694
4695
4696 XSRETURN(argvi);
4697 fail:
4698
4699
4700 SWIG_croak_null();
4701 }
4702 }
4703
4704
XS(_wrap_HeaderXML_compress_get)4705 XS(_wrap_HeaderXML_compress_get) {
4706 {
4707 dle_t *arg1 = (dle_t *) 0 ;
4708 void *argp1 = 0 ;
4709 int res1 = 0 ;
4710 int argvi = 0;
4711 int result;
4712 dXSARGS;
4713
4714 if ((items < 1) || (items > 1)) {
4715 SWIG_croak("Usage: HeaderXML_compress_get(self);");
4716 }
4717 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4718 if (!SWIG_IsOK(res1)) {
4719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_compress_get" "', argument " "1"" of type '" "dle_t *""'");
4720 }
4721 arg1 = (dle_t *)(argp1);
4722 result = (int) ((arg1)->compress);
4723 {
4724 SV *for_stack;
4725 SP += argvi; PUTBACK;
4726 for_stack = sv_2mortal(amglue_newSVi64(result));
4727 SPAGAIN; SP -= argvi;
4728 ST(argvi) = for_stack;
4729 argvi++;
4730 }
4731
4732 XSRETURN(argvi);
4733 fail:
4734
4735 SWIG_croak_null();
4736 }
4737 }
4738
4739
XS(_wrap_HeaderXML_encrypt_set)4740 XS(_wrap_HeaderXML_encrypt_set) {
4741 {
4742 dle_t *arg1 = (dle_t *) 0 ;
4743 int arg2 ;
4744 void *argp1 = 0 ;
4745 int res1 = 0 ;
4746 int argvi = 0;
4747 dXSARGS;
4748
4749 if ((items < 2) || (items > 2)) {
4750 SWIG_croak("Usage: HeaderXML_encrypt_set(self,encrypt);");
4751 }
4752 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4753 if (!SWIG_IsOK(res1)) {
4754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_encrypt_set" "', argument " "1"" of type '" "dle_t *""'");
4755 }
4756 arg1 = (dle_t *)(argp1);
4757 {
4758 if (sizeof(signed int) == 1) {
4759 arg2 = amglue_SvI8(ST(1));
4760 } else if (sizeof(signed int) == 2) {
4761 arg2 = amglue_SvI16(ST(1));
4762 } else if (sizeof(signed int) == 4) {
4763 arg2 = amglue_SvI32(ST(1));
4764 } else if (sizeof(signed int) == 8) {
4765 arg2 = amglue_SvI64(ST(1));
4766 } else {
4767 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4768 }
4769 }
4770 if (arg1) (arg1)->encrypt = arg2;
4771 ST(argvi) = sv_newmortal();
4772
4773
4774 XSRETURN(argvi);
4775 fail:
4776
4777
4778 SWIG_croak_null();
4779 }
4780 }
4781
4782
XS(_wrap_HeaderXML_encrypt_get)4783 XS(_wrap_HeaderXML_encrypt_get) {
4784 {
4785 dle_t *arg1 = (dle_t *) 0 ;
4786 void *argp1 = 0 ;
4787 int res1 = 0 ;
4788 int argvi = 0;
4789 int result;
4790 dXSARGS;
4791
4792 if ((items < 1) || (items > 1)) {
4793 SWIG_croak("Usage: HeaderXML_encrypt_get(self);");
4794 }
4795 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4796 if (!SWIG_IsOK(res1)) {
4797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_encrypt_get" "', argument " "1"" of type '" "dle_t *""'");
4798 }
4799 arg1 = (dle_t *)(argp1);
4800 result = (int) ((arg1)->encrypt);
4801 {
4802 SV *for_stack;
4803 SP += argvi; PUTBACK;
4804 for_stack = sv_2mortal(amglue_newSVi64(result));
4805 SPAGAIN; SP -= argvi;
4806 ST(argvi) = for_stack;
4807 argvi++;
4808 }
4809
4810 XSRETURN(argvi);
4811 fail:
4812
4813 SWIG_croak_null();
4814 }
4815 }
4816
4817
XS(_wrap_HeaderXML_kencrypt_set)4818 XS(_wrap_HeaderXML_kencrypt_set) {
4819 {
4820 dle_t *arg1 = (dle_t *) 0 ;
4821 int arg2 ;
4822 void *argp1 = 0 ;
4823 int res1 = 0 ;
4824 int argvi = 0;
4825 dXSARGS;
4826
4827 if ((items < 2) || (items > 2)) {
4828 SWIG_croak("Usage: HeaderXML_kencrypt_set(self,kencrypt);");
4829 }
4830 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4831 if (!SWIG_IsOK(res1)) {
4832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_kencrypt_set" "', argument " "1"" of type '" "dle_t *""'");
4833 }
4834 arg1 = (dle_t *)(argp1);
4835 {
4836 if (sizeof(signed int) == 1) {
4837 arg2 = amglue_SvI8(ST(1));
4838 } else if (sizeof(signed int) == 2) {
4839 arg2 = amglue_SvI16(ST(1));
4840 } else if (sizeof(signed int) == 4) {
4841 arg2 = amglue_SvI32(ST(1));
4842 } else if (sizeof(signed int) == 8) {
4843 arg2 = amglue_SvI64(ST(1));
4844 } else {
4845 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4846 }
4847 }
4848 if (arg1) (arg1)->kencrypt = arg2;
4849 ST(argvi) = sv_newmortal();
4850
4851
4852 XSRETURN(argvi);
4853 fail:
4854
4855
4856 SWIG_croak_null();
4857 }
4858 }
4859
4860
XS(_wrap_HeaderXML_kencrypt_get)4861 XS(_wrap_HeaderXML_kencrypt_get) {
4862 {
4863 dle_t *arg1 = (dle_t *) 0 ;
4864 void *argp1 = 0 ;
4865 int res1 = 0 ;
4866 int argvi = 0;
4867 int result;
4868 dXSARGS;
4869
4870 if ((items < 1) || (items > 1)) {
4871 SWIG_croak("Usage: HeaderXML_kencrypt_get(self);");
4872 }
4873 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4874 if (!SWIG_IsOK(res1)) {
4875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_kencrypt_get" "', argument " "1"" of type '" "dle_t *""'");
4876 }
4877 arg1 = (dle_t *)(argp1);
4878 result = (int) ((arg1)->kencrypt);
4879 {
4880 SV *for_stack;
4881 SP += argvi; PUTBACK;
4882 for_stack = sv_2mortal(amglue_newSVi64(result));
4883 SPAGAIN; SP -= argvi;
4884 ST(argvi) = for_stack;
4885 argvi++;
4886 }
4887
4888 XSRETURN(argvi);
4889 fail:
4890
4891 SWIG_croak_null();
4892 }
4893 }
4894
4895
XS(_wrap_HeaderXML_levellist_set)4896 XS(_wrap_HeaderXML_levellist_set) {
4897 {
4898 dle_t *arg1 = (dle_t *) 0 ;
4899 levellist_t arg2 ;
4900 void *argp1 = 0 ;
4901 int res1 = 0 ;
4902 void *argp2 ;
4903 int res2 = 0 ;
4904 int argvi = 0;
4905 dXSARGS;
4906
4907 if ((items < 2) || (items > 2)) {
4908 SWIG_croak("Usage: HeaderXML_levellist_set(self,levellist);");
4909 }
4910 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4911 if (!SWIG_IsOK(res1)) {
4912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_levellist_set" "', argument " "1"" of type '" "dle_t *""'");
4913 }
4914 arg1 = (dle_t *)(argp1);
4915 {
4916 res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_levellist_t, 0 );
4917 if (!SWIG_IsOK(res2)) {
4918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_levellist_set" "', argument " "2"" of type '" "levellist_t""'");
4919 }
4920 if (!argp2) {
4921 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeaderXML_levellist_set" "', argument " "2"" of type '" "levellist_t""'");
4922 } else {
4923 arg2 = *((levellist_t *)(argp2));
4924 }
4925 }
4926 if (arg1) (arg1)->levellist = arg2;
4927 ST(argvi) = sv_newmortal();
4928
4929 XSRETURN(argvi);
4930 fail:
4931
4932 SWIG_croak_null();
4933 }
4934 }
4935
4936
XS(_wrap_HeaderXML_levellist_get)4937 XS(_wrap_HeaderXML_levellist_get) {
4938 {
4939 dle_t *arg1 = (dle_t *) 0 ;
4940 void *argp1 = 0 ;
4941 int res1 = 0 ;
4942 int argvi = 0;
4943 levellist_t result;
4944 dXSARGS;
4945
4946 if ((items < 1) || (items > 1)) {
4947 SWIG_croak("Usage: HeaderXML_levellist_get(self);");
4948 }
4949 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4950 if (!SWIG_IsOK(res1)) {
4951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_levellist_get" "', argument " "1"" of type '" "dle_t *""'");
4952 }
4953 arg1 = (dle_t *)(argp1);
4954 result = ((arg1)->levellist);
4955 ST(argvi) = SWIG_NewPointerObj((levellist_t *)memcpy((levellist_t *)malloc(sizeof(levellist_t)),&result,sizeof(levellist_t)), SWIGTYPE_p_levellist_t, SWIG_POINTER_OWN | 0); argvi++ ;
4956
4957 XSRETURN(argvi);
4958 fail:
4959
4960 SWIG_croak_null();
4961 }
4962 }
4963
4964
XS(_wrap_HeaderXML_nb_level_set)4965 XS(_wrap_HeaderXML_nb_level_set) {
4966 {
4967 dle_t *arg1 = (dle_t *) 0 ;
4968 int arg2 ;
4969 void *argp1 = 0 ;
4970 int res1 = 0 ;
4971 int argvi = 0;
4972 dXSARGS;
4973
4974 if ((items < 2) || (items > 2)) {
4975 SWIG_croak("Usage: HeaderXML_nb_level_set(self,nb_level);");
4976 }
4977 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
4978 if (!SWIG_IsOK(res1)) {
4979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_nb_level_set" "', argument " "1"" of type '" "dle_t *""'");
4980 }
4981 arg1 = (dle_t *)(argp1);
4982 {
4983 if (sizeof(signed int) == 1) {
4984 arg2 = amglue_SvI8(ST(1));
4985 } else if (sizeof(signed int) == 2) {
4986 arg2 = amglue_SvI16(ST(1));
4987 } else if (sizeof(signed int) == 4) {
4988 arg2 = amglue_SvI32(ST(1));
4989 } else if (sizeof(signed int) == 8) {
4990 arg2 = amglue_SvI64(ST(1));
4991 } else {
4992 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4993 }
4994 }
4995 if (arg1) (arg1)->nb_level = arg2;
4996 ST(argvi) = sv_newmortal();
4997
4998
4999 XSRETURN(argvi);
5000 fail:
5001
5002
5003 SWIG_croak_null();
5004 }
5005 }
5006
5007
XS(_wrap_HeaderXML_nb_level_get)5008 XS(_wrap_HeaderXML_nb_level_get) {
5009 {
5010 dle_t *arg1 = (dle_t *) 0 ;
5011 void *argp1 = 0 ;
5012 int res1 = 0 ;
5013 int argvi = 0;
5014 int result;
5015 dXSARGS;
5016
5017 if ((items < 1) || (items > 1)) {
5018 SWIG_croak("Usage: HeaderXML_nb_level_get(self);");
5019 }
5020 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5021 if (!SWIG_IsOK(res1)) {
5022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_nb_level_get" "', argument " "1"" of type '" "dle_t *""'");
5023 }
5024 arg1 = (dle_t *)(argp1);
5025 result = (int) ((arg1)->nb_level);
5026 {
5027 SV *for_stack;
5028 SP += argvi; PUTBACK;
5029 for_stack = sv_2mortal(amglue_newSVi64(result));
5030 SPAGAIN; SP -= argvi;
5031 ST(argvi) = for_stack;
5032 argvi++;
5033 }
5034
5035 XSRETURN(argvi);
5036 fail:
5037
5038 SWIG_croak_null();
5039 }
5040 }
5041
5042
XS(_wrap_HeaderXML_dumpdate_set)5043 XS(_wrap_HeaderXML_dumpdate_set) {
5044 {
5045 dle_t *arg1 = (dle_t *) 0 ;
5046 char *arg2 = (char *) 0 ;
5047 void *argp1 = 0 ;
5048 int res1 = 0 ;
5049 int res2 ;
5050 char *buf2 = 0 ;
5051 int alloc2 = 0 ;
5052 int argvi = 0;
5053 dXSARGS;
5054
5055 if ((items < 2) || (items > 2)) {
5056 SWIG_croak("Usage: HeaderXML_dumpdate_set(self,dumpdate);");
5057 }
5058 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5059 if (!SWIG_IsOK(res1)) {
5060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_dumpdate_set" "', argument " "1"" of type '" "dle_t *""'");
5061 }
5062 arg1 = (dle_t *)(argp1);
5063 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5064 if (!SWIG_IsOK(res2)) {
5065 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_dumpdate_set" "', argument " "2"" of type '" "char *""'");
5066 }
5067 arg2 = (char *)(buf2);
5068 if (arg1->dumpdate) free((char*)arg1->dumpdate);
5069 if (arg2) {
5070 size_t size = strlen((const char *)(arg2)) + 1;
5071 arg1->dumpdate = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5072 } else {
5073 arg1->dumpdate = 0;
5074 }
5075 ST(argvi) = sv_newmortal();
5076
5077 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5078 XSRETURN(argvi);
5079 fail:
5080
5081 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5082 SWIG_croak_null();
5083 }
5084 }
5085
5086
XS(_wrap_HeaderXML_dumpdate_get)5087 XS(_wrap_HeaderXML_dumpdate_get) {
5088 {
5089 dle_t *arg1 = (dle_t *) 0 ;
5090 void *argp1 = 0 ;
5091 int res1 = 0 ;
5092 int argvi = 0;
5093 char *result = 0 ;
5094 dXSARGS;
5095
5096 if ((items < 1) || (items > 1)) {
5097 SWIG_croak("Usage: HeaderXML_dumpdate_get(self);");
5098 }
5099 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5100 if (!SWIG_IsOK(res1)) {
5101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_dumpdate_get" "', argument " "1"" of type '" "dle_t *""'");
5102 }
5103 arg1 = (dle_t *)(argp1);
5104 result = (char *) ((arg1)->dumpdate);
5105 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5106
5107 XSRETURN(argvi);
5108 fail:
5109
5110 SWIG_croak_null();
5111 }
5112 }
5113
5114
XS(_wrap_HeaderXML_compprog_set)5115 XS(_wrap_HeaderXML_compprog_set) {
5116 {
5117 dle_t *arg1 = (dle_t *) 0 ;
5118 char *arg2 = (char *) 0 ;
5119 void *argp1 = 0 ;
5120 int res1 = 0 ;
5121 int res2 ;
5122 char *buf2 = 0 ;
5123 int alloc2 = 0 ;
5124 int argvi = 0;
5125 dXSARGS;
5126
5127 if ((items < 2) || (items > 2)) {
5128 SWIG_croak("Usage: HeaderXML_compprog_set(self,compprog);");
5129 }
5130 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5131 if (!SWIG_IsOK(res1)) {
5132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_compprog_set" "', argument " "1"" of type '" "dle_t *""'");
5133 }
5134 arg1 = (dle_t *)(argp1);
5135 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5136 if (!SWIG_IsOK(res2)) {
5137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_compprog_set" "', argument " "2"" of type '" "char *""'");
5138 }
5139 arg2 = (char *)(buf2);
5140 if (arg1->compprog) free((char*)arg1->compprog);
5141 if (arg2) {
5142 size_t size = strlen((const char *)(arg2)) + 1;
5143 arg1->compprog = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5144 } else {
5145 arg1->compprog = 0;
5146 }
5147 ST(argvi) = sv_newmortal();
5148
5149 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5150 XSRETURN(argvi);
5151 fail:
5152
5153 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5154 SWIG_croak_null();
5155 }
5156 }
5157
5158
XS(_wrap_HeaderXML_compprog_get)5159 XS(_wrap_HeaderXML_compprog_get) {
5160 {
5161 dle_t *arg1 = (dle_t *) 0 ;
5162 void *argp1 = 0 ;
5163 int res1 = 0 ;
5164 int argvi = 0;
5165 char *result = 0 ;
5166 dXSARGS;
5167
5168 if ((items < 1) || (items > 1)) {
5169 SWIG_croak("Usage: HeaderXML_compprog_get(self);");
5170 }
5171 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5172 if (!SWIG_IsOK(res1)) {
5173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_compprog_get" "', argument " "1"" of type '" "dle_t *""'");
5174 }
5175 arg1 = (dle_t *)(argp1);
5176 result = (char *) ((arg1)->compprog);
5177 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5178
5179 XSRETURN(argvi);
5180 fail:
5181
5182 SWIG_croak_null();
5183 }
5184 }
5185
5186
XS(_wrap_HeaderXML_srv_encrypt_set)5187 XS(_wrap_HeaderXML_srv_encrypt_set) {
5188 {
5189 dle_t *arg1 = (dle_t *) 0 ;
5190 char *arg2 = (char *) 0 ;
5191 void *argp1 = 0 ;
5192 int res1 = 0 ;
5193 int res2 ;
5194 char *buf2 = 0 ;
5195 int alloc2 = 0 ;
5196 int argvi = 0;
5197 dXSARGS;
5198
5199 if ((items < 2) || (items > 2)) {
5200 SWIG_croak("Usage: HeaderXML_srv_encrypt_set(self,srv_encrypt);");
5201 }
5202 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5203 if (!SWIG_IsOK(res1)) {
5204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_srv_encrypt_set" "', argument " "1"" of type '" "dle_t *""'");
5205 }
5206 arg1 = (dle_t *)(argp1);
5207 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5208 if (!SWIG_IsOK(res2)) {
5209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_srv_encrypt_set" "', argument " "2"" of type '" "char *""'");
5210 }
5211 arg2 = (char *)(buf2);
5212 if (arg1->srv_encrypt) free((char*)arg1->srv_encrypt);
5213 if (arg2) {
5214 size_t size = strlen((const char *)(arg2)) + 1;
5215 arg1->srv_encrypt = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5216 } else {
5217 arg1->srv_encrypt = 0;
5218 }
5219 ST(argvi) = sv_newmortal();
5220
5221 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5222 XSRETURN(argvi);
5223 fail:
5224
5225 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5226 SWIG_croak_null();
5227 }
5228 }
5229
5230
XS(_wrap_HeaderXML_srv_encrypt_get)5231 XS(_wrap_HeaderXML_srv_encrypt_get) {
5232 {
5233 dle_t *arg1 = (dle_t *) 0 ;
5234 void *argp1 = 0 ;
5235 int res1 = 0 ;
5236 int argvi = 0;
5237 char *result = 0 ;
5238 dXSARGS;
5239
5240 if ((items < 1) || (items > 1)) {
5241 SWIG_croak("Usage: HeaderXML_srv_encrypt_get(self);");
5242 }
5243 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5244 if (!SWIG_IsOK(res1)) {
5245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_srv_encrypt_get" "', argument " "1"" of type '" "dle_t *""'");
5246 }
5247 arg1 = (dle_t *)(argp1);
5248 result = (char *) ((arg1)->srv_encrypt);
5249 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5250
5251 XSRETURN(argvi);
5252 fail:
5253
5254 SWIG_croak_null();
5255 }
5256 }
5257
5258
XS(_wrap_HeaderXML_clnt_encrypt_set)5259 XS(_wrap_HeaderXML_clnt_encrypt_set) {
5260 {
5261 dle_t *arg1 = (dle_t *) 0 ;
5262 char *arg2 = (char *) 0 ;
5263 void *argp1 = 0 ;
5264 int res1 = 0 ;
5265 int res2 ;
5266 char *buf2 = 0 ;
5267 int alloc2 = 0 ;
5268 int argvi = 0;
5269 dXSARGS;
5270
5271 if ((items < 2) || (items > 2)) {
5272 SWIG_croak("Usage: HeaderXML_clnt_encrypt_set(self,clnt_encrypt);");
5273 }
5274 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5275 if (!SWIG_IsOK(res1)) {
5276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_clnt_encrypt_set" "', argument " "1"" of type '" "dle_t *""'");
5277 }
5278 arg1 = (dle_t *)(argp1);
5279 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5280 if (!SWIG_IsOK(res2)) {
5281 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_clnt_encrypt_set" "', argument " "2"" of type '" "char *""'");
5282 }
5283 arg2 = (char *)(buf2);
5284 if (arg1->clnt_encrypt) free((char*)arg1->clnt_encrypt);
5285 if (arg2) {
5286 size_t size = strlen((const char *)(arg2)) + 1;
5287 arg1->clnt_encrypt = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5288 } else {
5289 arg1->clnt_encrypt = 0;
5290 }
5291 ST(argvi) = sv_newmortal();
5292
5293 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5294 XSRETURN(argvi);
5295 fail:
5296
5297 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5298 SWIG_croak_null();
5299 }
5300 }
5301
5302
XS(_wrap_HeaderXML_clnt_encrypt_get)5303 XS(_wrap_HeaderXML_clnt_encrypt_get) {
5304 {
5305 dle_t *arg1 = (dle_t *) 0 ;
5306 void *argp1 = 0 ;
5307 int res1 = 0 ;
5308 int argvi = 0;
5309 char *result = 0 ;
5310 dXSARGS;
5311
5312 if ((items < 1) || (items > 1)) {
5313 SWIG_croak("Usage: HeaderXML_clnt_encrypt_get(self);");
5314 }
5315 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5316 if (!SWIG_IsOK(res1)) {
5317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_clnt_encrypt_get" "', argument " "1"" of type '" "dle_t *""'");
5318 }
5319 arg1 = (dle_t *)(argp1);
5320 result = (char *) ((arg1)->clnt_encrypt);
5321 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5322
5323 XSRETURN(argvi);
5324 fail:
5325
5326 SWIG_croak_null();
5327 }
5328 }
5329
5330
XS(_wrap_HeaderXML_srv_decrypt_opt_set)5331 XS(_wrap_HeaderXML_srv_decrypt_opt_set) {
5332 {
5333 dle_t *arg1 = (dle_t *) 0 ;
5334 char *arg2 = (char *) 0 ;
5335 void *argp1 = 0 ;
5336 int res1 = 0 ;
5337 int res2 ;
5338 char *buf2 = 0 ;
5339 int alloc2 = 0 ;
5340 int argvi = 0;
5341 dXSARGS;
5342
5343 if ((items < 2) || (items > 2)) {
5344 SWIG_croak("Usage: HeaderXML_srv_decrypt_opt_set(self,srv_decrypt_opt);");
5345 }
5346 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5347 if (!SWIG_IsOK(res1)) {
5348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_srv_decrypt_opt_set" "', argument " "1"" of type '" "dle_t *""'");
5349 }
5350 arg1 = (dle_t *)(argp1);
5351 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5352 if (!SWIG_IsOK(res2)) {
5353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_srv_decrypt_opt_set" "', argument " "2"" of type '" "char *""'");
5354 }
5355 arg2 = (char *)(buf2);
5356 if (arg1->srv_decrypt_opt) free((char*)arg1->srv_decrypt_opt);
5357 if (arg2) {
5358 size_t size = strlen((const char *)(arg2)) + 1;
5359 arg1->srv_decrypt_opt = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5360 } else {
5361 arg1->srv_decrypt_opt = 0;
5362 }
5363 ST(argvi) = sv_newmortal();
5364
5365 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5366 XSRETURN(argvi);
5367 fail:
5368
5369 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5370 SWIG_croak_null();
5371 }
5372 }
5373
5374
XS(_wrap_HeaderXML_srv_decrypt_opt_get)5375 XS(_wrap_HeaderXML_srv_decrypt_opt_get) {
5376 {
5377 dle_t *arg1 = (dle_t *) 0 ;
5378 void *argp1 = 0 ;
5379 int res1 = 0 ;
5380 int argvi = 0;
5381 char *result = 0 ;
5382 dXSARGS;
5383
5384 if ((items < 1) || (items > 1)) {
5385 SWIG_croak("Usage: HeaderXML_srv_decrypt_opt_get(self);");
5386 }
5387 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5388 if (!SWIG_IsOK(res1)) {
5389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_srv_decrypt_opt_get" "', argument " "1"" of type '" "dle_t *""'");
5390 }
5391 arg1 = (dle_t *)(argp1);
5392 result = (char *) ((arg1)->srv_decrypt_opt);
5393 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5394
5395 XSRETURN(argvi);
5396 fail:
5397
5398 SWIG_croak_null();
5399 }
5400 }
5401
5402
XS(_wrap_HeaderXML_clnt_decrypt_opt_set)5403 XS(_wrap_HeaderXML_clnt_decrypt_opt_set) {
5404 {
5405 dle_t *arg1 = (dle_t *) 0 ;
5406 char *arg2 = (char *) 0 ;
5407 void *argp1 = 0 ;
5408 int res1 = 0 ;
5409 int res2 ;
5410 char *buf2 = 0 ;
5411 int alloc2 = 0 ;
5412 int argvi = 0;
5413 dXSARGS;
5414
5415 if ((items < 2) || (items > 2)) {
5416 SWIG_croak("Usage: HeaderXML_clnt_decrypt_opt_set(self,clnt_decrypt_opt);");
5417 }
5418 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5419 if (!SWIG_IsOK(res1)) {
5420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_clnt_decrypt_opt_set" "', argument " "1"" of type '" "dle_t *""'");
5421 }
5422 arg1 = (dle_t *)(argp1);
5423 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5424 if (!SWIG_IsOK(res2)) {
5425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_clnt_decrypt_opt_set" "', argument " "2"" of type '" "char *""'");
5426 }
5427 arg2 = (char *)(buf2);
5428 if (arg1->clnt_decrypt_opt) free((char*)arg1->clnt_decrypt_opt);
5429 if (arg2) {
5430 size_t size = strlen((const char *)(arg2)) + 1;
5431 arg1->clnt_decrypt_opt = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5432 } else {
5433 arg1->clnt_decrypt_opt = 0;
5434 }
5435 ST(argvi) = sv_newmortal();
5436
5437 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5438 XSRETURN(argvi);
5439 fail:
5440
5441 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5442 SWIG_croak_null();
5443 }
5444 }
5445
5446
XS(_wrap_HeaderXML_clnt_decrypt_opt_get)5447 XS(_wrap_HeaderXML_clnt_decrypt_opt_get) {
5448 {
5449 dle_t *arg1 = (dle_t *) 0 ;
5450 void *argp1 = 0 ;
5451 int res1 = 0 ;
5452 int argvi = 0;
5453 char *result = 0 ;
5454 dXSARGS;
5455
5456 if ((items < 1) || (items > 1)) {
5457 SWIG_croak("Usage: HeaderXML_clnt_decrypt_opt_get(self);");
5458 }
5459 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_clnt_decrypt_opt_get" "', argument " "1"" of type '" "dle_t *""'");
5462 }
5463 arg1 = (dle_t *)(argp1);
5464 result = (char *) ((arg1)->clnt_decrypt_opt);
5465 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5466
5467 XSRETURN(argvi);
5468 fail:
5469
5470 SWIG_croak_null();
5471 }
5472 }
5473
5474
XS(_wrap_HeaderXML_record_set)5475 XS(_wrap_HeaderXML_record_set) {
5476 {
5477 dle_t *arg1 = (dle_t *) 0 ;
5478 int arg2 ;
5479 void *argp1 = 0 ;
5480 int res1 = 0 ;
5481 int argvi = 0;
5482 dXSARGS;
5483
5484 if ((items < 2) || (items > 2)) {
5485 SWIG_croak("Usage: HeaderXML_record_set(self,record);");
5486 }
5487 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5488 if (!SWIG_IsOK(res1)) {
5489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_record_set" "', argument " "1"" of type '" "dle_t *""'");
5490 }
5491 arg1 = (dle_t *)(argp1);
5492 {
5493 if (sizeof(signed int) == 1) {
5494 arg2 = amglue_SvI8(ST(1));
5495 } else if (sizeof(signed int) == 2) {
5496 arg2 = amglue_SvI16(ST(1));
5497 } else if (sizeof(signed int) == 4) {
5498 arg2 = amglue_SvI32(ST(1));
5499 } else if (sizeof(signed int) == 8) {
5500 arg2 = amglue_SvI64(ST(1));
5501 } else {
5502 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5503 }
5504 }
5505 if (arg1) (arg1)->record = arg2;
5506 ST(argvi) = sv_newmortal();
5507
5508
5509 XSRETURN(argvi);
5510 fail:
5511
5512
5513 SWIG_croak_null();
5514 }
5515 }
5516
5517
XS(_wrap_HeaderXML_record_get)5518 XS(_wrap_HeaderXML_record_get) {
5519 {
5520 dle_t *arg1 = (dle_t *) 0 ;
5521 void *argp1 = 0 ;
5522 int res1 = 0 ;
5523 int argvi = 0;
5524 int result;
5525 dXSARGS;
5526
5527 if ((items < 1) || (items > 1)) {
5528 SWIG_croak("Usage: HeaderXML_record_get(self);");
5529 }
5530 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5531 if (!SWIG_IsOK(res1)) {
5532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_record_get" "', argument " "1"" of type '" "dle_t *""'");
5533 }
5534 arg1 = (dle_t *)(argp1);
5535 result = (int) ((arg1)->record);
5536 {
5537 SV *for_stack;
5538 SP += argvi; PUTBACK;
5539 for_stack = sv_2mortal(amglue_newSVi64(result));
5540 SPAGAIN; SP -= argvi;
5541 ST(argvi) = for_stack;
5542 argvi++;
5543 }
5544
5545 XSRETURN(argvi);
5546 fail:
5547
5548 SWIG_croak_null();
5549 }
5550 }
5551
5552
XS(_wrap_HeaderXML_create_index_set)5553 XS(_wrap_HeaderXML_create_index_set) {
5554 {
5555 dle_t *arg1 = (dle_t *) 0 ;
5556 int arg2 ;
5557 void *argp1 = 0 ;
5558 int res1 = 0 ;
5559 int argvi = 0;
5560 dXSARGS;
5561
5562 if ((items < 2) || (items > 2)) {
5563 SWIG_croak("Usage: HeaderXML_create_index_set(self,create_index);");
5564 }
5565 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5566 if (!SWIG_IsOK(res1)) {
5567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_create_index_set" "', argument " "1"" of type '" "dle_t *""'");
5568 }
5569 arg1 = (dle_t *)(argp1);
5570 {
5571 if (sizeof(signed int) == 1) {
5572 arg2 = amglue_SvI8(ST(1));
5573 } else if (sizeof(signed int) == 2) {
5574 arg2 = amglue_SvI16(ST(1));
5575 } else if (sizeof(signed int) == 4) {
5576 arg2 = amglue_SvI32(ST(1));
5577 } else if (sizeof(signed int) == 8) {
5578 arg2 = amglue_SvI64(ST(1));
5579 } else {
5580 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5581 }
5582 }
5583 if (arg1) (arg1)->create_index = arg2;
5584 ST(argvi) = sv_newmortal();
5585
5586
5587 XSRETURN(argvi);
5588 fail:
5589
5590
5591 SWIG_croak_null();
5592 }
5593 }
5594
5595
XS(_wrap_HeaderXML_create_index_get)5596 XS(_wrap_HeaderXML_create_index_get) {
5597 {
5598 dle_t *arg1 = (dle_t *) 0 ;
5599 void *argp1 = 0 ;
5600 int res1 = 0 ;
5601 int argvi = 0;
5602 int result;
5603 dXSARGS;
5604
5605 if ((items < 1) || (items > 1)) {
5606 SWIG_croak("Usage: HeaderXML_create_index_get(self);");
5607 }
5608 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5609 if (!SWIG_IsOK(res1)) {
5610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_create_index_get" "', argument " "1"" of type '" "dle_t *""'");
5611 }
5612 arg1 = (dle_t *)(argp1);
5613 result = (int) ((arg1)->create_index);
5614 {
5615 SV *for_stack;
5616 SP += argvi; PUTBACK;
5617 for_stack = sv_2mortal(amglue_newSVi64(result));
5618 SPAGAIN; SP -= argvi;
5619 ST(argvi) = for_stack;
5620 argvi++;
5621 }
5622
5623 XSRETURN(argvi);
5624 fail:
5625
5626 SWIG_croak_null();
5627 }
5628 }
5629
5630
XS(_wrap_HeaderXML_auth_set)5631 XS(_wrap_HeaderXML_auth_set) {
5632 {
5633 dle_t *arg1 = (dle_t *) 0 ;
5634 char *arg2 = (char *) 0 ;
5635 void *argp1 = 0 ;
5636 int res1 = 0 ;
5637 int res2 ;
5638 char *buf2 = 0 ;
5639 int alloc2 = 0 ;
5640 int argvi = 0;
5641 dXSARGS;
5642
5643 if ((items < 2) || (items > 2)) {
5644 SWIG_croak("Usage: HeaderXML_auth_set(self,auth);");
5645 }
5646 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5647 if (!SWIG_IsOK(res1)) {
5648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_auth_set" "', argument " "1"" of type '" "dle_t *""'");
5649 }
5650 arg1 = (dle_t *)(argp1);
5651 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
5652 if (!SWIG_IsOK(res2)) {
5653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_auth_set" "', argument " "2"" of type '" "char *""'");
5654 }
5655 arg2 = (char *)(buf2);
5656 if (arg1->auth) free((char*)arg1->auth);
5657 if (arg2) {
5658 size_t size = strlen((const char *)(arg2)) + 1;
5659 arg1->auth = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5660 } else {
5661 arg1->auth = 0;
5662 }
5663 ST(argvi) = sv_newmortal();
5664
5665 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5666 XSRETURN(argvi);
5667 fail:
5668
5669 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5670 SWIG_croak_null();
5671 }
5672 }
5673
5674
XS(_wrap_HeaderXML_auth_get)5675 XS(_wrap_HeaderXML_auth_get) {
5676 {
5677 dle_t *arg1 = (dle_t *) 0 ;
5678 void *argp1 = 0 ;
5679 int res1 = 0 ;
5680 int argvi = 0;
5681 char *result = 0 ;
5682 dXSARGS;
5683
5684 if ((items < 1) || (items > 1)) {
5685 SWIG_croak("Usage: HeaderXML_auth_get(self);");
5686 }
5687 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5688 if (!SWIG_IsOK(res1)) {
5689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_auth_get" "', argument " "1"" of type '" "dle_t *""'");
5690 }
5691 arg1 = (dle_t *)(argp1);
5692 result = (char *) ((arg1)->auth);
5693 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
5694
5695 XSRETURN(argvi);
5696 fail:
5697
5698 SWIG_croak_null();
5699 }
5700 }
5701
5702
XS(_wrap_HeaderXML_exclude_file_set)5703 XS(_wrap_HeaderXML_exclude_file_set) {
5704 {
5705 dle_t *arg1 = (dle_t *) 0 ;
5706 am_sl_t *arg2 = (am_sl_t *) 0 ;
5707 void *argp1 = 0 ;
5708 int res1 = 0 ;
5709 void *argp2 = 0 ;
5710 int res2 = 0 ;
5711 int argvi = 0;
5712 dXSARGS;
5713
5714 if ((items < 2) || (items > 2)) {
5715 SWIG_croak("Usage: HeaderXML_exclude_file_set(self,exclude_file);");
5716 }
5717 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5718 if (!SWIG_IsOK(res1)) {
5719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_file_set" "', argument " "1"" of type '" "dle_t *""'");
5720 }
5721 arg1 = (dle_t *)(argp1);
5722 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_am_sl_t, SWIG_POINTER_DISOWN | 0 );
5723 if (!SWIG_IsOK(res2)) {
5724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_exclude_file_set" "', argument " "2"" of type '" "am_sl_t *""'");
5725 }
5726 arg2 = (am_sl_t *)(argp2);
5727 if (arg1) (arg1)->exclude_file = arg2;
5728 ST(argvi) = sv_newmortal();
5729
5730
5731 XSRETURN(argvi);
5732 fail:
5733
5734
5735 SWIG_croak_null();
5736 }
5737 }
5738
5739
XS(_wrap_HeaderXML_exclude_file_get)5740 XS(_wrap_HeaderXML_exclude_file_get) {
5741 {
5742 dle_t *arg1 = (dle_t *) 0 ;
5743 void *argp1 = 0 ;
5744 int res1 = 0 ;
5745 int argvi = 0;
5746 am_sl_t *result = 0 ;
5747 dXSARGS;
5748
5749 if ((items < 1) || (items > 1)) {
5750 SWIG_croak("Usage: HeaderXML_exclude_file_get(self);");
5751 }
5752 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5753 if (!SWIG_IsOK(res1)) {
5754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_file_get" "', argument " "1"" of type '" "dle_t *""'");
5755 }
5756 arg1 = (dle_t *)(argp1);
5757 result = (am_sl_t *) ((arg1)->exclude_file);
5758 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_am_sl_t, 0 | 0); argvi++ ;
5759
5760 XSRETURN(argvi);
5761 fail:
5762
5763 SWIG_croak_null();
5764 }
5765 }
5766
5767
XS(_wrap_HeaderXML_exclude_list_set)5768 XS(_wrap_HeaderXML_exclude_list_set) {
5769 {
5770 dle_t *arg1 = (dle_t *) 0 ;
5771 am_sl_t *arg2 = (am_sl_t *) 0 ;
5772 void *argp1 = 0 ;
5773 int res1 = 0 ;
5774 void *argp2 = 0 ;
5775 int res2 = 0 ;
5776 int argvi = 0;
5777 dXSARGS;
5778
5779 if ((items < 2) || (items > 2)) {
5780 SWIG_croak("Usage: HeaderXML_exclude_list_set(self,exclude_list);");
5781 }
5782 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5783 if (!SWIG_IsOK(res1)) {
5784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_list_set" "', argument " "1"" of type '" "dle_t *""'");
5785 }
5786 arg1 = (dle_t *)(argp1);
5787 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_am_sl_t, SWIG_POINTER_DISOWN | 0 );
5788 if (!SWIG_IsOK(res2)) {
5789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_exclude_list_set" "', argument " "2"" of type '" "am_sl_t *""'");
5790 }
5791 arg2 = (am_sl_t *)(argp2);
5792 if (arg1) (arg1)->exclude_list = arg2;
5793 ST(argvi) = sv_newmortal();
5794
5795
5796 XSRETURN(argvi);
5797 fail:
5798
5799
5800 SWIG_croak_null();
5801 }
5802 }
5803
5804
XS(_wrap_HeaderXML_exclude_list_get)5805 XS(_wrap_HeaderXML_exclude_list_get) {
5806 {
5807 dle_t *arg1 = (dle_t *) 0 ;
5808 void *argp1 = 0 ;
5809 int res1 = 0 ;
5810 int argvi = 0;
5811 am_sl_t *result = 0 ;
5812 dXSARGS;
5813
5814 if ((items < 1) || (items > 1)) {
5815 SWIG_croak("Usage: HeaderXML_exclude_list_get(self);");
5816 }
5817 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5818 if (!SWIG_IsOK(res1)) {
5819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_list_get" "', argument " "1"" of type '" "dle_t *""'");
5820 }
5821 arg1 = (dle_t *)(argp1);
5822 result = (am_sl_t *) ((arg1)->exclude_list);
5823 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_am_sl_t, 0 | 0); argvi++ ;
5824
5825 XSRETURN(argvi);
5826 fail:
5827
5828 SWIG_croak_null();
5829 }
5830 }
5831
5832
XS(_wrap_HeaderXML_include_file_set)5833 XS(_wrap_HeaderXML_include_file_set) {
5834 {
5835 dle_t *arg1 = (dle_t *) 0 ;
5836 am_sl_t *arg2 = (am_sl_t *) 0 ;
5837 void *argp1 = 0 ;
5838 int res1 = 0 ;
5839 void *argp2 = 0 ;
5840 int res2 = 0 ;
5841 int argvi = 0;
5842 dXSARGS;
5843
5844 if ((items < 2) || (items > 2)) {
5845 SWIG_croak("Usage: HeaderXML_include_file_set(self,include_file);");
5846 }
5847 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5848 if (!SWIG_IsOK(res1)) {
5849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_file_set" "', argument " "1"" of type '" "dle_t *""'");
5850 }
5851 arg1 = (dle_t *)(argp1);
5852 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_am_sl_t, SWIG_POINTER_DISOWN | 0 );
5853 if (!SWIG_IsOK(res2)) {
5854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_include_file_set" "', argument " "2"" of type '" "am_sl_t *""'");
5855 }
5856 arg2 = (am_sl_t *)(argp2);
5857 if (arg1) (arg1)->include_file = arg2;
5858 ST(argvi) = sv_newmortal();
5859
5860
5861 XSRETURN(argvi);
5862 fail:
5863
5864
5865 SWIG_croak_null();
5866 }
5867 }
5868
5869
XS(_wrap_HeaderXML_include_file_get)5870 XS(_wrap_HeaderXML_include_file_get) {
5871 {
5872 dle_t *arg1 = (dle_t *) 0 ;
5873 void *argp1 = 0 ;
5874 int res1 = 0 ;
5875 int argvi = 0;
5876 am_sl_t *result = 0 ;
5877 dXSARGS;
5878
5879 if ((items < 1) || (items > 1)) {
5880 SWIG_croak("Usage: HeaderXML_include_file_get(self);");
5881 }
5882 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5883 if (!SWIG_IsOK(res1)) {
5884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_file_get" "', argument " "1"" of type '" "dle_t *""'");
5885 }
5886 arg1 = (dle_t *)(argp1);
5887 result = (am_sl_t *) ((arg1)->include_file);
5888 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_am_sl_t, 0 | 0); argvi++ ;
5889
5890 XSRETURN(argvi);
5891 fail:
5892
5893 SWIG_croak_null();
5894 }
5895 }
5896
5897
XS(_wrap_HeaderXML_include_list_set)5898 XS(_wrap_HeaderXML_include_list_set) {
5899 {
5900 dle_t *arg1 = (dle_t *) 0 ;
5901 am_sl_t *arg2 = (am_sl_t *) 0 ;
5902 void *argp1 = 0 ;
5903 int res1 = 0 ;
5904 void *argp2 = 0 ;
5905 int res2 = 0 ;
5906 int argvi = 0;
5907 dXSARGS;
5908
5909 if ((items < 2) || (items > 2)) {
5910 SWIG_croak("Usage: HeaderXML_include_list_set(self,include_list);");
5911 }
5912 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5913 if (!SWIG_IsOK(res1)) {
5914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_list_set" "', argument " "1"" of type '" "dle_t *""'");
5915 }
5916 arg1 = (dle_t *)(argp1);
5917 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_am_sl_t, SWIG_POINTER_DISOWN | 0 );
5918 if (!SWIG_IsOK(res2)) {
5919 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_include_list_set" "', argument " "2"" of type '" "am_sl_t *""'");
5920 }
5921 arg2 = (am_sl_t *)(argp2);
5922 if (arg1) (arg1)->include_list = arg2;
5923 ST(argvi) = sv_newmortal();
5924
5925
5926 XSRETURN(argvi);
5927 fail:
5928
5929
5930 SWIG_croak_null();
5931 }
5932 }
5933
5934
XS(_wrap_HeaderXML_include_list_get)5935 XS(_wrap_HeaderXML_include_list_get) {
5936 {
5937 dle_t *arg1 = (dle_t *) 0 ;
5938 void *argp1 = 0 ;
5939 int res1 = 0 ;
5940 int argvi = 0;
5941 am_sl_t *result = 0 ;
5942 dXSARGS;
5943
5944 if ((items < 1) || (items > 1)) {
5945 SWIG_croak("Usage: HeaderXML_include_list_get(self);");
5946 }
5947 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5948 if (!SWIG_IsOK(res1)) {
5949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_list_get" "', argument " "1"" of type '" "dle_t *""'");
5950 }
5951 arg1 = (dle_t *)(argp1);
5952 result = (am_sl_t *) ((arg1)->include_list);
5953 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_am_sl_t, 0 | 0); argvi++ ;
5954
5955 XSRETURN(argvi);
5956 fail:
5957
5958 SWIG_croak_null();
5959 }
5960 }
5961
5962
XS(_wrap_HeaderXML_exclude_optional_set)5963 XS(_wrap_HeaderXML_exclude_optional_set) {
5964 {
5965 dle_t *arg1 = (dle_t *) 0 ;
5966 int arg2 ;
5967 void *argp1 = 0 ;
5968 int res1 = 0 ;
5969 int argvi = 0;
5970 dXSARGS;
5971
5972 if ((items < 2) || (items > 2)) {
5973 SWIG_croak("Usage: HeaderXML_exclude_optional_set(self,exclude_optional);");
5974 }
5975 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
5976 if (!SWIG_IsOK(res1)) {
5977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_optional_set" "', argument " "1"" of type '" "dle_t *""'");
5978 }
5979 arg1 = (dle_t *)(argp1);
5980 {
5981 if (sizeof(signed int) == 1) {
5982 arg2 = amglue_SvI8(ST(1));
5983 } else if (sizeof(signed int) == 2) {
5984 arg2 = amglue_SvI16(ST(1));
5985 } else if (sizeof(signed int) == 4) {
5986 arg2 = amglue_SvI32(ST(1));
5987 } else if (sizeof(signed int) == 8) {
5988 arg2 = amglue_SvI64(ST(1));
5989 } else {
5990 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
5991 }
5992 }
5993 if (arg1) (arg1)->exclude_optional = arg2;
5994 ST(argvi) = sv_newmortal();
5995
5996
5997 XSRETURN(argvi);
5998 fail:
5999
6000
6001 SWIG_croak_null();
6002 }
6003 }
6004
6005
XS(_wrap_HeaderXML_exclude_optional_get)6006 XS(_wrap_HeaderXML_exclude_optional_get) {
6007 {
6008 dle_t *arg1 = (dle_t *) 0 ;
6009 void *argp1 = 0 ;
6010 int res1 = 0 ;
6011 int argvi = 0;
6012 int result;
6013 dXSARGS;
6014
6015 if ((items < 1) || (items > 1)) {
6016 SWIG_croak("Usage: HeaderXML_exclude_optional_get(self);");
6017 }
6018 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6019 if (!SWIG_IsOK(res1)) {
6020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_exclude_optional_get" "', argument " "1"" of type '" "dle_t *""'");
6021 }
6022 arg1 = (dle_t *)(argp1);
6023 result = (int) ((arg1)->exclude_optional);
6024 {
6025 SV *for_stack;
6026 SP += argvi; PUTBACK;
6027 for_stack = sv_2mortal(amglue_newSVi64(result));
6028 SPAGAIN; SP -= argvi;
6029 ST(argvi) = for_stack;
6030 argvi++;
6031 }
6032
6033 XSRETURN(argvi);
6034 fail:
6035
6036 SWIG_croak_null();
6037 }
6038 }
6039
6040
XS(_wrap_HeaderXML_include_optional_set)6041 XS(_wrap_HeaderXML_include_optional_set) {
6042 {
6043 dle_t *arg1 = (dle_t *) 0 ;
6044 int arg2 ;
6045 void *argp1 = 0 ;
6046 int res1 = 0 ;
6047 int argvi = 0;
6048 dXSARGS;
6049
6050 if ((items < 2) || (items > 2)) {
6051 SWIG_croak("Usage: HeaderXML_include_optional_set(self,include_optional);");
6052 }
6053 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6054 if (!SWIG_IsOK(res1)) {
6055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_optional_set" "', argument " "1"" of type '" "dle_t *""'");
6056 }
6057 arg1 = (dle_t *)(argp1);
6058 {
6059 if (sizeof(signed int) == 1) {
6060 arg2 = amglue_SvI8(ST(1));
6061 } else if (sizeof(signed int) == 2) {
6062 arg2 = amglue_SvI16(ST(1));
6063 } else if (sizeof(signed int) == 4) {
6064 arg2 = amglue_SvI32(ST(1));
6065 } else if (sizeof(signed int) == 8) {
6066 arg2 = amglue_SvI64(ST(1));
6067 } else {
6068 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
6069 }
6070 }
6071 if (arg1) (arg1)->include_optional = arg2;
6072 ST(argvi) = sv_newmortal();
6073
6074
6075 XSRETURN(argvi);
6076 fail:
6077
6078
6079 SWIG_croak_null();
6080 }
6081 }
6082
6083
XS(_wrap_HeaderXML_include_optional_get)6084 XS(_wrap_HeaderXML_include_optional_get) {
6085 {
6086 dle_t *arg1 = (dle_t *) 0 ;
6087 void *argp1 = 0 ;
6088 int res1 = 0 ;
6089 int argvi = 0;
6090 int result;
6091 dXSARGS;
6092
6093 if ((items < 1) || (items > 1)) {
6094 SWIG_croak("Usage: HeaderXML_include_optional_get(self);");
6095 }
6096 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6097 if (!SWIG_IsOK(res1)) {
6098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_include_optional_get" "', argument " "1"" of type '" "dle_t *""'");
6099 }
6100 arg1 = (dle_t *)(argp1);
6101 result = (int) ((arg1)->include_optional);
6102 {
6103 SV *for_stack;
6104 SP += argvi; PUTBACK;
6105 for_stack = sv_2mortal(amglue_newSVi64(result));
6106 SPAGAIN; SP -= argvi;
6107 ST(argvi) = for_stack;
6108 argvi++;
6109 }
6110
6111 XSRETURN(argvi);
6112 fail:
6113
6114 SWIG_croak_null();
6115 }
6116 }
6117
6118
XS(_wrap_HeaderXML_application_property_set)6119 XS(_wrap_HeaderXML_application_property_set) {
6120 {
6121 dle_t *arg1 = (dle_t *) 0 ;
6122 proplist_t arg2 ;
6123 void *argp1 = 0 ;
6124 int res1 = 0 ;
6125 void *argp2 ;
6126 int res2 = 0 ;
6127 int argvi = 0;
6128 dXSARGS;
6129
6130 if ((items < 2) || (items > 2)) {
6131 SWIG_croak("Usage: HeaderXML_application_property_set(self,application_property);");
6132 }
6133 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6134 if (!SWIG_IsOK(res1)) {
6135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_application_property_set" "', argument " "1"" of type '" "dle_t *""'");
6136 }
6137 arg1 = (dle_t *)(argp1);
6138 {
6139 res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_proplist_t, 0 );
6140 if (!SWIG_IsOK(res2)) {
6141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_application_property_set" "', argument " "2"" of type '" "proplist_t""'");
6142 }
6143 if (!argp2) {
6144 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeaderXML_application_property_set" "', argument " "2"" of type '" "proplist_t""'");
6145 } else {
6146 arg2 = *((proplist_t *)(argp2));
6147 }
6148 }
6149 if (arg1) (arg1)->application_property = arg2;
6150 ST(argvi) = sv_newmortal();
6151
6152 XSRETURN(argvi);
6153 fail:
6154
6155 SWIG_croak_null();
6156 }
6157 }
6158
6159
XS(_wrap_HeaderXML_application_property_get)6160 XS(_wrap_HeaderXML_application_property_get) {
6161 {
6162 dle_t *arg1 = (dle_t *) 0 ;
6163 void *argp1 = 0 ;
6164 int res1 = 0 ;
6165 int argvi = 0;
6166 proplist_t result;
6167 dXSARGS;
6168
6169 if ((items < 1) || (items > 1)) {
6170 SWIG_croak("Usage: HeaderXML_application_property_get(self);");
6171 }
6172 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6173 if (!SWIG_IsOK(res1)) {
6174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_application_property_get" "', argument " "1"" of type '" "dle_t *""'");
6175 }
6176 arg1 = (dle_t *)(argp1);
6177 result = ((arg1)->application_property);
6178 ST(argvi) = SWIG_NewPointerObj((proplist_t *)memcpy((proplist_t *)malloc(sizeof(proplist_t)),&result,sizeof(proplist_t)), SWIGTYPE_p_proplist_t, SWIG_POINTER_OWN | 0); argvi++ ;
6179
6180 XSRETURN(argvi);
6181 fail:
6182
6183 SWIG_croak_null();
6184 }
6185 }
6186
6187
XS(_wrap_HeaderXML_scriptlist_set)6188 XS(_wrap_HeaderXML_scriptlist_set) {
6189 {
6190 dle_t *arg1 = (dle_t *) 0 ;
6191 scriptlist_t arg2 ;
6192 void *argp1 = 0 ;
6193 int res1 = 0 ;
6194 void *argp2 ;
6195 int res2 = 0 ;
6196 int argvi = 0;
6197 dXSARGS;
6198
6199 if ((items < 2) || (items > 2)) {
6200 SWIG_croak("Usage: HeaderXML_scriptlist_set(self,scriptlist);");
6201 }
6202 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6203 if (!SWIG_IsOK(res1)) {
6204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_scriptlist_set" "', argument " "1"" of type '" "dle_t *""'");
6205 }
6206 arg1 = (dle_t *)(argp1);
6207 {
6208 res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_scriptlist_t, 0 );
6209 if (!SWIG_IsOK(res2)) {
6210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_scriptlist_set" "', argument " "2"" of type '" "scriptlist_t""'");
6211 }
6212 if (!argp2) {
6213 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeaderXML_scriptlist_set" "', argument " "2"" of type '" "scriptlist_t""'");
6214 } else {
6215 arg2 = *((scriptlist_t *)(argp2));
6216 }
6217 }
6218 if (arg1) (arg1)->scriptlist = arg2;
6219 ST(argvi) = sv_newmortal();
6220
6221 XSRETURN(argvi);
6222 fail:
6223
6224 SWIG_croak_null();
6225 }
6226 }
6227
6228
XS(_wrap_HeaderXML_scriptlist_get)6229 XS(_wrap_HeaderXML_scriptlist_get) {
6230 {
6231 dle_t *arg1 = (dle_t *) 0 ;
6232 void *argp1 = 0 ;
6233 int res1 = 0 ;
6234 int argvi = 0;
6235 scriptlist_t result;
6236 dXSARGS;
6237
6238 if ((items < 1) || (items > 1)) {
6239 SWIG_croak("Usage: HeaderXML_scriptlist_get(self);");
6240 }
6241 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6242 if (!SWIG_IsOK(res1)) {
6243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_scriptlist_get" "', argument " "1"" of type '" "dle_t *""'");
6244 }
6245 arg1 = (dle_t *)(argp1);
6246 result = ((arg1)->scriptlist);
6247 ST(argvi) = SWIG_NewPointerObj((scriptlist_t *)memcpy((scriptlist_t *)malloc(sizeof(scriptlist_t)),&result,sizeof(scriptlist_t)), SWIGTYPE_p_scriptlist_t, SWIG_POINTER_OWN | 0); argvi++ ;
6248
6249 XSRETURN(argvi);
6250 fail:
6251
6252 SWIG_croak_null();
6253 }
6254 }
6255
6256
XS(_wrap_HeaderXML_data_path_set)6257 XS(_wrap_HeaderXML_data_path_set) {
6258 {
6259 dle_t *arg1 = (dle_t *) 0 ;
6260 data_path_t arg2 ;
6261 void *argp1 = 0 ;
6262 int res1 = 0 ;
6263 void *argp2 ;
6264 int res2 = 0 ;
6265 int argvi = 0;
6266 dXSARGS;
6267
6268 if ((items < 2) || (items > 2)) {
6269 SWIG_croak("Usage: HeaderXML_data_path_set(self,data_path);");
6270 }
6271 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6272 if (!SWIG_IsOK(res1)) {
6273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_data_path_set" "', argument " "1"" of type '" "dle_t *""'");
6274 }
6275 arg1 = (dle_t *)(argp1);
6276 {
6277 res2 = SWIG_ConvertPtr(ST(1), &argp2, SWIGTYPE_p_data_path_t, 0 );
6278 if (!SWIG_IsOK(res2)) {
6279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_data_path_set" "', argument " "2"" of type '" "data_path_t""'");
6280 }
6281 if (!argp2) {
6282 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "HeaderXML_data_path_set" "', argument " "2"" of type '" "data_path_t""'");
6283 } else {
6284 arg2 = *((data_path_t *)(argp2));
6285 }
6286 }
6287 if (arg1) (arg1)->data_path = arg2;
6288 ST(argvi) = sv_newmortal();
6289
6290 XSRETURN(argvi);
6291 fail:
6292
6293 SWIG_croak_null();
6294 }
6295 }
6296
6297
XS(_wrap_HeaderXML_data_path_get)6298 XS(_wrap_HeaderXML_data_path_get) {
6299 {
6300 dle_t *arg1 = (dle_t *) 0 ;
6301 void *argp1 = 0 ;
6302 int res1 = 0 ;
6303 int argvi = 0;
6304 data_path_t result;
6305 dXSARGS;
6306
6307 if ((items < 1) || (items > 1)) {
6308 SWIG_croak("Usage: HeaderXML_data_path_get(self);");
6309 }
6310 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6311 if (!SWIG_IsOK(res1)) {
6312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_data_path_get" "', argument " "1"" of type '" "dle_t *""'");
6313 }
6314 arg1 = (dle_t *)(argp1);
6315 result = ((arg1)->data_path);
6316 ST(argvi) = SWIG_NewPointerObj((data_path_t *)memcpy((data_path_t *)malloc(sizeof(data_path_t)),&result,sizeof(data_path_t)), SWIGTYPE_p_data_path_t, SWIG_POINTER_OWN | 0); argvi++ ;
6317
6318 XSRETURN(argvi);
6319 fail:
6320
6321 SWIG_croak_null();
6322 }
6323 }
6324
6325
XS(_wrap_HeaderXML_directtcp_list_set)6326 XS(_wrap_HeaderXML_directtcp_list_set) {
6327 {
6328 dle_t *arg1 = (dle_t *) 0 ;
6329 GSList *arg2 = (GSList *) 0 ;
6330 void *argp1 = 0 ;
6331 int res1 = 0 ;
6332 void *argp2 = 0 ;
6333 int res2 = 0 ;
6334 int argvi = 0;
6335 dXSARGS;
6336
6337 if ((items < 2) || (items > 2)) {
6338 SWIG_croak("Usage: HeaderXML_directtcp_list_set(self,directtcp_list);");
6339 }
6340 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6341 if (!SWIG_IsOK(res1)) {
6342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_directtcp_list_set" "', argument " "1"" of type '" "dle_t *""'");
6343 }
6344 arg1 = (dle_t *)(argp1);
6345 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_GSList, SWIG_POINTER_DISOWN | 0 );
6346 if (!SWIG_IsOK(res2)) {
6347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_directtcp_list_set" "', argument " "2"" of type '" "GSList *""'");
6348 }
6349 arg2 = (GSList *)(argp2);
6350 if (arg1) (arg1)->directtcp_list = arg2;
6351 ST(argvi) = sv_newmortal();
6352
6353
6354 XSRETURN(argvi);
6355 fail:
6356
6357
6358 SWIG_croak_null();
6359 }
6360 }
6361
6362
XS(_wrap_HeaderXML_directtcp_list_get)6363 XS(_wrap_HeaderXML_directtcp_list_get) {
6364 {
6365 dle_t *arg1 = (dle_t *) 0 ;
6366 void *argp1 = 0 ;
6367 int res1 = 0 ;
6368 int argvi = 0;
6369 GSList *result = 0 ;
6370 dXSARGS;
6371
6372 if ((items < 1) || (items > 1)) {
6373 SWIG_croak("Usage: HeaderXML_directtcp_list_get(self);");
6374 }
6375 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6376 if (!SWIG_IsOK(res1)) {
6377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_directtcp_list_get" "', argument " "1"" of type '" "dle_t *""'");
6378 }
6379 arg1 = (dle_t *)(argp1);
6380 result = (GSList *) ((arg1)->directtcp_list);
6381 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_GSList, 0 | 0); argvi++ ;
6382
6383 XSRETURN(argvi);
6384 fail:
6385
6386 SWIG_croak_null();
6387 }
6388 }
6389
6390
XS(_wrap_HeaderXML_next_set)6391 XS(_wrap_HeaderXML_next_set) {
6392 {
6393 dle_t *arg1 = (dle_t *) 0 ;
6394 struct a_dle_s *arg2 = (struct a_dle_s *) 0 ;
6395 void *argp1 = 0 ;
6396 int res1 = 0 ;
6397 void *argp2 = 0 ;
6398 int res2 = 0 ;
6399 int argvi = 0;
6400 dXSARGS;
6401
6402 if ((items < 2) || (items > 2)) {
6403 SWIG_croak("Usage: HeaderXML_next_set(self,next);");
6404 }
6405 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6406 if (!SWIG_IsOK(res1)) {
6407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_next_set" "', argument " "1"" of type '" "dle_t *""'");
6408 }
6409 arg1 = (dle_t *)(argp1);
6410 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_a_dle_s, SWIG_POINTER_DISOWN | 0 );
6411 if (!SWIG_IsOK(res2)) {
6412 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "HeaderXML_next_set" "', argument " "2"" of type '" "struct a_dle_s *""'");
6413 }
6414 arg2 = (struct a_dle_s *)(argp2);
6415 if (arg1) (arg1)->next = arg2;
6416 ST(argvi) = sv_newmortal();
6417
6418
6419 XSRETURN(argvi);
6420 fail:
6421
6422
6423 SWIG_croak_null();
6424 }
6425 }
6426
6427
XS(_wrap_HeaderXML_next_get)6428 XS(_wrap_HeaderXML_next_get) {
6429 {
6430 dle_t *arg1 = (dle_t *) 0 ;
6431 void *argp1 = 0 ;
6432 int res1 = 0 ;
6433 int argvi = 0;
6434 struct a_dle_s *result = 0 ;
6435 dXSARGS;
6436
6437 if ((items < 1) || (items > 1)) {
6438 SWIG_croak("Usage: HeaderXML_next_get(self);");
6439 }
6440 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, 0 | 0 );
6441 if (!SWIG_IsOK(res1)) {
6442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "HeaderXML_next_get" "', argument " "1"" of type '" "dle_t *""'");
6443 }
6444 arg1 = (dle_t *)(argp1);
6445 result = (struct a_dle_s *) ((arg1)->next);
6446 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_a_dle_s, 0 | 0); argvi++ ;
6447
6448 XSRETURN(argvi);
6449 fail:
6450
6451 SWIG_croak_null();
6452 }
6453 }
6454
6455
XS(_wrap_new_HeaderXML)6456 XS(_wrap_new_HeaderXML) {
6457 {
6458 char *arg1 = (char *) 0 ;
6459 int res1 ;
6460 char *buf1 = 0 ;
6461 int alloc1 = 0 ;
6462 int argvi = 0;
6463 dle_t *result = 0 ;
6464 dXSARGS;
6465
6466 if ((items < 1) || (items > 1)) {
6467 SWIG_croak("Usage: new_HeaderXML(dle_str);");
6468 }
6469 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
6470 if (!SWIG_IsOK(res1)) {
6471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_HeaderXML" "', argument " "1"" of type '" "char *""'");
6472 }
6473 arg1 = (char *)(buf1);
6474 result = (dle_t *)new_dle_t(arg1);
6475 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dle_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
6476 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6477 XSRETURN(argvi);
6478 fail:
6479 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
6480 SWIG_croak_null();
6481 }
6482 }
6483
6484
XS(_wrap_delete_HeaderXML)6485 XS(_wrap_delete_HeaderXML) {
6486 {
6487 dle_t *arg1 = (dle_t *) 0 ;
6488 void *argp1 = 0 ;
6489 int res1 = 0 ;
6490 int argvi = 0;
6491 dXSARGS;
6492
6493 if ((items < 1) || (items > 1)) {
6494 SWIG_croak("Usage: delete_HeaderXML(self);");
6495 }
6496 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dle_t, SWIG_POINTER_DISOWN | 0 );
6497 if (!SWIG_IsOK(res1)) {
6498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_HeaderXML" "', argument " "1"" of type '" "dle_t *""'");
6499 }
6500 arg1 = (dle_t *)(argp1);
6501 delete_dle_t(arg1);
6502 ST(argvi) = sv_newmortal();
6503
6504 XSRETURN(argvi);
6505 fail:
6506
6507 SWIG_croak_null();
6508 }
6509 }
6510
6511
6512
6513 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6514
6515 static swig_type_info _swigt__p_GSList = {"_p_GSList", "GSList *", 0, 0, (void*)0, 0};
6516 static swig_type_info _swigt__p_a_STRMAX__char = {"_p_a_STRMAX__char", "char (*)[STRMAX]|string_t *", 0, 0, (void*)0, 0};
6517 static swig_type_info _swigt__p_a_dle_s = {"_p_a_dle_s", "struct a_dle_s *", 0, 0, (void*)0, 0};
6518 static swig_type_info _swigt__p_am_sl_t = {"_p_am_sl_t", "am_sl_t *", 0, 0, (void*)0, 0};
6519 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
6520 static swig_type_info _swigt__p_data_path_t = {"_p_data_path_t", "data_path_t *", 0, 0, (void*)0, 0};
6521 static swig_type_info _swigt__p_dle_t = {"_p_dle_t", "dle_t *", 0, 0, (void*)"Amanda::Header::HeaderXML", 0};
6522 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
6523 static swig_type_info _swigt__p_dumpfile_t = {"_p_dumpfile_t", "dumpfile_t *", 0, 0, (void*)"Amanda::Header::Header", 0};
6524 static swig_type_info _swigt__p_estimatelist_t = {"_p_estimatelist_t", "estimatelist_t *", 0, 0, (void*)0, 0};
6525 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
6526 static swig_type_info _swigt__p_int = {"_p_int", "int *|filetype_t *|gboolean *", 0, 0, (void*)0, 0};
6527 static swig_type_info _swigt__p_levellist_t = {"_p_levellist_t", "levellist_t *", 0, 0, (void*)0, 0};
6528 static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *", 0, 0, (void*)0, 0};
6529 static swig_type_info _swigt__p_proplist_t = {"_p_proplist_t", "proplist_t *", 0, 0, (void*)0, 0};
6530 static swig_type_info _swigt__p_scriptlist_t = {"_p_scriptlist_t", "scriptlist_t *", 0, 0, (void*)0, 0};
6531 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
6532
6533 static swig_type_info *swig_type_initial[] = {
6534 &_swigt__p_GSList,
6535 &_swigt__p_a_STRMAX__char,
6536 &_swigt__p_a_dle_s,
6537 &_swigt__p_am_sl_t,
6538 &_swigt__p_char,
6539 &_swigt__p_data_path_t,
6540 &_swigt__p_dle_t,
6541 &_swigt__p_double,
6542 &_swigt__p_dumpfile_t,
6543 &_swigt__p_estimatelist_t,
6544 &_swigt__p_float,
6545 &_swigt__p_int,
6546 &_swigt__p_levellist_t,
6547 &_swigt__p_off_t,
6548 &_swigt__p_proplist_t,
6549 &_swigt__p_scriptlist_t,
6550 &_swigt__p_unsigned_char,
6551 };
6552
6553 static swig_cast_info _swigc__p_GSList[] = { {&_swigt__p_GSList, 0, 0, 0},{0, 0, 0, 0}};
6554 static swig_cast_info _swigc__p_a_STRMAX__char[] = { {&_swigt__p_a_STRMAX__char, 0, 0, 0},{0, 0, 0, 0}};
6555 static swig_cast_info _swigc__p_a_dle_s[] = { {&_swigt__p_a_dle_s, 0, 0, 0},{0, 0, 0, 0}};
6556 static swig_cast_info _swigc__p_am_sl_t[] = { {&_swigt__p_am_sl_t, 0, 0, 0},{0, 0, 0, 0}};
6557 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
6558 static swig_cast_info _swigc__p_data_path_t[] = { {&_swigt__p_data_path_t, 0, 0, 0},{0, 0, 0, 0}};
6559 static swig_cast_info _swigc__p_dle_t[] = { {&_swigt__p_dle_t, 0, 0, 0},{0, 0, 0, 0}};
6560 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
6561 static swig_cast_info _swigc__p_dumpfile_t[] = { {&_swigt__p_dumpfile_t, 0, 0, 0},{0, 0, 0, 0}};
6562 static swig_cast_info _swigc__p_estimatelist_t[] = { {&_swigt__p_estimatelist_t, 0, 0, 0},{0, 0, 0, 0}};
6563 static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
6564 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
6565 static swig_cast_info _swigc__p_levellist_t[] = { {&_swigt__p_levellist_t, 0, 0, 0},{0, 0, 0, 0}};
6566 static swig_cast_info _swigc__p_off_t[] = { {&_swigt__p_off_t, 0, 0, 0},{0, 0, 0, 0}};
6567 static swig_cast_info _swigc__p_proplist_t[] = { {&_swigt__p_proplist_t, 0, 0, 0},{0, 0, 0, 0}};
6568 static swig_cast_info _swigc__p_scriptlist_t[] = { {&_swigt__p_scriptlist_t, 0, 0, 0},{0, 0, 0, 0}};
6569 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
6570
6571 static swig_cast_info *swig_cast_initial[] = {
6572 _swigc__p_GSList,
6573 _swigc__p_a_STRMAX__char,
6574 _swigc__p_a_dle_s,
6575 _swigc__p_am_sl_t,
6576 _swigc__p_char,
6577 _swigc__p_data_path_t,
6578 _swigc__p_dle_t,
6579 _swigc__p_double,
6580 _swigc__p_dumpfile_t,
6581 _swigc__p_estimatelist_t,
6582 _swigc__p_float,
6583 _swigc__p_int,
6584 _swigc__p_levellist_t,
6585 _swigc__p_off_t,
6586 _swigc__p_proplist_t,
6587 _swigc__p_scriptlist_t,
6588 _swigc__p_unsigned_char,
6589 };
6590
6591
6592 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6593
6594 static swig_constant_info swig_constants[] = {
6595 {0,0,0,0,0,0}
6596 };
6597 #ifdef __cplusplus
6598 }
6599 #endif
6600 static swig_variable_info swig_variables[] = {
6601 {0,0,0,0}
6602 };
6603 static swig_command_info swig_commands[] = {
6604 {"Amanda::Headerc::Header_type_set", _wrap_Header_type_set},
6605 {"Amanda::Headerc::Header_type_get", _wrap_Header_type_get},
6606 {"Amanda::Headerc::Header_datestamp_set", _wrap_Header_datestamp_set},
6607 {"Amanda::Headerc::Header_datestamp_get", _wrap_Header_datestamp_get},
6608 {"Amanda::Headerc::Header_dumplevel_set", _wrap_Header_dumplevel_set},
6609 {"Amanda::Headerc::Header_dumplevel_get", _wrap_Header_dumplevel_get},
6610 {"Amanda::Headerc::Header_compressed_set", _wrap_Header_compressed_set},
6611 {"Amanda::Headerc::Header_compressed_get", _wrap_Header_compressed_get},
6612 {"Amanda::Headerc::Header_encrypted_set", _wrap_Header_encrypted_set},
6613 {"Amanda::Headerc::Header_encrypted_get", _wrap_Header_encrypted_get},
6614 {"Amanda::Headerc::Header_comp_suffix_set", _wrap_Header_comp_suffix_set},
6615 {"Amanda::Headerc::Header_comp_suffix_get", _wrap_Header_comp_suffix_get},
6616 {"Amanda::Headerc::Header_encrypt_suffix_set", _wrap_Header_encrypt_suffix_set},
6617 {"Amanda::Headerc::Header_encrypt_suffix_get", _wrap_Header_encrypt_suffix_get},
6618 {"Amanda::Headerc::Header_name_set", _wrap_Header_name_set},
6619 {"Amanda::Headerc::Header_name_get", _wrap_Header_name_get},
6620 {"Amanda::Headerc::Header_disk_set", _wrap_Header_disk_set},
6621 {"Amanda::Headerc::Header_disk_get", _wrap_Header_disk_get},
6622 {"Amanda::Headerc::Header_program_set", _wrap_Header_program_set},
6623 {"Amanda::Headerc::Header_program_get", _wrap_Header_program_get},
6624 {"Amanda::Headerc::Header_application_set", _wrap_Header_application_set},
6625 {"Amanda::Headerc::Header_application_get", _wrap_Header_application_get},
6626 {"Amanda::Headerc::Header_srvcompprog_set", _wrap_Header_srvcompprog_set},
6627 {"Amanda::Headerc::Header_srvcompprog_get", _wrap_Header_srvcompprog_get},
6628 {"Amanda::Headerc::Header_clntcompprog_set", _wrap_Header_clntcompprog_set},
6629 {"Amanda::Headerc::Header_clntcompprog_get", _wrap_Header_clntcompprog_get},
6630 {"Amanda::Headerc::Header_srv_encrypt_set", _wrap_Header_srv_encrypt_set},
6631 {"Amanda::Headerc::Header_srv_encrypt_get", _wrap_Header_srv_encrypt_get},
6632 {"Amanda::Headerc::Header_clnt_encrypt_set", _wrap_Header_clnt_encrypt_set},
6633 {"Amanda::Headerc::Header_clnt_encrypt_get", _wrap_Header_clnt_encrypt_get},
6634 {"Amanda::Headerc::Header_recover_cmd_set", _wrap_Header_recover_cmd_set},
6635 {"Amanda::Headerc::Header_recover_cmd_get", _wrap_Header_recover_cmd_get},
6636 {"Amanda::Headerc::Header_uncompress_cmd_set", _wrap_Header_uncompress_cmd_set},
6637 {"Amanda::Headerc::Header_uncompress_cmd_get", _wrap_Header_uncompress_cmd_get},
6638 {"Amanda::Headerc::Header_decrypt_cmd_set", _wrap_Header_decrypt_cmd_set},
6639 {"Amanda::Headerc::Header_decrypt_cmd_get", _wrap_Header_decrypt_cmd_get},
6640 {"Amanda::Headerc::Header_srv_decrypt_opt_set", _wrap_Header_srv_decrypt_opt_set},
6641 {"Amanda::Headerc::Header_srv_decrypt_opt_get", _wrap_Header_srv_decrypt_opt_get},
6642 {"Amanda::Headerc::Header_clnt_decrypt_opt_set", _wrap_Header_clnt_decrypt_opt_set},
6643 {"Amanda::Headerc::Header_clnt_decrypt_opt_get", _wrap_Header_clnt_decrypt_opt_get},
6644 {"Amanda::Headerc::Header_cont_filename_set", _wrap_Header_cont_filename_set},
6645 {"Amanda::Headerc::Header_cont_filename_get", _wrap_Header_cont_filename_get},
6646 {"Amanda::Headerc::Header_dle_str_set", _wrap_Header_dle_str_set},
6647 {"Amanda::Headerc::Header_dle_str_get", _wrap_Header_dle_str_get},
6648 {"Amanda::Headerc::Header_is_partial_set", _wrap_Header_is_partial_set},
6649 {"Amanda::Headerc::Header_is_partial_get", _wrap_Header_is_partial_get},
6650 {"Amanda::Headerc::Header_partnum_set", _wrap_Header_partnum_set},
6651 {"Amanda::Headerc::Header_partnum_get", _wrap_Header_partnum_get},
6652 {"Amanda::Headerc::Header_totalparts_set", _wrap_Header_totalparts_set},
6653 {"Amanda::Headerc::Header_totalparts_get", _wrap_Header_totalparts_get},
6654 {"Amanda::Headerc::Header_blocksize_set", _wrap_Header_blocksize_set},
6655 {"Amanda::Headerc::Header_blocksize_get", _wrap_Header_blocksize_get},
6656 {"Amanda::Headerc::Header_orig_size_set", _wrap_Header_orig_size_set},
6657 {"Amanda::Headerc::Header_orig_size_get", _wrap_Header_orig_size_get},
6658 {"Amanda::Headerc::new_Header", _wrap_new_Header},
6659 {"Amanda::Headerc::delete_Header", _wrap_delete_Header},
6660 {"Amanda::Headerc::Header_to_string", _wrap_Header_to_string},
6661 {"Amanda::Headerc::Header_debug_dump", _wrap_Header_debug_dump},
6662 {"Amanda::Headerc::Header_summary", _wrap_Header_summary},
6663 {"Amanda::Headerc::C_from_string", _wrap_C_from_string},
6664 {"Amanda::Headerc::HeaderXML_disk_set", _wrap_HeaderXML_disk_set},
6665 {"Amanda::Headerc::HeaderXML_disk_get", _wrap_HeaderXML_disk_get},
6666 {"Amanda::Headerc::HeaderXML_device_set", _wrap_HeaderXML_device_set},
6667 {"Amanda::Headerc::HeaderXML_device_get", _wrap_HeaderXML_device_get},
6668 {"Amanda::Headerc::HeaderXML_program_is_application_api_set", _wrap_HeaderXML_program_is_application_api_set},
6669 {"Amanda::Headerc::HeaderXML_program_is_application_api_get", _wrap_HeaderXML_program_is_application_api_get},
6670 {"Amanda::Headerc::HeaderXML_program_set", _wrap_HeaderXML_program_set},
6671 {"Amanda::Headerc::HeaderXML_program_get", _wrap_HeaderXML_program_get},
6672 {"Amanda::Headerc::HeaderXML_estimatelist_set", _wrap_HeaderXML_estimatelist_set},
6673 {"Amanda::Headerc::HeaderXML_estimatelist_get", _wrap_HeaderXML_estimatelist_get},
6674 {"Amanda::Headerc::HeaderXML_spindle_set", _wrap_HeaderXML_spindle_set},
6675 {"Amanda::Headerc::HeaderXML_spindle_get", _wrap_HeaderXML_spindle_get},
6676 {"Amanda::Headerc::HeaderXML_compress_set", _wrap_HeaderXML_compress_set},
6677 {"Amanda::Headerc::HeaderXML_compress_get", _wrap_HeaderXML_compress_get},
6678 {"Amanda::Headerc::HeaderXML_encrypt_set", _wrap_HeaderXML_encrypt_set},
6679 {"Amanda::Headerc::HeaderXML_encrypt_get", _wrap_HeaderXML_encrypt_get},
6680 {"Amanda::Headerc::HeaderXML_kencrypt_set", _wrap_HeaderXML_kencrypt_set},
6681 {"Amanda::Headerc::HeaderXML_kencrypt_get", _wrap_HeaderXML_kencrypt_get},
6682 {"Amanda::Headerc::HeaderXML_levellist_set", _wrap_HeaderXML_levellist_set},
6683 {"Amanda::Headerc::HeaderXML_levellist_get", _wrap_HeaderXML_levellist_get},
6684 {"Amanda::Headerc::HeaderXML_nb_level_set", _wrap_HeaderXML_nb_level_set},
6685 {"Amanda::Headerc::HeaderXML_nb_level_get", _wrap_HeaderXML_nb_level_get},
6686 {"Amanda::Headerc::HeaderXML_dumpdate_set", _wrap_HeaderXML_dumpdate_set},
6687 {"Amanda::Headerc::HeaderXML_dumpdate_get", _wrap_HeaderXML_dumpdate_get},
6688 {"Amanda::Headerc::HeaderXML_compprog_set", _wrap_HeaderXML_compprog_set},
6689 {"Amanda::Headerc::HeaderXML_compprog_get", _wrap_HeaderXML_compprog_get},
6690 {"Amanda::Headerc::HeaderXML_srv_encrypt_set", _wrap_HeaderXML_srv_encrypt_set},
6691 {"Amanda::Headerc::HeaderXML_srv_encrypt_get", _wrap_HeaderXML_srv_encrypt_get},
6692 {"Amanda::Headerc::HeaderXML_clnt_encrypt_set", _wrap_HeaderXML_clnt_encrypt_set},
6693 {"Amanda::Headerc::HeaderXML_clnt_encrypt_get", _wrap_HeaderXML_clnt_encrypt_get},
6694 {"Amanda::Headerc::HeaderXML_srv_decrypt_opt_set", _wrap_HeaderXML_srv_decrypt_opt_set},
6695 {"Amanda::Headerc::HeaderXML_srv_decrypt_opt_get", _wrap_HeaderXML_srv_decrypt_opt_get},
6696 {"Amanda::Headerc::HeaderXML_clnt_decrypt_opt_set", _wrap_HeaderXML_clnt_decrypt_opt_set},
6697 {"Amanda::Headerc::HeaderXML_clnt_decrypt_opt_get", _wrap_HeaderXML_clnt_decrypt_opt_get},
6698 {"Amanda::Headerc::HeaderXML_record_set", _wrap_HeaderXML_record_set},
6699 {"Amanda::Headerc::HeaderXML_record_get", _wrap_HeaderXML_record_get},
6700 {"Amanda::Headerc::HeaderXML_create_index_set", _wrap_HeaderXML_create_index_set},
6701 {"Amanda::Headerc::HeaderXML_create_index_get", _wrap_HeaderXML_create_index_get},
6702 {"Amanda::Headerc::HeaderXML_auth_set", _wrap_HeaderXML_auth_set},
6703 {"Amanda::Headerc::HeaderXML_auth_get", _wrap_HeaderXML_auth_get},
6704 {"Amanda::Headerc::HeaderXML_exclude_file_set", _wrap_HeaderXML_exclude_file_set},
6705 {"Amanda::Headerc::HeaderXML_exclude_file_get", _wrap_HeaderXML_exclude_file_get},
6706 {"Amanda::Headerc::HeaderXML_exclude_list_set", _wrap_HeaderXML_exclude_list_set},
6707 {"Amanda::Headerc::HeaderXML_exclude_list_get", _wrap_HeaderXML_exclude_list_get},
6708 {"Amanda::Headerc::HeaderXML_include_file_set", _wrap_HeaderXML_include_file_set},
6709 {"Amanda::Headerc::HeaderXML_include_file_get", _wrap_HeaderXML_include_file_get},
6710 {"Amanda::Headerc::HeaderXML_include_list_set", _wrap_HeaderXML_include_list_set},
6711 {"Amanda::Headerc::HeaderXML_include_list_get", _wrap_HeaderXML_include_list_get},
6712 {"Amanda::Headerc::HeaderXML_exclude_optional_set", _wrap_HeaderXML_exclude_optional_set},
6713 {"Amanda::Headerc::HeaderXML_exclude_optional_get", _wrap_HeaderXML_exclude_optional_get},
6714 {"Amanda::Headerc::HeaderXML_include_optional_set", _wrap_HeaderXML_include_optional_set},
6715 {"Amanda::Headerc::HeaderXML_include_optional_get", _wrap_HeaderXML_include_optional_get},
6716 {"Amanda::Headerc::HeaderXML_application_property_set", _wrap_HeaderXML_application_property_set},
6717 {"Amanda::Headerc::HeaderXML_application_property_get", _wrap_HeaderXML_application_property_get},
6718 {"Amanda::Headerc::HeaderXML_scriptlist_set", _wrap_HeaderXML_scriptlist_set},
6719 {"Amanda::Headerc::HeaderXML_scriptlist_get", _wrap_HeaderXML_scriptlist_get},
6720 {"Amanda::Headerc::HeaderXML_data_path_set", _wrap_HeaderXML_data_path_set},
6721 {"Amanda::Headerc::HeaderXML_data_path_get", _wrap_HeaderXML_data_path_get},
6722 {"Amanda::Headerc::HeaderXML_directtcp_list_set", _wrap_HeaderXML_directtcp_list_set},
6723 {"Amanda::Headerc::HeaderXML_directtcp_list_get", _wrap_HeaderXML_directtcp_list_get},
6724 {"Amanda::Headerc::HeaderXML_next_set", _wrap_HeaderXML_next_set},
6725 {"Amanda::Headerc::HeaderXML_next_get", _wrap_HeaderXML_next_get},
6726 {"Amanda::Headerc::new_HeaderXML", _wrap_new_HeaderXML},
6727 {"Amanda::Headerc::delete_HeaderXML", _wrap_delete_HeaderXML},
6728 {0,0}
6729 };
6730 /* -----------------------------------------------------------------------------
6731 * Type initialization:
6732 * This problem is tough by the requirement that no dynamic
6733 * memory is used. Also, since swig_type_info structures store pointers to
6734 * swig_cast_info structures and swig_cast_info structures store pointers back
6735 * to swig_type_info structures, we need some lookup code at initialization.
6736 * The idea is that swig generates all the structures that are needed.
6737 * The runtime then collects these partially filled structures.
6738 * The SWIG_InitializeModule function takes these initial arrays out of
6739 * swig_module, and does all the lookup, filling in the swig_module.types
6740 * array with the correct data and linking the correct swig_cast_info
6741 * structures together.
6742 *
6743 * The generated swig_type_info structures are assigned statically to an initial
6744 * array. We just loop through that array, and handle each type individually.
6745 * First we lookup if this type has been already loaded, and if so, use the
6746 * loaded structure instead of the generated one. Then we have to fill in the
6747 * cast linked list. The cast data is initially stored in something like a
6748 * two-dimensional array. Each row corresponds to a type (there are the same
6749 * number of rows as there are in the swig_type_initial array). Each entry in
6750 * a column is one of the swig_cast_info structures for that type.
6751 * The cast_initial array is actually an array of arrays, because each row has
6752 * a variable number of columns. So to actually build the cast linked list,
6753 * we find the array of casts associated with the type, and loop through it
6754 * adding the casts to the list. The one last trick we need to do is making
6755 * sure the type pointer in the swig_cast_info struct is correct.
6756 *
6757 * First off, we lookup the cast->type name to see if it is already loaded.
6758 * There are three cases to handle:
6759 * 1) If the cast->type has already been loaded AND the type we are adding
6760 * casting info to has not been loaded (it is in this module), THEN we
6761 * replace the cast->type pointer with the type pointer that has already
6762 * been loaded.
6763 * 2) If BOTH types (the one we are adding casting info to, and the
6764 * cast->type) are loaded, THEN the cast info has already been loaded by
6765 * the previous module so we just ignore it.
6766 * 3) Finally, if cast->type has not already been loaded, then we add that
6767 * swig_cast_info to the linked list (because the cast->type) pointer will
6768 * be correct.
6769 * ----------------------------------------------------------------------------- */
6770
6771 #ifdef __cplusplus
6772 extern "C" {
6773 #if 0
6774 } /* c-mode */
6775 #endif
6776 #endif
6777
6778 #if 0
6779 #define SWIGRUNTIME_DEBUG
6780 #endif
6781
6782
6783 SWIGRUNTIME void
SWIG_InitializeModule(void * clientdata)6784 SWIG_InitializeModule(void *clientdata) {
6785 size_t i;
6786 swig_module_info *module_head, *iter;
6787 int init;
6788
6789 /* check to see if the circular list has been setup, if not, set it up */
6790 if (swig_module.next==0) {
6791 /* Initialize the swig_module */
6792 swig_module.type_initial = swig_type_initial;
6793 swig_module.cast_initial = swig_cast_initial;
6794 swig_module.next = &swig_module;
6795 init = 1;
6796 } else {
6797 init = 0;
6798 }
6799
6800 /* Try and load any already created modules */
6801 module_head = SWIG_GetModule(clientdata);
6802 if (!module_head) {
6803 /* This is the first module loaded for this interpreter */
6804 /* so set the swig module into the interpreter */
6805 SWIG_SetModule(clientdata, &swig_module);
6806 } else {
6807 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
6808 iter=module_head;
6809 do {
6810 if (iter==&swig_module) {
6811 /* Our module is already in the list, so there's nothing more to do. */
6812 return;
6813 }
6814 iter=iter->next;
6815 } while (iter!= module_head);
6816
6817 /* otherwise we must add our module into the list */
6818 swig_module.next = module_head->next;
6819 module_head->next = &swig_module;
6820 }
6821
6822 /* When multiple interpreters are used, a module could have already been initialized in
6823 a different interpreter, but not yet have a pointer in this interpreter.
6824 In this case, we do not want to continue adding types... everything should be
6825 set up already */
6826 if (init == 0) return;
6827
6828 /* Now work on filling in swig_module.types */
6829 #ifdef SWIGRUNTIME_DEBUG
6830 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
6831 #endif
6832 for (i = 0; i < swig_module.size; ++i) {
6833 swig_type_info *type = 0;
6834 swig_type_info *ret;
6835 swig_cast_info *cast;
6836
6837 #ifdef SWIGRUNTIME_DEBUG
6838 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6839 #endif
6840
6841 /* if there is another module already loaded */
6842 if (swig_module.next != &swig_module) {
6843 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
6844 }
6845 if (type) {
6846 /* Overwrite clientdata field */
6847 #ifdef SWIGRUNTIME_DEBUG
6848 printf("SWIG_InitializeModule: found type %s\n", type->name);
6849 #endif
6850 if (swig_module.type_initial[i]->clientdata) {
6851 type->clientdata = swig_module.type_initial[i]->clientdata;
6852 #ifdef SWIGRUNTIME_DEBUG
6853 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
6854 #endif
6855 }
6856 } else {
6857 type = swig_module.type_initial[i];
6858 }
6859
6860 /* Insert casting types */
6861 cast = swig_module.cast_initial[i];
6862 while (cast->type) {
6863 /* Don't need to add information already in the list */
6864 ret = 0;
6865 #ifdef SWIGRUNTIME_DEBUG
6866 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
6867 #endif
6868 if (swig_module.next != &swig_module) {
6869 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
6870 #ifdef SWIGRUNTIME_DEBUG
6871 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6872 #endif
6873 }
6874 if (ret) {
6875 if (type == swig_module.type_initial[i]) {
6876 #ifdef SWIGRUNTIME_DEBUG
6877 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6878 #endif
6879 cast->type = ret;
6880 ret = 0;
6881 } else {
6882 /* Check for casting already in the list */
6883 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6884 #ifdef SWIGRUNTIME_DEBUG
6885 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6886 #endif
6887 if (!ocast) ret = 0;
6888 }
6889 }
6890
6891 if (!ret) {
6892 #ifdef SWIGRUNTIME_DEBUG
6893 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6894 #endif
6895 if (type->cast) {
6896 type->cast->prev = cast;
6897 cast->next = type->cast;
6898 }
6899 type->cast = cast;
6900 }
6901 cast++;
6902 }
6903 /* Set entry in modules->types array equal to the type */
6904 swig_module.types[i] = type;
6905 }
6906 swig_module.types[i] = 0;
6907
6908 #ifdef SWIGRUNTIME_DEBUG
6909 printf("**** SWIG_InitializeModule: Cast List ******\n");
6910 for (i = 0; i < swig_module.size; ++i) {
6911 int j = 0;
6912 swig_cast_info *cast = swig_module.cast_initial[i];
6913 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6914 while (cast->type) {
6915 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6916 cast++;
6917 ++j;
6918 }
6919 printf("---- Total casts: %d\n",j);
6920 }
6921 printf("**** SWIG_InitializeModule: Cast List ******\n");
6922 #endif
6923 }
6924
6925 /* This function will propagate the clientdata field of type to
6926 * any new swig_type_info structures that have been added into the list
6927 * of equivalent types. It is like calling
6928 * SWIG_TypeClientData(type, clientdata) a second time.
6929 */
6930 SWIGRUNTIME void
SWIG_PropagateClientData(void)6931 SWIG_PropagateClientData(void) {
6932 size_t i;
6933 swig_cast_info *equiv;
6934 static int init_run = 0;
6935
6936 if (init_run) return;
6937 init_run = 1;
6938
6939 for (i = 0; i < swig_module.size; i++) {
6940 if (swig_module.types[i]->clientdata) {
6941 equiv = swig_module.types[i]->cast;
6942 while (equiv) {
6943 if (!equiv->converter) {
6944 if (equiv->type && !equiv->type->clientdata)
6945 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
6946 }
6947 equiv = equiv->next;
6948 }
6949 }
6950 }
6951 }
6952
6953 #ifdef __cplusplus
6954 #if 0
6955 {
6956 /* c-mode */
6957 #endif
6958 }
6959 #endif
6960
6961
6962
6963 #if defined(__cplusplus) && ! defined(XSPROTO)
6964 extern "C"
6965 #endif
6966
XS(SWIG_init)6967 XS(SWIG_init) {
6968 dXSARGS;
6969 int i;
6970
6971 SWIG_InitializeModule(0);
6972
6973 /* Install commands */
6974 for (i = 0; swig_commands[i].name; i++) {
6975 /* Casts only needed for Perl < 5.10. */
6976 #ifdef __cplusplus
6977 newXS(const_cast<char*>(swig_commands[i].name), swig_commands[i].wrapper, const_cast<char*>(__FILE__));
6978 #else
6979 newXS((char*)swig_commands[i].name, swig_commands[i].wrapper, (char*)__FILE__);
6980 #endif
6981 }
6982
6983 /* Install variables */
6984 for (i = 0; swig_variables[i].name; i++) {
6985 SV *sv;
6986 sv = get_sv(swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
6987 if (swig_variables[i].type) {
6988 SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
6989 } else {
6990 sv_setiv(sv,(IV) 0);
6991 }
6992 swig_create_magic(sv, swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
6993 }
6994
6995 /* Install constant */
6996 for (i = 0; swig_constants[i].type; i++) {
6997 SV *sv;
6998 sv = get_sv(swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
6999 switch(swig_constants[i].type) {
7000 case SWIG_INT:
7001 sv_setiv(sv, (IV) swig_constants[i].lvalue);
7002 break;
7003 case SWIG_FLOAT:
7004 sv_setnv(sv, (double) swig_constants[i].dvalue);
7005 break;
7006 case SWIG_STRING:
7007 sv_setpv(sv, (const char *) swig_constants[i].pvalue);
7008 break;
7009 case SWIG_POINTER:
7010 SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
7011 break;
7012 case SWIG_BINARY:
7013 SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
7014 break;
7015 default:
7016 break;
7017 }
7018 SvREADONLY_on(sv);
7019 }
7020
7021 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7022 SV *sv = get_sv((char*) SWIG_prefix "F_UNKNOWN", TRUE | 0x2 | GV_ADDMULTI);
7023 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_UNKNOWN)));
7024 SvREADONLY_on(sv);
7025 } while(0) /*@SWIG@*/;
7026 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7027 SV *sv = get_sv((char*) SWIG_prefix "F_WEIRD", TRUE | 0x2 | GV_ADDMULTI);
7028 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_WEIRD)));
7029 SvREADONLY_on(sv);
7030 } while(0) /*@SWIG@*/;
7031 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7032 SV *sv = get_sv((char*) SWIG_prefix "F_TAPESTART", TRUE | 0x2 | GV_ADDMULTI);
7033 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_TAPESTART)));
7034 SvREADONLY_on(sv);
7035 } while(0) /*@SWIG@*/;
7036 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7037 SV *sv = get_sv((char*) SWIG_prefix "F_TAPEEND", TRUE | 0x2 | GV_ADDMULTI);
7038 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_TAPEEND)));
7039 SvREADONLY_on(sv);
7040 } while(0) /*@SWIG@*/;
7041 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7042 SV *sv = get_sv((char*) SWIG_prefix "F_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
7043 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_DUMPFILE)));
7044 SvREADONLY_on(sv);
7045 } while(0) /*@SWIG@*/;
7046 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7047 SV *sv = get_sv((char*) SWIG_prefix "F_CONT_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
7048 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_CONT_DUMPFILE)));
7049 SvREADONLY_on(sv);
7050 } while(0) /*@SWIG@*/;
7051 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7052 SV *sv = get_sv((char*) SWIG_prefix "F_SPLIT_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
7053 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_SPLIT_DUMPFILE)));
7054 SvREADONLY_on(sv);
7055 } while(0) /*@SWIG@*/;
7056 /*@SWIG:/usr/share/swig/3.0.7/perl5/perltypemaps.swg,65,%set_constant@*/ do {
7057 SV *sv = get_sv((char*) SWIG_prefix "F_EMPTY", TRUE | 0x2 | GV_ADDMULTI);
7058 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_EMPTY)));
7059 SvREADONLY_on(sv);
7060 } while(0) /*@SWIG@*/;
7061 SWIG_TypeClientData(SWIGTYPE_p_dumpfile_t, (void*) "Amanda::Header::Header");
7062 SWIG_TypeClientData(SWIGTYPE_p_dle_t, (void*) "Amanda::Header::HeaderXML");
7063 ST(0) = &PL_sv_yes;
7064 XSRETURN(1);
7065 }
7066
7067