1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
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 * ----------------------------------------------------------------------------- */
11 #include "../config/config.h"
15 #define SWIG_CASTRANK_MODE
17 /* -----------------------------------------------------------------------------
18 * This section contains generic SWIG labels for method/variable
19 * declarations/attributes, and other compiler dependent labels.
20 * ----------------------------------------------------------------------------- */
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
31 # define SWIGTEMPLATEDISAMBIGUATOR
35 /* inline attribute */
37 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
38 # define SWIGINLINE inline
44 /* attribute recognised by some compilers to avoid 'unused' warnings */
46 # if defined(__GNUC__)
47 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
48 # define SWIGUNUSED __attribute__ ((__unused__))
53 # define SWIGUNUSED __attribute__ ((__unused__))
59 #ifndef SWIG_MSC_UNSUPPRESS_4505
60 # if defined(_MSC_VER)
61 # pragma warning(disable : 4505) /* unreferenced local function has been removed */
65 #ifndef SWIGUNUSEDPARM
67 # define SWIGUNUSEDPARM(p)
69 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
73 /* internal SWIG method */
75 # define SWIGINTERN static SWIGUNUSED
78 /* internal inline SWIG method */
79 #ifndef SWIGINTERNINLINE
80 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
83 /* exporting methods */
84 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
85 # ifndef GCC_HASCLASSVISIBILITY
86 # define GCC_HASCLASSVISIBILITY
91 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
92 # if defined(STATIC_LINKED)
95 # define SWIGEXPORT __declspec(dllexport)
98 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
99 # define SWIGEXPORT __attribute__ ((visibility("default")))
106 /* calling conventions for Windows */
108 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
109 # define SWIGSTDCALL __stdcall
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
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
126 /* -----------------------------------------------------------------------------
129 * This file contains generic C API SWIG runtime support for pointer
131 * ----------------------------------------------------------------------------- */
133 /* This should only be incremented when either the layout of swig_type_info changes,
134 or for whatever reason, the runtime changes incompatibly */
135 #define SWIG_RUNTIME_VERSION "4"
137 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
138 #ifdef SWIG_TYPE_TABLE
139 # define SWIG_QUOTE_STRING(x) #x
140 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
141 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
143 # define SWIG_TYPE_TABLE_NAME
147 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
148 creating a static or dynamic library from the SWIG runtime code.
149 In 99.9% of the cases, SWIG just needs to declare them as 'static'.
151 But only do this if strictly necessary, ie, if you have problems
152 with your compiler or suchlike.
156 # define SWIGRUNTIME SWIGINTERN
159 #ifndef SWIGRUNTIMEINLINE
160 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
163 /* Generic buffer size */
164 #ifndef SWIG_BUFFER_SIZE
165 # define SWIG_BUFFER_SIZE 1024
168 /* Flags for pointer conversions */
169 #define SWIG_POINTER_DISOWN 0x1
170 #define SWIG_CAST_NEW_MEMORY 0x2
172 /* Flags for new pointer objects */
173 #define SWIG_POINTER_OWN 0x1
177 Flags/methods for returning states.
179 The SWIG conversion methods, as ConvertPtr, return and integer
180 that tells if the conversion was successful or not. And if not,
181 an error code can be returned (see swigerrors.swg for the codes).
183 Use the following macros/flags to set or process the returning
186 In old versions of SWIG, code such as the following was usually written:
188 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
194 Now you can be more explicit:
196 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
197 if (SWIG_IsOK(res)) {
203 which is the same really, but now you can also do
206 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
207 if (SWIG_IsOK(res)) {
209 if (SWIG_IsNewObj(res) {
219 I.e., now SWIG_ConvertPtr can return new objects and you can
220 identify the case and take care of the deallocation. Of course that
221 also requires SWIG_ConvertPtr to return new result values, such as
223 int SWIG_ConvertPtr(obj, ptr,...) {
225 if (<need new object>) {
226 *ptr = <ptr to new allocated object>;
229 *ptr = <ptr to old object>;
237 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
238 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
241 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
242 allows to return the 'cast rank', for example, if you have this
249 food(1) // cast rank '1' (1 -> 1.0)
250 fooi(1) // cast rank '0'
252 just use the SWIG_AddCast()/SWIG_CheckState()
256 #define SWIG_ERROR (-1)
257 #define SWIG_IsOK(r) (r >= 0)
258 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
260 /* The CastRankLimit says how many bits are used for the cast rank */
261 #define SWIG_CASTRANKLIMIT (1 << 8)
262 /* The NewMask denotes the object was created (using new/malloc) */
263 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
264 /* The TmpMask is for in/out typemaps that use temporal objects */
265 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
266 /* Simple returning values */
267 #define SWIG_BADOBJ (SWIG_ERROR)
268 #define SWIG_OLDOBJ (SWIG_OK)
269 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
270 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
271 /* Check, add and del mask methods */
272 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
273 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
274 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
275 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
276 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
277 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
280 #if defined(SWIG_CASTRANK_MODE)
281 # ifndef SWIG_TypeRank
282 # define SWIG_TypeRank unsigned long
284 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
285 # define SWIG_MAXCASTRANK (2)
287 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
288 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
289 SWIGINTERNINLINE int SWIG_AddCast(int r) {
290 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
292 SWIGINTERNINLINE int SWIG_CheckState(int r) {
293 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
295 #else /* no cast-rank mode */
296 # define SWIG_AddCast
297 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
307 typedef void *(*swig_converter_func)(void *, int *);
308 typedef struct swig_type_info *(*swig_dycast_func)(void **);
310 /* Structure to store information on one type */
311 typedef struct swig_type_info {
312 const char *name; /* mangled name of this type */
313 const char *str; /* human readable name of this type */
314 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
315 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
316 void *clientdata; /* language specific type data */
317 int owndata; /* flag if the structure owns the clientdata */
320 /* Structure to store a type and conversion function used for casting */
321 typedef struct swig_cast_info {
322 swig_type_info *type; /* pointer to type that is equivalent to this type */
323 swig_converter_func converter; /* function to cast the void pointers */
324 struct swig_cast_info *next; /* pointer to next cast in linked list */
325 struct swig_cast_info *prev; /* pointer to the previous cast */
328 /* Structure used to store module information
329 * Each module generates one structure like this, and the runtime collects
330 * all of these structures and stores them in a circularly linked list.*/
331 typedef struct swig_module_info {
332 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
333 size_t size; /* Number of types in this module */
334 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
335 swig_type_info **type_initial; /* Array of initially generated type structures */
336 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
337 void *clientdata; /* Language specific module data */
341 Compare two type names skipping the space characters, therefore
342 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
344 Return 0 when the two name types are equivalent, as in
345 strncmp, but skipping ' '.
348 SWIG_TypeNameComp(const char *f1, const char *l1,
349 const char *f2, const char *l2) {
350 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
351 while ((*f1 == ' ') && (f1 != l1)) ++f1;
352 while ((*f2 == ' ') && (f2 != l2)) ++f2;
353 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
355 return (int)((l1 - f1) - (l2 - f2));
359 Check type equivalence in a name list like <name1>|<name2>|...
360 Return 0 if not equal, 1 if equal
363 SWIG_TypeEquiv(const char *nb, const char *tb) {
365 const char* te = tb + strlen(tb);
367 while (!equiv && *ne) {
368 for (nb = ne; *ne; ++ne) {
369 if (*ne == '|') break;
371 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
378 Check type equivalence in a name list like <name1>|<name2>|...
379 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
382 SWIG_TypeCompare(const char *nb, const char *tb) {
384 const char* te = tb + strlen(tb);
386 while (!equiv && *ne) {
387 for (nb = ne; *ne; ++ne) {
388 if (*ne == '|') break;
390 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
400 SWIGRUNTIME swig_cast_info *
401 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
403 swig_cast_info *iter = ty->cast;
405 if (strcmp(iter->type->name, c) == 0) {
406 if (iter == ty->cast)
408 /* Move iter to the top of the linked list */
409 iter->prev->next = iter->next;
411 iter->next->prev = iter->prev;
412 iter->next = ty->cast;
414 if (ty->cast) ty->cast->prev = iter;
425 Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
427 SWIGRUNTIME swig_cast_info *
428 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
430 swig_cast_info *iter = ty->cast;
432 if (iter->type == from) {
433 if (iter == ty->cast)
435 /* Move iter to the top of the linked list */
436 iter->prev->next = iter->next;
438 iter->next->prev = iter->prev;
439 iter->next = ty->cast;
441 if (ty->cast) ty->cast->prev = iter;
452 Cast a pointer up an inheritance hierarchy
454 SWIGRUNTIMEINLINE void *
455 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
456 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
460 Dynamic pointer casting. Down an inheritance hierarchy
462 SWIGRUNTIME swig_type_info *
463 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
464 swig_type_info *lastty = ty;
465 if (!ty || !ty->dcast) return ty;
466 while (ty && (ty->dcast)) {
467 ty = (*ty->dcast)(ptr);
474 Return the name associated with this type
476 SWIGRUNTIMEINLINE const char *
477 SWIG_TypeName(const swig_type_info *ty) {
482 Return the pretty name associated with this type,
483 that is an unmangled type name in a form presentable to the user.
485 SWIGRUNTIME const char *
486 SWIG_TypePrettyName(const swig_type_info *type) {
487 /* The "str" field contains the equivalent pretty names of the
488 type, separated by vertical-bar characters. We choose
489 to print the last name, as it is often (?) the most
491 if (!type) return NULL;
492 if (type->str != NULL) {
493 const char *last_name = type->str;
495 for (s = type->str; *s; s++)
496 if (*s == '|') last_name = s+1;
504 Set the clientdata field for a type
507 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
508 swig_cast_info *cast = ti->cast;
509 /* if (ti->clientdata == clientdata) return; */
510 ti->clientdata = clientdata;
513 if (!cast->converter) {
514 swig_type_info *tc = cast->type;
515 if (!tc->clientdata) {
516 SWIG_TypeClientData(tc, clientdata);
523 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
524 SWIG_TypeClientData(ti, clientdata);
529 Search for a swig_type_info structure only by mangled name
530 Search is a O(log #types)
532 We start searching at module start, and finish searching when start == end.
533 Note: if start == end at the beginning of the function, we go all the way around
536 SWIGRUNTIME swig_type_info *
537 SWIG_MangledTypeQueryModule(swig_module_info *start,
538 swig_module_info *end,
540 swig_module_info *iter = start;
543 register size_t l = 0;
544 register size_t r = iter->size - 1;
546 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
547 register size_t i = (l + r) >> 1;
548 const char *iname = iter->types[i]->name;
550 register int compare = strcmp(name, iname);
552 return iter->types[i];
553 } else if (compare < 0) {
559 } else if (compare > 0) {
563 break; /* should never happen */
568 } while (iter != end);
573 Search for a swig_type_info structure for either a mangled name or a human readable name.
574 It first searches the mangled names of the types, which is a O(log #types)
575 If a type is not found it then searches the human readable names, which is O(#types).
577 We start searching at module start, and finish searching when start == end.
578 Note: if start == end at the beginning of the function, we go all the way around
581 SWIGRUNTIME swig_type_info *
582 SWIG_TypeQueryModule(swig_module_info *start,
583 swig_module_info *end,
585 /* STEP 1: Search the name field using binary search */
586 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
590 /* STEP 2: If the type hasn't been found, do a complete search
591 of the str field (the human readable name) */
592 swig_module_info *iter = start;
594 register size_t i = 0;
595 for (; i < iter->size; ++i) {
596 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
597 return iter->types[i];
600 } while (iter != end);
603 /* neither found a match */
608 Pack binary data into a string
611 SWIG_PackData(char *c, void *ptr, size_t sz) {
612 static const char hex[17] = "0123456789abcdef";
613 register const unsigned char *u = (unsigned char *) ptr;
614 register const unsigned char *eu = u + sz;
615 for (; u != eu; ++u) {
616 register unsigned char uu = *u;
617 *(c++) = hex[(uu & 0xf0) >> 4];
618 *(c++) = hex[uu & 0xf];
624 Unpack binary data from a string
626 SWIGRUNTIME const char *
627 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
628 register unsigned char *u = (unsigned char *) ptr;
629 register const unsigned char *eu = u + sz;
630 for (; u != eu; ++u) {
631 register char d = *(c++);
632 register unsigned char uu;
633 if ((d >= '0') && (d <= '9'))
634 uu = ((d - '0') << 4);
635 else if ((d >= 'a') && (d <= 'f'))
636 uu = ((d - ('a'-10)) << 4);
640 if ((d >= '0') && (d <= '9'))
642 else if ((d >= 'a') && (d <= 'f'))
643 uu |= (d - ('a'-10));
652 Pack 'void *' into a string buffer.
655 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
657 if ((2*sizeof(void *) + 2) > bsz) return 0;
659 r = SWIG_PackData(r,&ptr,sizeof(void *));
660 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
665 SWIGRUNTIME const char *
666 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
668 if (strcmp(c,"NULL") == 0) {
675 return SWIG_UnpackData(++c,ptr,sizeof(void *));
679 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
681 size_t lname = (name ? strlen(name) : 0);
682 if ((2*sz + 2 + lname) > bsz) return 0;
684 r = SWIG_PackData(r,ptr,sz);
686 strncpy(r,name,lname+1);
693 SWIGRUNTIME const char *
694 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
696 if (strcmp(c,"NULL") == 0) {
703 return SWIG_UnpackData(++c,ptr,sz);
711 #define SWIG_UnknownError -1
712 #define SWIG_IOError -2
713 #define SWIG_RuntimeError -3
714 #define SWIG_IndexError -4
715 #define SWIG_TypeError -5
716 #define SWIG_DivisionByZero -6
717 #define SWIG_OverflowError -7
718 #define SWIG_SyntaxError -8
719 #define SWIG_ValueError -9
720 #define SWIG_SystemError -10
721 #define SWIG_AttributeError -11
722 #define SWIG_MemoryError -12
723 #define SWIG_NullReferenceError -13
728 /* Needed on some windows machines---since MS plays funny games with the header files under C++ */
737 /* Add in functionality missing in older versions of Perl. Much of this is based on Devel-PPPort on cpan. */
739 /* Add PERL_REVISION, PERL_VERSION, PERL_SUBVERSION if missing */
740 #ifndef PERL_REVISION
741 # if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
742 # define PERL_PATCHLEVEL_H_IMPLICIT
743 # include <patchlevel.h>
745 # if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
746 # include <could_not_find_Perl_patchlevel.h>
748 # ifndef PERL_REVISION
749 # define PERL_REVISION (5)
750 # define PERL_VERSION PATCHLEVEL
751 # define PERL_SUBVERSION SUBVERSION
755 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
756 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
760 # define SvIOK_UV(sv) (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
764 # define SvUOK(sv) SvIOK_UV(sv)
767 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
768 # define PL_sv_undef sv_undef
770 # define PL_errgv errgv
771 # define PL_sv_no sv_no
772 # define PL_sv_yes sv_yes
773 # define PL_markstack_ptr markstack_ptr
778 # define IVSIZE LONGSIZE
780 # define IVSIZE 4 /* A bold guess, but the best we can make. */
785 # if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
787 # define INT2PTR(any,d) (any)(d)
789 # if PTRSIZE == LONGSIZE
790 # define PTRV unsigned long
792 # define PTRV unsigned
794 # define INT2PTR(any,d) (any)(PTRV)(d)
797 # define NUM2PTR(any,d) (any)(PTRV)(d)
798 # define PTR2IV(p) INT2PTR(IV,p)
799 # define PTR2UV(p) INT2PTR(UV,p)
800 # define PTR2NV(p) NUM2PTR(NV,p)
802 # if PTRSIZE == LONGSIZE
803 # define PTR2ul(p) (unsigned long)(p)
805 # define PTR2ul(p) INT2PTR(unsigned long,p)
807 #endif /* !INT2PTR */
810 # define SvPV_nolen(x) SvPV(x,PL_na)
814 # define get_sv perl_get_sv
818 # define ERRSV get_sv("@",FALSE)
830 /* -----------------------------------------------------------------------------
832 * ----------------------------------------------------------------------------- */
834 SWIGINTERN const char*
835 SWIG_Perl_ErrorType(int code) {
836 const char* type = 0;
838 case SWIG_MemoryError:
839 type = "MemoryError";
844 case SWIG_RuntimeError:
845 type = "RuntimeError";
847 case SWIG_IndexError:
853 case SWIG_DivisionByZero:
854 type = "ZeroDivisionError";
856 case SWIG_OverflowError:
857 type = "OverflowError";
859 case SWIG_SyntaxError:
860 type = "SyntaxError";
862 case SWIG_ValueError:
865 case SWIG_SystemError:
866 type = "SystemError";
868 case SWIG_AttributeError:
869 type = "AttributeError";
872 type = "RuntimeError";
880 /* -----------------------------------------------------------------------------
883 * This file contains the runtime support for Perl modules
884 * and includes code for managing global variables and pointer
886 * ----------------------------------------------------------------------------- */
889 #define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
890 #define SWIG_PERL_OBJECT_CALL pPerl,
892 #define SWIG_PERL_OBJECT_DECL
893 #define SWIG_PERL_OBJECT_CALL
896 /* Common SWIG API */
898 /* for raw pointers */
899 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
900 #define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
902 /* for raw packed data */
903 #define SWIG_ConvertPacked(obj, p, s, type) SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
904 #define SWIG_NewPackedObj(p, s, type) SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
906 /* for class or struct pointers */
907 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
908 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
910 /* for C or C++ function pointers */
911 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
912 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
914 /* for C++ member pointers, ie, member methods */
915 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_ConvertPacked(obj, ptr, sz, ty)
916 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_NewPackedObj(ptr, sz, type)
921 #define SWIG_GetModule(clientdata) SWIG_Perl_GetModule()
922 #define SWIG_SetModule(clientdata, pointer) SWIG_Perl_SetModule(pointer)
925 /* Error manipulation */
927 #define SWIG_ErrorType(code) SWIG_Perl_ErrorType(code)
928 #define SWIG_Error(code, msg) sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
929 #define SWIG_fail goto fail
931 /* Perl-specific SWIG API */
933 #define SWIG_MakePtr(sv, ptr, type, flags) SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
934 #define SWIG_MakePackedObj(sv, p, s, type) SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
935 #define SWIG_SetError(str) SWIG_Error(SWIG_RuntimeError, str)
938 #define SWIG_PERL_DECL_ARGS_1(arg1) (SWIG_PERL_OBJECT_DECL arg1)
939 #define SWIG_PERL_CALL_ARGS_1(arg1) (SWIG_PERL_OBJECT_CALL arg1)
940 #define SWIG_PERL_DECL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_DECL arg1, arg2)
941 #define SWIG_PERL_CALL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_CALL arg1, arg2)
943 /* -----------------------------------------------------------------------------
944 * pointers/data manipulation
945 * ----------------------------------------------------------------------------- */
947 /* For backward compatibility only */
948 #define SWIG_POINTER_EXCEPTION 0
954 #define SWIG_OWNER SWIG_POINTER_OWN
955 #define SWIG_SHADOW SWIG_OWNER << 1
957 #define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
959 /* SWIG Perl macros */
961 /* Macro to declare an XS function */
963 # define XSPROTO(name) void name(pTHX_ CV* cv)
966 /* Macro to call an XS function */
968 # define SWIG_CALLXS(_name) _name(cv,pPerl)
970 # ifndef MULTIPLICITY
971 # define SWIG_CALLXS(_name) _name(cv)
973 # define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
978 #define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this;
983 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
988 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
989 #define SWIGCLASS_STATIC
991 #else /* PERL_OBJECT */
994 #define SWIGCLASS_STATIC static SWIGUNUSED
997 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
1002 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
1007 #else /* MULTIPLICITY */
1009 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
1014 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
1019 #endif /* MULTIPLICITY */
1020 #endif /* PERL_OBJECT */
1022 /* Workaround for bug in perl 5.6.x croak and earlier */
1023 #if (PERL_VERSION < 8)
1025 # define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
1026 static void SWIG_Perl_croak_null(CPerlObj *pPerl)
1028 static void SWIG_croak_null()
1032 # if (PERL_VERSION < 6)
1035 if (SvOK(err) && !SvROK(err)) croak("%_", err);
1040 # define SWIG_croak_null() croak(Nullch)
1045 Define how strict is the cast between strings and integers/doubles
1046 when overloading between these types occurs.
1048 The default is making it as strict as possible by using SWIG_AddCast
1051 You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
1052 disable the SWIG_AddCast, making the casting between string and
1053 numbers less strict.
1055 In the end, we try to solve the overloading between strings and
1056 numerical types in the more natural way, but if you can avoid it,
1057 well, avoid it using %rename, for example.
1059 #ifndef SWIG_PERL_NO_STRICT_STR2NUM
1060 # ifndef SWIG_PERL_STRICT_STR2NUM
1061 # define SWIG_PERL_STRICT_STR2NUM
1064 #ifdef SWIG_PERL_STRICT_STR2NUM
1065 /* string takes precedence */
1066 #define SWIG_Str2NumCast(x) SWIG_AddCast(x)
1068 /* number takes precedence */
1069 #define SWIG_Str2NumCast(x) x
1076 SWIGRUNTIME const char *
1077 SWIG_Perl_TypeProxyName(const swig_type_info *type) {
1078 if (!type) return NULL;
1079 if (type->clientdata != NULL) {
1080 return (const char*) type->clientdata;
1087 /* Identical to SWIG_TypeCheck, except for strcmp comparison */
1088 SWIGRUNTIME swig_cast_info *
1089 SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
1091 swig_cast_info *iter = ty->cast;
1093 if ( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) ||
1094 (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0)) ) {
1095 if (iter == ty->cast)
1097 /* Move iter to the top of the linked list */
1098 iter->prev->next = iter->next;
1100 iter->next->prev = iter->prev;
1101 iter->next = ty->cast;
1103 if (ty->cast) ty->cast->prev = iter;
1113 /* Function for getting a pointer value */
1116 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
1118 void *voidptr = (void *)0;
1120 /* If magical, apply more magic */
1124 /* Check to see if this is an object */
1125 if (sv_isobject(sv)) {
1127 tsv = (SV*) SvRV(sv);
1128 if ((SvTYPE(tsv) == SVt_PVHV)) {
1130 if (SvMAGICAL(tsv)) {
1131 mg = mg_find(tsv,'P');
1134 if (sv_isobject(sv)) {
1135 tsv = (SV*)SvRV(sv);
1145 voidptr = INT2PTR(void *,tmp);
1146 } else if (! SvOK(sv)) { /* Check for undef */
1147 *(ptr) = (void *) 0;
1149 } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
1151 *(ptr) = (void *) 0;
1156 } else { /* Don't know what it is */
1160 /* Now see if the types match */
1161 char *_c = HvNAME(SvSTASH(SvRV(sv)));
1162 tc = SWIG_TypeProxyCheck(_c,_t);
1168 *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1169 assert(!newmemory); /* newmemory handling not yet implemented */
1176 * DISOWN implementation: we need a perl guru to check this one.
1178 if (tsv && (flags & SWIG_POINTER_DISOWN)) {
1180 * almost copy paste code from below SWIG_POINTER_OWN setting
1183 HV *stash = SvSTASH(SvRV(obj));
1184 GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
1188 * To set ownership (see below), a newSViv(1) entry is added.
1189 * Hence, to remove ownership, we delete the entry.
1191 if (hv_exists_ent(hv, obj, 0)) {
1192 hv_delete_ent(hv, obj, 0, 0);
1200 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
1201 if (ptr && (flags & SWIG_SHADOW)) {
1206 sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1207 stash=SvSTASH(SvRV(obj));
1208 if (flags & SWIG_POINTER_OWN) {
1210 GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1212 gv_init(gv, stash, "OWNER", 5, FALSE);
1214 hv_store_ent(hv, obj, newSViv(1), 0);
1216 sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
1218 self=newRV_noinc((SV *)hash);
1220 SvREFCNT_dec((SV *)self);
1221 sv_bless(sv, stash);
1224 sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1228 SWIGRUNTIMEINLINE SV *
1229 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
1230 SV *result = sv_newmortal();
1231 SWIG_MakePtr(result, ptr, t, flags);
1236 SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
1239 if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
1241 r = SWIG_PackData(r,ptr,sz);
1242 strcpy(r,SWIG_Perl_TypeProxyName(type));
1243 sv_setpv(sv, result);
1247 SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
1248 SV *result = sv_newmortal();
1249 SWIG_Perl_MakePackedObj(result, ptr, sz, type);
1253 /* Convert a packed value value */
1255 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
1259 if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
1260 c = SvPV_nolen(obj);
1261 /* Pointer values must start with leading underscore */
1262 if (*c != '_') return SWIG_ERROR;
1264 c = SWIG_UnpackData(c,ptr,sz);
1266 tc = SWIG_TypeCheck(c,ty);
1267 if (!tc) return SWIG_ERROR;
1273 /* Macros for low-level exception handling */
1274 #define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
1277 typedef XSPROTO(SwigPerlWrapper);
1278 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
1280 /* Structure for command table */
1283 SwigPerlWrapperPtr wrapper;
1284 } swig_command_info;
1286 /* Information for constant table */
1289 #define SWIG_FLOAT 2
1290 #define SWIG_STRING 3
1291 #define SWIG_POINTER 4
1292 #define SWIG_BINARY 5
1294 /* Constant information structure */
1295 typedef struct swig_constant_info {
1301 swig_type_info **ptype;
1302 } swig_constant_info;
1305 /* Structure for variable table */
1310 swig_type_info **type;
1311 } swig_variable_info;
1313 /* Magic variable code */
1315 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
1316 #ifndef MULTIPLICITY
1317 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
1319 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
1322 # define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
1323 SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
1327 sv_magic(sv,sv,'U',(char *) name,strlen(name));
1328 mg = mg_find(sv,'U');
1329 mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1330 mg->mg_virtual->svt_get = (SwigMagicFunc) get;
1331 mg->mg_virtual->svt_set = (SwigMagicFunc) set;
1332 mg->mg_virtual->svt_len = 0;
1333 mg->mg_virtual->svt_clear = 0;
1334 mg->mg_virtual->svt_free = 0;
1338 SWIGRUNTIME swig_module_info *
1339 SWIG_Perl_GetModule(void) {
1340 static void *type_pointer = (void *)0;
1343 /* first check if pointer already created */
1344 if (!type_pointer) {
1345 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
1346 if (pointer && SvOK(pointer)) {
1347 type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
1351 return (swig_module_info *) type_pointer;
1355 SWIG_Perl_SetModule(swig_module_info *module) {
1358 /* create a new pointer */
1359 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
1360 sv_setiv(pointer, PTR2IV(module));
1367 /* Workaround perl5 global namespace pollution. Note that undefining library
1368 * functions like fopen will not solve the problem on all platforms as fopen
1369 * might be a macro on Windows but not necessarily on other operating systems. */
1469 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1471 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1475 #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
1478 /* -------- TYPES TABLE (BEGIN) -------- */
1480 #define SWIGTYPE_p_a_STRMAX__char swig_types[0]
1481 #define SWIGTYPE_p_char swig_types[1]
1482 #define SWIGTYPE_p_double swig_types[2]
1483 #define SWIGTYPE_p_dumpfile_t swig_types[3]
1484 #define SWIGTYPE_p_float swig_types[4]
1485 #define SWIGTYPE_p_int swig_types[5]
1486 #define SWIGTYPE_p_off_t swig_types[6]
1487 #define SWIGTYPE_p_unsigned_char swig_types[7]
1488 static swig_type_info *swig_types[9];
1489 static swig_module_info swig_module = {swig_types, 8, 0, 0, 0, 0};
1490 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1491 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1493 /* -------- TYPES TABLE (END) -------- */
1495 #define SWIG_init boot_Amanda__Header
1497 #define SWIG_name "Amanda::Headerc::boot_Amanda__Header"
1498 #define SWIG_prefix "Amanda::Headerc::"
1500 #define SWIGVERSION 0x010339
1501 #define SWIG_VERSION SWIGVERSION
1504 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1505 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1512 #ifndef MULTIPLICITY
1513 SWIGEXPORT void SWIG_init (CV* cv);
1515 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1518 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1531 #include "fileheader.h"
1534 SWIGINTERNINLINE SV *
1535 SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value)
1537 SV *obj = sv_newmortal();
1538 sv_setiv(obj, (IV) value);
1543 SWIGINTERNINLINE SV *
1544 SWIG_From_int SWIG_PERL_DECL_ARGS_1(int value)
1546 return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
1551 #if !defined(SWIG_NO_LLONG_MAX)
1552 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1553 # define LLONG_MAX __LONG_LONG_MAX__
1554 # define LLONG_MIN (-LLONG_MAX - 1LL)
1555 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1561 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1564 if (val) *val = SvNV(obj);
1566 } else if (SvIOK(obj)) {
1567 if (val) *val = (double) SvIV(obj);
1568 return SWIG_AddCast(SWIG_OK);
1570 const char *nptr = SvPV_nolen(obj);
1573 double v = strtod(nptr, &endptr);
1574 if (errno == ERANGE) {
1576 return SWIG_OverflowError;
1578 if (*endptr == '\0') {
1580 return SWIG_Str2NumCast(SWIG_OK);
1585 return SWIG_TypeError;
1595 SWIGINTERNINLINE int
1596 SWIG_CanCastAsInteger(double *d, double min, double max) {
1598 if ((min <= x && x <= max)) {
1599 double fx = floor(x);
1600 double cx = ceil(x);
1601 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1602 if ((errno == EDOM) || (errno == ERANGE)) {
1605 double summ, reps, diff;
1608 } else if (rd > x) {
1615 if (reps < 8*DBL_EPSILON) {
1626 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1629 if (val) *val = SvIV(obj);
1633 const char *nptr = SvPV_nolen(obj);
1638 v = strtol(nptr, &endptr,0);
1639 if (errno == ERANGE) {
1641 return SWIG_OverflowError;
1643 if (*endptr == '\0') {
1645 return SWIG_Str2NumCast(SWIG_OK);
1651 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1652 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1653 if (val) *val = (long)(d);
1658 return SWIG_TypeError;
1663 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1666 int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1667 if (SWIG_IsOK(res)) {
1668 if ((v < INT_MIN || v > INT_MAX)) {
1669 return SWIG_OverflowError;
1671 if (val) *val = (int)(v);
1678 SWIGINTERN swig_type_info*
1679 SWIG_pchar_descriptor(void)
1681 static int init = 0;
1682 static swig_type_info* info = 0;
1684 info = SWIG_TypeQuery("_p_char");
1692 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1694 if (SvMAGICAL(obj)) {
1695 SV *tmp = sv_newmortal();
1701 char *cstr = SvPV(obj, len);
1702 size_t size = len + 1;
1705 if (*alloc == SWIG_NEWOBJ) {
1706 *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1709 *alloc = SWIG_OLDOBJ;
1713 if (psize) *psize = size;
1716 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1717 if (pchar_descriptor) {
1719 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1720 if (cptr) *cptr = vptr;
1721 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1722 if (alloc) *alloc = SWIG_OLDOBJ;
1727 return SWIG_TypeError;
1732 SWIG_AsCharArray(SV * obj, char *val, size_t size)
1734 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
1735 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
1736 if (SWIG_IsOK(res)) {
1737 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
1738 if (csize <= size) {
1740 if (csize) memcpy(val, cptr, csize*sizeof(char));
1741 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
1743 if (alloc == SWIG_NEWOBJ) {
1745 res = SWIG_DelNewMask(res);
1749 if (alloc == SWIG_NEWOBJ) free((char*)cptr);
1751 return SWIG_TypeError;
1755 SWIGINTERNINLINE SV *
1756 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1758 SV *obj = sv_newmortal();
1760 sv_setpvn(obj, carray, size);
1762 sv_setsv(obj, &PL_sv_undef);
1771 SWIGINTERNINLINE SV *
1772 SWIG_FromCharPtr(const char *cptr)
1774 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1779 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
1782 if (val) *val = SvUV(obj);
1784 } else if (SvIOK(obj)) {
1790 return SWIG_OverflowError;
1794 const char *nptr = SvPV_nolen(obj);
1799 v = strtoul(nptr, &endptr,0);
1800 if (errno == ERANGE) {
1802 return SWIG_OverflowError;
1804 if (*endptr == '\0') {
1806 return SWIG_Str2NumCast(SWIG_OK);
1812 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1813 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
1814 if (val) *val = (unsigned long)(d);
1819 return SWIG_TypeError;
1823 SWIGINTERNINLINE int
1824 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
1827 int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
1828 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
1832 SWIGINTERN dumpfile_t *new_dumpfile_t(){
1833 dumpfile_t *df = g_new(dumpfile_t, 1);
1835 /* some default values */
1836 df->totalparts = -1;
1840 SWIGINTERN SV *dumpfile_t_to_string(dumpfile_t *self,size_t min_size,size_t max_size){
1841 size_t size = min_size;
1844 result = build_header(self, &size, max_size);
1846 /* header didn't fit -> return undef; */
1847 return &PL_sv_undef;
1849 STRLEN strlen_size = (STRLEN)size;
1851 g_assert((size_t)strlen_size == size); /* check for casting overflow */
1852 sv = sv_2mortal(newSVpvn(result, (STRLEN)size));
1857 SWIGINTERN void dumpfile_t_debug_dump(dumpfile_t *self){
1858 dump_dumpfile_t(self);
1860 SWIGINTERN char *dumpfile_t_summary(dumpfile_t *self){
1861 return summarize_header(self);
1864 static dumpfile_t *C_from_string(const char *string) {
1865 dumpfile_t *result = g_new(dumpfile_t, 1);
1866 parse_file_header(string, result, strlen(string));
1875 #define MAGIC_CLASS _wrap_Amanda__Header_var::
1876 class _wrap_Amanda__Header_var : public CPerlObj {
1881 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
1883 croak("Value is read-only.");
1899 XS(_wrap_Header_type_set) {
1901 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1908 if ((items < 2) || (items > 2)) {
1909 SWIG_croak("Usage: Header_type_set(self,type);");
1911 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
1912 if (!SWIG_IsOK(res1)) {
1913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_type_set" "', argument " "1"" of type '" "dumpfile_t *""'");
1915 arg1 = (dumpfile_t *)(argp1);
1917 if (sizeof(signed int) == 1) {
1918 arg2 = amglue_SvI8(ST(1));
1919 } else if (sizeof(signed int) == 2) {
1920 arg2 = amglue_SvI16(ST(1));
1921 } else if (sizeof(signed int) == 4) {
1922 arg2 = amglue_SvI32(ST(1));
1923 } else if (sizeof(signed int) == 8) {
1924 arg2 = amglue_SvI64(ST(1));
1926 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
1929 if (arg1) (arg1)->type = arg2;
1930 ST(argvi) = sv_newmortal();
1942 XS(_wrap_Header_type_get) {
1944 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1951 if ((items < 1) || (items > 1)) {
1952 SWIG_croak("Usage: Header_type_get(self);");
1954 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
1955 if (!SWIG_IsOK(res1)) {
1956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_type_get" "', argument " "1"" of type '" "dumpfile_t *""'");
1958 arg1 = (dumpfile_t *)(argp1);
1959 result = (filetype_t) ((arg1)->type);
1962 SP += argvi; PUTBACK;
1963 for_stack = sv_2mortal(amglue_newSVi64(result));
1964 SPAGAIN; SP -= argvi;
1965 ST(argvi) = for_stack;
1977 XS(_wrap_Header_datestamp_set) {
1979 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
1983 char temp2[STRMAX] ;
1988 if ((items < 2) || (items > 2)) {
1989 SWIG_croak("Usage: Header_datestamp_set(self,datestamp);");
1991 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
1992 if (!SWIG_IsOK(res1)) {
1993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_datestamp_set" "', argument " "1"" of type '" "dumpfile_t *""'");
1995 arg1 = (dumpfile_t *)(argp1);
1996 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
1997 if (!SWIG_IsOK(res2)) {
1998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_datestamp_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2000 arg2 = (char *)(temp2);
2002 strncpy(arg1->datestamp, arg2, STRMAX);
2003 if (arg1->datestamp[STRMAX-1] != '\0')
2004 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2006 ST(argvi) = sv_newmortal();
2018 XS(_wrap_Header_datestamp_get) {
2020 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2027 if ((items < 1) || (items > 1)) {
2028 SWIG_croak("Usage: Header_datestamp_get(self);");
2030 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2031 if (!SWIG_IsOK(res1)) {
2032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_datestamp_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2034 arg1 = (dumpfile_t *)(argp1);
2035 result = (char *) ((arg1)->datestamp);
2037 size_t size = STRMAX;
2039 while (size && (result[size - 1] == '\0')) --size;
2041 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2052 XS(_wrap_Header_dumplevel_set) {
2054 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2061 if ((items < 2) || (items > 2)) {
2062 SWIG_croak("Usage: Header_dumplevel_set(self,dumplevel);");
2064 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2065 if (!SWIG_IsOK(res1)) {
2066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dumplevel_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2068 arg1 = (dumpfile_t *)(argp1);
2070 if (sizeof(signed int) == 1) {
2071 arg2 = amglue_SvI8(ST(1));
2072 } else if (sizeof(signed int) == 2) {
2073 arg2 = amglue_SvI16(ST(1));
2074 } else if (sizeof(signed int) == 4) {
2075 arg2 = amglue_SvI32(ST(1));
2076 } else if (sizeof(signed int) == 8) {
2077 arg2 = amglue_SvI64(ST(1));
2079 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2082 if (arg1) (arg1)->dumplevel = arg2;
2083 ST(argvi) = sv_newmortal();
2095 XS(_wrap_Header_dumplevel_get) {
2097 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2104 if ((items < 1) || (items > 1)) {
2105 SWIG_croak("Usage: Header_dumplevel_get(self);");
2107 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2108 if (!SWIG_IsOK(res1)) {
2109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dumplevel_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2111 arg1 = (dumpfile_t *)(argp1);
2112 result = (int) ((arg1)->dumplevel);
2115 SP += argvi; PUTBACK;
2116 for_stack = sv_2mortal(amglue_newSVi64(result));
2117 SPAGAIN; SP -= argvi;
2118 ST(argvi) = for_stack;
2130 XS(_wrap_Header_compressed_set) {
2132 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2139 if ((items < 2) || (items > 2)) {
2140 SWIG_croak("Usage: Header_compressed_set(self,compressed);");
2142 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2143 if (!SWIG_IsOK(res1)) {
2144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_compressed_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2146 arg1 = (dumpfile_t *)(argp1);
2148 if (sizeof(signed int) == 1) {
2149 arg2 = amglue_SvI8(ST(1));
2150 } else if (sizeof(signed int) == 2) {
2151 arg2 = amglue_SvI16(ST(1));
2152 } else if (sizeof(signed int) == 4) {
2153 arg2 = amglue_SvI32(ST(1));
2154 } else if (sizeof(signed int) == 8) {
2155 arg2 = amglue_SvI64(ST(1));
2157 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2160 if (arg1) (arg1)->compressed = arg2;
2161 ST(argvi) = sv_newmortal();
2173 XS(_wrap_Header_compressed_get) {
2175 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2182 if ((items < 1) || (items > 1)) {
2183 SWIG_croak("Usage: Header_compressed_get(self);");
2185 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2186 if (!SWIG_IsOK(res1)) {
2187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_compressed_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2189 arg1 = (dumpfile_t *)(argp1);
2190 result = (int) ((arg1)->compressed);
2193 SP += argvi; PUTBACK;
2194 for_stack = sv_2mortal(amglue_newSVi64(result));
2195 SPAGAIN; SP -= argvi;
2196 ST(argvi) = for_stack;
2208 XS(_wrap_Header_encrypted_set) {
2210 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2217 if ((items < 2) || (items > 2)) {
2218 SWIG_croak("Usage: Header_encrypted_set(self,encrypted);");
2220 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2221 if (!SWIG_IsOK(res1)) {
2222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypted_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2224 arg1 = (dumpfile_t *)(argp1);
2226 if (sizeof(signed int) == 1) {
2227 arg2 = amglue_SvI8(ST(1));
2228 } else if (sizeof(signed int) == 2) {
2229 arg2 = amglue_SvI16(ST(1));
2230 } else if (sizeof(signed int) == 4) {
2231 arg2 = amglue_SvI32(ST(1));
2232 } else if (sizeof(signed int) == 8) {
2233 arg2 = amglue_SvI64(ST(1));
2235 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2238 if (arg1) (arg1)->encrypted = arg2;
2239 ST(argvi) = sv_newmortal();
2251 XS(_wrap_Header_encrypted_get) {
2253 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2260 if ((items < 1) || (items > 1)) {
2261 SWIG_croak("Usage: Header_encrypted_get(self);");
2263 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2264 if (!SWIG_IsOK(res1)) {
2265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypted_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2267 arg1 = (dumpfile_t *)(argp1);
2268 result = (int) ((arg1)->encrypted);
2271 SP += argvi; PUTBACK;
2272 for_stack = sv_2mortal(amglue_newSVi64(result));
2273 SPAGAIN; SP -= argvi;
2274 ST(argvi) = for_stack;
2286 XS(_wrap_Header_comp_suffix_set) {
2288 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2292 char temp2[STRMAX] ;
2297 if ((items < 2) || (items > 2)) {
2298 SWIG_croak("Usage: Header_comp_suffix_set(self,comp_suffix);");
2300 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2301 if (!SWIG_IsOK(res1)) {
2302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_comp_suffix_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2304 arg1 = (dumpfile_t *)(argp1);
2305 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2306 if (!SWIG_IsOK(res2)) {
2307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_comp_suffix_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2309 arg2 = (char *)(temp2);
2311 strncpy(arg1->comp_suffix, arg2, STRMAX);
2312 if (arg1->comp_suffix[STRMAX-1] != '\0')
2313 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2315 ST(argvi) = sv_newmortal();
2327 XS(_wrap_Header_comp_suffix_get) {
2329 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2336 if ((items < 1) || (items > 1)) {
2337 SWIG_croak("Usage: Header_comp_suffix_get(self);");
2339 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2340 if (!SWIG_IsOK(res1)) {
2341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_comp_suffix_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2343 arg1 = (dumpfile_t *)(argp1);
2344 result = (char *) ((arg1)->comp_suffix);
2346 size_t size = STRMAX;
2348 while (size && (result[size - 1] == '\0')) --size;
2350 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2361 XS(_wrap_Header_encrypt_suffix_set) {
2363 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2367 char temp2[STRMAX] ;
2372 if ((items < 2) || (items > 2)) {
2373 SWIG_croak("Usage: Header_encrypt_suffix_set(self,encrypt_suffix);");
2375 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2376 if (!SWIG_IsOK(res1)) {
2377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypt_suffix_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2379 arg1 = (dumpfile_t *)(argp1);
2380 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2381 if (!SWIG_IsOK(res2)) {
2382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_encrypt_suffix_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2384 arg2 = (char *)(temp2);
2386 strncpy(arg1->encrypt_suffix, arg2, STRMAX);
2387 if (arg1->encrypt_suffix[STRMAX-1] != '\0')
2388 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2390 ST(argvi) = sv_newmortal();
2402 XS(_wrap_Header_encrypt_suffix_get) {
2404 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2411 if ((items < 1) || (items > 1)) {
2412 SWIG_croak("Usage: Header_encrypt_suffix_get(self);");
2414 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2415 if (!SWIG_IsOK(res1)) {
2416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_encrypt_suffix_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2418 arg1 = (dumpfile_t *)(argp1);
2419 result = (char *) ((arg1)->encrypt_suffix);
2421 size_t size = STRMAX;
2423 while (size && (result[size - 1] == '\0')) --size;
2425 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2436 XS(_wrap_Header_name_set) {
2438 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2442 char temp2[STRMAX] ;
2447 if ((items < 2) || (items > 2)) {
2448 SWIG_croak("Usage: Header_name_set(self,name);");
2450 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2451 if (!SWIG_IsOK(res1)) {
2452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_name_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2454 arg1 = (dumpfile_t *)(argp1);
2455 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2456 if (!SWIG_IsOK(res2)) {
2457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_name_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2459 arg2 = (char *)(temp2);
2461 strncpy(arg1->name, arg2, STRMAX);
2462 if (arg1->name[STRMAX-1] != '\0')
2463 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2465 ST(argvi) = sv_newmortal();
2477 XS(_wrap_Header_name_get) {
2479 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2486 if ((items < 1) || (items > 1)) {
2487 SWIG_croak("Usage: Header_name_get(self);");
2489 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2490 if (!SWIG_IsOK(res1)) {
2491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_name_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2493 arg1 = (dumpfile_t *)(argp1);
2494 result = (char *) ((arg1)->name);
2496 size_t size = STRMAX;
2498 while (size && (result[size - 1] == '\0')) --size;
2500 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2511 XS(_wrap_Header_disk_set) {
2513 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2517 char temp2[STRMAX] ;
2522 if ((items < 2) || (items > 2)) {
2523 SWIG_croak("Usage: Header_disk_set(self,disk);");
2525 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2526 if (!SWIG_IsOK(res1)) {
2527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_disk_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2529 arg1 = (dumpfile_t *)(argp1);
2530 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2531 if (!SWIG_IsOK(res2)) {
2532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_disk_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2534 arg2 = (char *)(temp2);
2536 strncpy(arg1->disk, arg2, STRMAX);
2537 if (arg1->disk[STRMAX-1] != '\0')
2538 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2540 ST(argvi) = sv_newmortal();
2552 XS(_wrap_Header_disk_get) {
2554 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2561 if ((items < 1) || (items > 1)) {
2562 SWIG_croak("Usage: Header_disk_get(self);");
2564 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2565 if (!SWIG_IsOK(res1)) {
2566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_disk_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2568 arg1 = (dumpfile_t *)(argp1);
2569 result = (char *) ((arg1)->disk);
2571 size_t size = STRMAX;
2573 while (size && (result[size - 1] == '\0')) --size;
2575 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2586 XS(_wrap_Header_program_set) {
2588 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2592 char temp2[STRMAX] ;
2597 if ((items < 2) || (items > 2)) {
2598 SWIG_croak("Usage: Header_program_set(self,program);");
2600 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2601 if (!SWIG_IsOK(res1)) {
2602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_program_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2604 arg1 = (dumpfile_t *)(argp1);
2605 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2606 if (!SWIG_IsOK(res2)) {
2607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_program_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2609 arg2 = (char *)(temp2);
2611 strncpy(arg1->program, arg2, STRMAX);
2612 if (arg1->program[STRMAX-1] != '\0')
2613 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2615 ST(argvi) = sv_newmortal();
2627 XS(_wrap_Header_program_get) {
2629 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2636 if ((items < 1) || (items > 1)) {
2637 SWIG_croak("Usage: Header_program_get(self);");
2639 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2640 if (!SWIG_IsOK(res1)) {
2641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_program_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2643 arg1 = (dumpfile_t *)(argp1);
2644 result = (char *) ((arg1)->program);
2646 size_t size = STRMAX;
2648 while (size && (result[size - 1] == '\0')) --size;
2650 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2661 XS(_wrap_Header_application_set) {
2663 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2667 char temp2[STRMAX] ;
2672 if ((items < 2) || (items > 2)) {
2673 SWIG_croak("Usage: Header_application_set(self,application);");
2675 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2676 if (!SWIG_IsOK(res1)) {
2677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_application_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2679 arg1 = (dumpfile_t *)(argp1);
2680 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2681 if (!SWIG_IsOK(res2)) {
2682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_application_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2684 arg2 = (char *)(temp2);
2686 strncpy(arg1->application, arg2, STRMAX);
2687 if (arg1->application[STRMAX-1] != '\0')
2688 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2690 ST(argvi) = sv_newmortal();
2702 XS(_wrap_Header_application_get) {
2704 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2711 if ((items < 1) || (items > 1)) {
2712 SWIG_croak("Usage: Header_application_get(self);");
2714 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2715 if (!SWIG_IsOK(res1)) {
2716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_application_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2718 arg1 = (dumpfile_t *)(argp1);
2719 result = (char *) ((arg1)->application);
2721 size_t size = STRMAX;
2723 while (size && (result[size - 1] == '\0')) --size;
2725 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2736 XS(_wrap_Header_srvcompprog_set) {
2738 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2742 char temp2[STRMAX] ;
2747 if ((items < 2) || (items > 2)) {
2748 SWIG_croak("Usage: Header_srvcompprog_set(self,srvcompprog);");
2750 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2751 if (!SWIG_IsOK(res1)) {
2752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srvcompprog_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2754 arg1 = (dumpfile_t *)(argp1);
2755 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2756 if (!SWIG_IsOK(res2)) {
2757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srvcompprog_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2759 arg2 = (char *)(temp2);
2761 strncpy(arg1->srvcompprog, arg2, STRMAX);
2762 if (arg1->srvcompprog[STRMAX-1] != '\0')
2763 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2765 ST(argvi) = sv_newmortal();
2777 XS(_wrap_Header_srvcompprog_get) {
2779 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2786 if ((items < 1) || (items > 1)) {
2787 SWIG_croak("Usage: Header_srvcompprog_get(self);");
2789 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2790 if (!SWIG_IsOK(res1)) {
2791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srvcompprog_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2793 arg1 = (dumpfile_t *)(argp1);
2794 result = (char *) ((arg1)->srvcompprog);
2796 size_t size = STRMAX;
2798 while (size && (result[size - 1] == '\0')) --size;
2800 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2811 XS(_wrap_Header_clntcompprog_set) {
2813 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2817 char temp2[STRMAX] ;
2822 if ((items < 2) || (items > 2)) {
2823 SWIG_croak("Usage: Header_clntcompprog_set(self,clntcompprog);");
2825 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2826 if (!SWIG_IsOK(res1)) {
2827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clntcompprog_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2829 arg1 = (dumpfile_t *)(argp1);
2830 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2831 if (!SWIG_IsOK(res2)) {
2832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clntcompprog_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2834 arg2 = (char *)(temp2);
2836 strncpy(arg1->clntcompprog, arg2, STRMAX);
2837 if (arg1->clntcompprog[STRMAX-1] != '\0')
2838 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2840 ST(argvi) = sv_newmortal();
2852 XS(_wrap_Header_clntcompprog_get) {
2854 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2861 if ((items < 1) || (items > 1)) {
2862 SWIG_croak("Usage: Header_clntcompprog_get(self);");
2864 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2865 if (!SWIG_IsOK(res1)) {
2866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clntcompprog_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2868 arg1 = (dumpfile_t *)(argp1);
2869 result = (char *) ((arg1)->clntcompprog);
2871 size_t size = STRMAX;
2873 while (size && (result[size - 1] == '\0')) --size;
2875 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2886 XS(_wrap_Header_srv_encrypt_set) {
2888 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2892 char temp2[STRMAX] ;
2897 if ((items < 2) || (items > 2)) {
2898 SWIG_croak("Usage: Header_srv_encrypt_set(self,srv_encrypt);");
2900 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2901 if (!SWIG_IsOK(res1)) {
2902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_encrypt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2904 arg1 = (dumpfile_t *)(argp1);
2905 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2906 if (!SWIG_IsOK(res2)) {
2907 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srv_encrypt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2909 arg2 = (char *)(temp2);
2911 strncpy(arg1->srv_encrypt, arg2, STRMAX);
2912 if (arg1->srv_encrypt[STRMAX-1] != '\0')
2913 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2915 ST(argvi) = sv_newmortal();
2927 XS(_wrap_Header_srv_encrypt_get) {
2929 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2936 if ((items < 1) || (items > 1)) {
2937 SWIG_croak("Usage: Header_srv_encrypt_get(self);");
2939 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2940 if (!SWIG_IsOK(res1)) {
2941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_encrypt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
2943 arg1 = (dumpfile_t *)(argp1);
2944 result = (char *) ((arg1)->srv_encrypt);
2946 size_t size = STRMAX;
2948 while (size && (result[size - 1] == '\0')) --size;
2950 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
2961 XS(_wrap_Header_clnt_encrypt_set) {
2963 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
2967 char temp2[STRMAX] ;
2972 if ((items < 2) || (items > 2)) {
2973 SWIG_croak("Usage: Header_clnt_encrypt_set(self,clnt_encrypt);");
2975 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2976 if (!SWIG_IsOK(res1)) {
2977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_encrypt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
2979 arg1 = (dumpfile_t *)(argp1);
2980 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
2981 if (!SWIG_IsOK(res2)) {
2982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clnt_encrypt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
2984 arg2 = (char *)(temp2);
2986 strncpy(arg1->clnt_encrypt, arg2, STRMAX);
2987 if (arg1->clnt_encrypt[STRMAX-1] != '\0')
2988 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
2990 ST(argvi) = sv_newmortal();
3002 XS(_wrap_Header_clnt_encrypt_get) {
3004 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3011 if ((items < 1) || (items > 1)) {
3012 SWIG_croak("Usage: Header_clnt_encrypt_get(self);");
3014 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3015 if (!SWIG_IsOK(res1)) {
3016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_encrypt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3018 arg1 = (dumpfile_t *)(argp1);
3019 result = (char *) ((arg1)->clnt_encrypt);
3021 size_t size = STRMAX;
3023 while (size && (result[size - 1] == '\0')) --size;
3025 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3036 XS(_wrap_Header_recover_cmd_set) {
3038 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3042 char temp2[STRMAX] ;
3047 if ((items < 2) || (items > 2)) {
3048 SWIG_croak("Usage: Header_recover_cmd_set(self,recover_cmd);");
3050 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3051 if (!SWIG_IsOK(res1)) {
3052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_recover_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3054 arg1 = (dumpfile_t *)(argp1);
3055 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3056 if (!SWIG_IsOK(res2)) {
3057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_recover_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3059 arg2 = (char *)(temp2);
3061 strncpy(arg1->recover_cmd, arg2, STRMAX);
3062 if (arg1->recover_cmd[STRMAX-1] != '\0')
3063 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3065 ST(argvi) = sv_newmortal();
3077 XS(_wrap_Header_recover_cmd_get) {
3079 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3086 if ((items < 1) || (items > 1)) {
3087 SWIG_croak("Usage: Header_recover_cmd_get(self);");
3089 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3090 if (!SWIG_IsOK(res1)) {
3091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_recover_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3093 arg1 = (dumpfile_t *)(argp1);
3094 result = (char *) ((arg1)->recover_cmd);
3096 size_t size = STRMAX;
3098 while (size && (result[size - 1] == '\0')) --size;
3100 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3111 XS(_wrap_Header_uncompress_cmd_set) {
3113 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3117 char temp2[STRMAX] ;
3122 if ((items < 2) || (items > 2)) {
3123 SWIG_croak("Usage: Header_uncompress_cmd_set(self,uncompress_cmd);");
3125 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3126 if (!SWIG_IsOK(res1)) {
3127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_uncompress_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3129 arg1 = (dumpfile_t *)(argp1);
3130 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3131 if (!SWIG_IsOK(res2)) {
3132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_uncompress_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3134 arg2 = (char *)(temp2);
3136 strncpy(arg1->uncompress_cmd, arg2, STRMAX);
3137 if (arg1->uncompress_cmd[STRMAX-1] != '\0')
3138 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3140 ST(argvi) = sv_newmortal();
3152 XS(_wrap_Header_uncompress_cmd_get) {
3154 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3161 if ((items < 1) || (items > 1)) {
3162 SWIG_croak("Usage: Header_uncompress_cmd_get(self);");
3164 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3165 if (!SWIG_IsOK(res1)) {
3166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_uncompress_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3168 arg1 = (dumpfile_t *)(argp1);
3169 result = (char *) ((arg1)->uncompress_cmd);
3171 size_t size = STRMAX;
3173 while (size && (result[size - 1] == '\0')) --size;
3175 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3186 XS(_wrap_Header_decrypt_cmd_set) {
3188 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3192 char temp2[STRMAX] ;
3197 if ((items < 2) || (items > 2)) {
3198 SWIG_croak("Usage: Header_decrypt_cmd_set(self,decrypt_cmd);");
3200 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3201 if (!SWIG_IsOK(res1)) {
3202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_decrypt_cmd_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3204 arg1 = (dumpfile_t *)(argp1);
3205 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3206 if (!SWIG_IsOK(res2)) {
3207 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_decrypt_cmd_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3209 arg2 = (char *)(temp2);
3211 strncpy(arg1->decrypt_cmd, arg2, STRMAX);
3212 if (arg1->decrypt_cmd[STRMAX-1] != '\0')
3213 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3215 ST(argvi) = sv_newmortal();
3227 XS(_wrap_Header_decrypt_cmd_get) {
3229 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3236 if ((items < 1) || (items > 1)) {
3237 SWIG_croak("Usage: Header_decrypt_cmd_get(self);");
3239 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3240 if (!SWIG_IsOK(res1)) {
3241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_decrypt_cmd_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3243 arg1 = (dumpfile_t *)(argp1);
3244 result = (char *) ((arg1)->decrypt_cmd);
3246 size_t size = STRMAX;
3248 while (size && (result[size - 1] == '\0')) --size;
3250 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3261 XS(_wrap_Header_srv_decrypt_opt_set) {
3263 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3267 char temp2[STRMAX] ;
3272 if ((items < 2) || (items > 2)) {
3273 SWIG_croak("Usage: Header_srv_decrypt_opt_set(self,srv_decrypt_opt);");
3275 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3276 if (!SWIG_IsOK(res1)) {
3277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_decrypt_opt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3279 arg1 = (dumpfile_t *)(argp1);
3280 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3281 if (!SWIG_IsOK(res2)) {
3282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_srv_decrypt_opt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3284 arg2 = (char *)(temp2);
3286 strncpy(arg1->srv_decrypt_opt, arg2, STRMAX);
3287 if (arg1->srv_decrypt_opt[STRMAX-1] != '\0')
3288 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3290 ST(argvi) = sv_newmortal();
3302 XS(_wrap_Header_srv_decrypt_opt_get) {
3304 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3311 if ((items < 1) || (items > 1)) {
3312 SWIG_croak("Usage: Header_srv_decrypt_opt_get(self);");
3314 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3315 if (!SWIG_IsOK(res1)) {
3316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_srv_decrypt_opt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3318 arg1 = (dumpfile_t *)(argp1);
3319 result = (char *) ((arg1)->srv_decrypt_opt);
3321 size_t size = STRMAX;
3323 while (size && (result[size - 1] == '\0')) --size;
3325 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3336 XS(_wrap_Header_clnt_decrypt_opt_set) {
3338 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3342 char temp2[STRMAX] ;
3347 if ((items < 2) || (items > 2)) {
3348 SWIG_croak("Usage: Header_clnt_decrypt_opt_set(self,clnt_decrypt_opt);");
3350 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3351 if (!SWIG_IsOK(res1)) {
3352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_decrypt_opt_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3354 arg1 = (dumpfile_t *)(argp1);
3355 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3356 if (!SWIG_IsOK(res2)) {
3357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_clnt_decrypt_opt_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3359 arg2 = (char *)(temp2);
3361 strncpy(arg1->clnt_decrypt_opt, arg2, STRMAX);
3362 if (arg1->clnt_decrypt_opt[STRMAX-1] != '\0')
3363 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3365 ST(argvi) = sv_newmortal();
3377 XS(_wrap_Header_clnt_decrypt_opt_get) {
3379 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3386 if ((items < 1) || (items > 1)) {
3387 SWIG_croak("Usage: Header_clnt_decrypt_opt_get(self);");
3389 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3390 if (!SWIG_IsOK(res1)) {
3391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_clnt_decrypt_opt_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3393 arg1 = (dumpfile_t *)(argp1);
3394 result = (char *) ((arg1)->clnt_decrypt_opt);
3396 size_t size = STRMAX;
3398 while (size && (result[size - 1] == '\0')) --size;
3400 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3411 XS(_wrap_Header_cont_filename_set) {
3413 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3417 char temp2[STRMAX] ;
3422 if ((items < 2) || (items > 2)) {
3423 SWIG_croak("Usage: Header_cont_filename_set(self,cont_filename);");
3425 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3426 if (!SWIG_IsOK(res1)) {
3427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_cont_filename_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3429 arg1 = (dumpfile_t *)(argp1);
3430 res2 = SWIG_AsCharArray(ST(1), temp2, STRMAX);
3431 if (!SWIG_IsOK(res2)) {
3432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_cont_filename_set" "', argument " "2"" of type '" "char [STRMAX]""'");
3434 arg2 = (char *)(temp2);
3436 strncpy(arg1->cont_filename, arg2, STRMAX);
3437 if (arg1->cont_filename[STRMAX-1] != '\0')
3438 SWIG_exception(SWIG_ValueError, "String too large for Amanda::Header");
3440 ST(argvi) = sv_newmortal();
3452 XS(_wrap_Header_cont_filename_get) {
3454 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3461 if ((items < 1) || (items > 1)) {
3462 SWIG_croak("Usage: Header_cont_filename_get(self);");
3464 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3465 if (!SWIG_IsOK(res1)) {
3466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_cont_filename_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3468 arg1 = (dumpfile_t *)(argp1);
3469 result = (char *) ((arg1)->cont_filename);
3471 size_t size = STRMAX;
3473 while (size && (result[size - 1] == '\0')) --size;
3475 ST(argvi) = SWIG_FromCharPtrAndSize(result, size); argvi++ ;
3486 XS(_wrap_Header_dle_str_set) {
3488 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3489 char *arg2 = (char *) 0 ;
3498 if ((items < 2) || (items > 2)) {
3499 SWIG_croak("Usage: Header_dle_str_set(self,dle_str);");
3501 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3502 if (!SWIG_IsOK(res1)) {
3503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dle_str_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3505 arg1 = (dumpfile_t *)(argp1);
3506 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
3507 if (!SWIG_IsOK(res2)) {
3508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Header_dle_str_set" "', argument " "2"" of type '" "char *""'");
3510 arg2 = (char *)(buf2);
3511 if (arg1->dle_str) free((char*)arg1->dle_str);
3513 size_t size = strlen((const char *)(arg2)) + 1;
3514 arg1->dle_str = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
3518 ST(argvi) = sv_newmortal();
3520 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3524 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3530 XS(_wrap_Header_dle_str_get) {
3532 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3539 if ((items < 1) || (items > 1)) {
3540 SWIG_croak("Usage: Header_dle_str_get(self);");
3542 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3543 if (!SWIG_IsOK(res1)) {
3544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_dle_str_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3546 arg1 = (dumpfile_t *)(argp1);
3547 result = (char *) ((arg1)->dle_str);
3548 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3558 XS(_wrap_Header_is_partial_set) {
3560 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3567 if ((items < 2) || (items > 2)) {
3568 SWIG_croak("Usage: Header_is_partial_set(self,is_partial);");
3570 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3571 if (!SWIG_IsOK(res1)) {
3572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_is_partial_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3574 arg1 = (dumpfile_t *)(argp1);
3576 if (sizeof(signed int) == 1) {
3577 arg2 = amglue_SvI8(ST(1));
3578 } else if (sizeof(signed int) == 2) {
3579 arg2 = amglue_SvI16(ST(1));
3580 } else if (sizeof(signed int) == 4) {
3581 arg2 = amglue_SvI32(ST(1));
3582 } else if (sizeof(signed int) == 8) {
3583 arg2 = amglue_SvI64(ST(1));
3585 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3588 if (arg1) (arg1)->is_partial = arg2;
3589 ST(argvi) = sv_newmortal();
3601 XS(_wrap_Header_is_partial_get) {
3603 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3610 if ((items < 1) || (items > 1)) {
3611 SWIG_croak("Usage: Header_is_partial_get(self);");
3613 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3614 if (!SWIG_IsOK(res1)) {
3615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_is_partial_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3617 arg1 = (dumpfile_t *)(argp1);
3618 result = (int) ((arg1)->is_partial);
3621 SP += argvi; PUTBACK;
3622 for_stack = sv_2mortal(amglue_newSVi64(result));
3623 SPAGAIN; SP -= argvi;
3624 ST(argvi) = for_stack;
3636 XS(_wrap_Header_partnum_set) {
3638 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3645 if ((items < 2) || (items > 2)) {
3646 SWIG_croak("Usage: Header_partnum_set(self,partnum);");
3648 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3649 if (!SWIG_IsOK(res1)) {
3650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_partnum_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3652 arg1 = (dumpfile_t *)(argp1);
3654 if (sizeof(signed int) == 1) {
3655 arg2 = amglue_SvI8(ST(1));
3656 } else if (sizeof(signed int) == 2) {
3657 arg2 = amglue_SvI16(ST(1));
3658 } else if (sizeof(signed int) == 4) {
3659 arg2 = amglue_SvI32(ST(1));
3660 } else if (sizeof(signed int) == 8) {
3661 arg2 = amglue_SvI64(ST(1));
3663 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3666 if (arg1) (arg1)->partnum = arg2;
3667 ST(argvi) = sv_newmortal();
3679 XS(_wrap_Header_partnum_get) {
3681 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3688 if ((items < 1) || (items > 1)) {
3689 SWIG_croak("Usage: Header_partnum_get(self);");
3691 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3692 if (!SWIG_IsOK(res1)) {
3693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_partnum_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3695 arg1 = (dumpfile_t *)(argp1);
3696 result = (int) ((arg1)->partnum);
3699 SP += argvi; PUTBACK;
3700 for_stack = sv_2mortal(amglue_newSVi64(result));
3701 SPAGAIN; SP -= argvi;
3702 ST(argvi) = for_stack;
3714 XS(_wrap_Header_totalparts_set) {
3716 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3723 if ((items < 2) || (items > 2)) {
3724 SWIG_croak("Usage: Header_totalparts_set(self,totalparts);");
3726 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3727 if (!SWIG_IsOK(res1)) {
3728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_totalparts_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3730 arg1 = (dumpfile_t *)(argp1);
3732 if (sizeof(signed int) == 1) {
3733 arg2 = amglue_SvI8(ST(1));
3734 } else if (sizeof(signed int) == 2) {
3735 arg2 = amglue_SvI16(ST(1));
3736 } else if (sizeof(signed int) == 4) {
3737 arg2 = amglue_SvI32(ST(1));
3738 } else if (sizeof(signed int) == 8) {
3739 arg2 = amglue_SvI64(ST(1));
3741 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3744 if (arg1) (arg1)->totalparts = arg2;
3745 ST(argvi) = sv_newmortal();
3757 XS(_wrap_Header_totalparts_get) {
3759 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3766 if ((items < 1) || (items > 1)) {
3767 SWIG_croak("Usage: Header_totalparts_get(self);");
3769 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3770 if (!SWIG_IsOK(res1)) {
3771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_totalparts_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3773 arg1 = (dumpfile_t *)(argp1);
3774 result = (int) ((arg1)->totalparts);
3777 SP += argvi; PUTBACK;
3778 for_stack = sv_2mortal(amglue_newSVi64(result));
3779 SPAGAIN; SP -= argvi;
3780 ST(argvi) = for_stack;
3792 XS(_wrap_Header_blocksize_set) {
3794 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3801 if ((items < 2) || (items > 2)) {
3802 SWIG_croak("Usage: Header_blocksize_set(self,blocksize);");
3804 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3805 if (!SWIG_IsOK(res1)) {
3806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_blocksize_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3808 arg1 = (dumpfile_t *)(argp1);
3810 if (sizeof(size_t) == 1) {
3811 arg2 = amglue_SvU8(ST(1));
3812 } else if (sizeof(size_t) == 2) {
3813 arg2 = amglue_SvU16(ST(1));
3814 } else if (sizeof(size_t) == 4) {
3815 arg2 = amglue_SvU32(ST(1));
3816 } else if (sizeof(size_t) == 8) {
3817 arg2 = amglue_SvU64(ST(1));
3819 croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
3822 if (arg1) (arg1)->blocksize = arg2;
3823 ST(argvi) = sv_newmortal();
3835 XS(_wrap_Header_blocksize_get) {
3837 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3844 if ((items < 1) || (items > 1)) {
3845 SWIG_croak("Usage: Header_blocksize_get(self);");
3847 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3848 if (!SWIG_IsOK(res1)) {
3849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_blocksize_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3851 arg1 = (dumpfile_t *)(argp1);
3852 result = ((arg1)->blocksize);
3855 SP += argvi; PUTBACK;
3856 for_stack = sv_2mortal(amglue_newSVu64(result));
3857 SPAGAIN; SP -= argvi;
3858 ST(argvi) = for_stack;
3870 XS(_wrap_Header_orig_size_set) {
3872 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3879 if ((items < 2) || (items > 2)) {
3880 SWIG_croak("Usage: Header_orig_size_set(self,orig_size);");
3882 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3883 if (!SWIG_IsOK(res1)) {
3884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_orig_size_set" "', argument " "1"" of type '" "dumpfile_t *""'");
3886 arg1 = (dumpfile_t *)(argp1);
3888 if (sizeof(off_t) == 1) {
3889 arg2 = amglue_SvU8(ST(1));
3890 } else if (sizeof(off_t) == 2) {
3891 arg2 = amglue_SvU16(ST(1));
3892 } else if (sizeof(off_t) == 4) {
3893 arg2 = amglue_SvU32(ST(1));
3894 } else if (sizeof(off_t) == 8) {
3895 arg2 = amglue_SvU64(ST(1));
3897 croak("Unexpected off_t >64 bits?"); /* should be optimized out unless sizeof(off_t) > 8 */
3900 if (arg1) (arg1)->orig_size = arg2;
3901 ST(argvi) = sv_newmortal();
3911 XS(_wrap_Header_orig_size_get) {
3913 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3920 if ((items < 1) || (items > 1)) {
3921 SWIG_croak("Usage: Header_orig_size_get(self);");
3923 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3924 if (!SWIG_IsOK(res1)) {
3925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_orig_size_get" "', argument " "1"" of type '" "dumpfile_t *""'");
3927 arg1 = (dumpfile_t *)(argp1);
3928 result = ((arg1)->orig_size);
3931 SP += argvi; PUTBACK;
3932 for_stack = sv_2mortal(amglue_newSVu64(result));
3933 SPAGAIN; SP -= argvi;
3934 ST(argvi) = for_stack;
3946 XS(_wrap_new_Header) {
3949 dumpfile_t *result = 0 ;
3952 if ((items < 0) || (items > 0)) {
3953 SWIG_croak("Usage: new_Header();");
3955 result = (dumpfile_t *)new_dumpfile_t();
3956 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3964 XS(_wrap_Header_to_string) {
3966 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
3975 if ((items < 3) || (items > 3)) {
3976 SWIG_croak("Usage: Header_to_string(self,min_size,max_size);");
3978 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
3979 if (!SWIG_IsOK(res1)) {
3980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_to_string" "', argument " "1"" of type '" "dumpfile_t *""'");
3982 arg1 = (dumpfile_t *)(argp1);
3984 if (sizeof(size_t) == 1) {
3985 arg2 = amglue_SvU8(ST(1));
3986 } else if (sizeof(size_t) == 2) {
3987 arg2 = amglue_SvU16(ST(1));
3988 } else if (sizeof(size_t) == 4) {
3989 arg2 = amglue_SvU32(ST(1));
3990 } else if (sizeof(size_t) == 8) {
3991 arg2 = amglue_SvU64(ST(1));
3993 croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
3997 if (sizeof(size_t) == 1) {
3998 arg3 = amglue_SvU8(ST(2));
3999 } else if (sizeof(size_t) == 2) {
4000 arg3 = amglue_SvU16(ST(2));
4001 } else if (sizeof(size_t) == 4) {
4002 arg3 = amglue_SvU32(ST(2));
4003 } else if (sizeof(size_t) == 8) {
4004 arg3 = amglue_SvU64(ST(2));
4006 croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
4009 result = (SV *)dumpfile_t_to_string(arg1,arg2,arg3);
4010 ST(argvi) = result; argvi++;
4024 XS(_wrap_Header_debug_dump) {
4026 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4032 if ((items < 1) || (items > 1)) {
4033 SWIG_croak("Usage: Header_debug_dump(self);");
4035 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
4036 if (!SWIG_IsOK(res1)) {
4037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_debug_dump" "', argument " "1"" of type '" "dumpfile_t *""'");
4039 arg1 = (dumpfile_t *)(argp1);
4040 dumpfile_t_debug_dump(arg1);
4041 ST(argvi) = sv_newmortal();
4051 XS(_wrap_Header_summary) {
4053 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4060 if ((items < 1) || (items > 1)) {
4061 SWIG_croak("Usage: Header_summary(self);");
4063 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, 0 | 0 );
4064 if (!SWIG_IsOK(res1)) {
4065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Header_summary" "', argument " "1"" of type '" "dumpfile_t *""'");
4067 arg1 = (dumpfile_t *)(argp1);
4068 result = (char *)dumpfile_t_summary(arg1);
4069 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4071 free((char*)result);
4080 XS(_wrap_delete_Header__SWIG_1) {
4082 dumpfile_t *arg1 = (dumpfile_t *) 0 ;
4088 if ((items < 1) || (items > 1)) {
4089 SWIG_croak("Usage: delete_Header(self);");
4091 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_dumpfile_t, SWIG_POINTER_DISOWN | 0 );
4092 if (!SWIG_IsOK(res1)) {
4093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Header" "', argument " "1"" of type '" "dumpfile_t *""'");
4095 arg1 = (dumpfile_t *)(argp1);
4096 free((char *) arg1);
4097 ST(argvi) = sv_newmortal();
4107 XS(_wrap_delete_Header) {
4111 unsigned long _index = 0;
4112 SWIG_TypeRank _rank = 0;
4114 SWIG_TypeRank _ranki = 0;
4115 SWIG_TypeRank _rankm = 0;
4116 SWIG_TypeRank _pi = 1;
4120 int res = SWIG_ConvertPtr(ST(0), &vptr, SWIGTYPE_p_dumpfile_t, 0);
4121 _v = SWIG_CheckState(res);
4123 if (!_v) goto check_1;
4126 _pi *= SWIG_MAXCASTRANK;
4127 if (!_index || (_ranki < _rank)) {
4128 _rank = _ranki; _index = 1;
4129 if (_rank == _rankm) goto dispatch;
4137 ++PL_markstack_ptr; SWIG_CALLXS(_wrap_delete_Header__SWIG_1); return;
4141 croak("No matching function for overloaded 'delete_Header'");
4146 XS(_wrap_C_from_string) {
4148 char *arg1 = (char *) 0 ;
4153 dumpfile_t *result = 0 ;
4156 if ((items < 1) || (items > 1)) {
4157 SWIG_croak("Usage: C_from_string(string);");
4159 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
4160 if (!SWIG_IsOK(res1)) {
4161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "C_from_string" "', argument " "1"" of type '" "char const *""'");
4163 arg1 = (char *)(buf1);
4164 result = (dumpfile_t *)C_from_string((char const *)arg1);
4165 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
4166 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4169 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
4176 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4178 static swig_type_info _swigt__p_a_STRMAX__char = {"_p_a_STRMAX__char", "char (*)[STRMAX]|string_t *", 0, 0, (void*)0, 0};
4179 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
4180 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
4181 static swig_type_info _swigt__p_dumpfile_t = {"_p_dumpfile_t", "dumpfile_t *", 0, 0, (void*)"Amanda::Header::Header", 0};
4182 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
4183 static swig_type_info _swigt__p_int = {"_p_int", "int *|filetype_t *|gboolean *", 0, 0, (void*)0, 0};
4184 static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *", 0, 0, (void*)0, 0};
4185 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
4187 static swig_type_info *swig_type_initial[] = {
4188 &_swigt__p_a_STRMAX__char,
4191 &_swigt__p_dumpfile_t,
4195 &_swigt__p_unsigned_char,
4198 static swig_cast_info _swigc__p_a_STRMAX__char[] = { {&_swigt__p_a_STRMAX__char, 0, 0, 0},{0, 0, 0, 0}};
4199 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4200 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
4201 static swig_cast_info _swigc__p_dumpfile_t[] = { {&_swigt__p_dumpfile_t, 0, 0, 0},{0, 0, 0, 0}};
4202 static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
4203 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
4204 static swig_cast_info _swigc__p_off_t[] = { {&_swigt__p_off_t, 0, 0, 0},{0, 0, 0, 0}};
4205 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
4207 static swig_cast_info *swig_cast_initial[] = {
4208 _swigc__p_a_STRMAX__char,
4211 _swigc__p_dumpfile_t,
4215 _swigc__p_unsigned_char,
4219 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4221 static swig_constant_info swig_constants[] = {
4227 static swig_variable_info swig_variables[] = {
4230 static swig_command_info swig_commands[] = {
4231 {"Amanda::Headerc::Header_type_set", _wrap_Header_type_set},
4232 {"Amanda::Headerc::Header_type_get", _wrap_Header_type_get},
4233 {"Amanda::Headerc::Header_datestamp_set", _wrap_Header_datestamp_set},
4234 {"Amanda::Headerc::Header_datestamp_get", _wrap_Header_datestamp_get},
4235 {"Amanda::Headerc::Header_dumplevel_set", _wrap_Header_dumplevel_set},
4236 {"Amanda::Headerc::Header_dumplevel_get", _wrap_Header_dumplevel_get},
4237 {"Amanda::Headerc::Header_compressed_set", _wrap_Header_compressed_set},
4238 {"Amanda::Headerc::Header_compressed_get", _wrap_Header_compressed_get},
4239 {"Amanda::Headerc::Header_encrypted_set", _wrap_Header_encrypted_set},
4240 {"Amanda::Headerc::Header_encrypted_get", _wrap_Header_encrypted_get},
4241 {"Amanda::Headerc::Header_comp_suffix_set", _wrap_Header_comp_suffix_set},
4242 {"Amanda::Headerc::Header_comp_suffix_get", _wrap_Header_comp_suffix_get},
4243 {"Amanda::Headerc::Header_encrypt_suffix_set", _wrap_Header_encrypt_suffix_set},
4244 {"Amanda::Headerc::Header_encrypt_suffix_get", _wrap_Header_encrypt_suffix_get},
4245 {"Amanda::Headerc::Header_name_set", _wrap_Header_name_set},
4246 {"Amanda::Headerc::Header_name_get", _wrap_Header_name_get},
4247 {"Amanda::Headerc::Header_disk_set", _wrap_Header_disk_set},
4248 {"Amanda::Headerc::Header_disk_get", _wrap_Header_disk_get},
4249 {"Amanda::Headerc::Header_program_set", _wrap_Header_program_set},
4250 {"Amanda::Headerc::Header_program_get", _wrap_Header_program_get},
4251 {"Amanda::Headerc::Header_application_set", _wrap_Header_application_set},
4252 {"Amanda::Headerc::Header_application_get", _wrap_Header_application_get},
4253 {"Amanda::Headerc::Header_srvcompprog_set", _wrap_Header_srvcompprog_set},
4254 {"Amanda::Headerc::Header_srvcompprog_get", _wrap_Header_srvcompprog_get},
4255 {"Amanda::Headerc::Header_clntcompprog_set", _wrap_Header_clntcompprog_set},
4256 {"Amanda::Headerc::Header_clntcompprog_get", _wrap_Header_clntcompprog_get},
4257 {"Amanda::Headerc::Header_srv_encrypt_set", _wrap_Header_srv_encrypt_set},
4258 {"Amanda::Headerc::Header_srv_encrypt_get", _wrap_Header_srv_encrypt_get},
4259 {"Amanda::Headerc::Header_clnt_encrypt_set", _wrap_Header_clnt_encrypt_set},
4260 {"Amanda::Headerc::Header_clnt_encrypt_get", _wrap_Header_clnt_encrypt_get},
4261 {"Amanda::Headerc::Header_recover_cmd_set", _wrap_Header_recover_cmd_set},
4262 {"Amanda::Headerc::Header_recover_cmd_get", _wrap_Header_recover_cmd_get},
4263 {"Amanda::Headerc::Header_uncompress_cmd_set", _wrap_Header_uncompress_cmd_set},
4264 {"Amanda::Headerc::Header_uncompress_cmd_get", _wrap_Header_uncompress_cmd_get},
4265 {"Amanda::Headerc::Header_decrypt_cmd_set", _wrap_Header_decrypt_cmd_set},
4266 {"Amanda::Headerc::Header_decrypt_cmd_get", _wrap_Header_decrypt_cmd_get},
4267 {"Amanda::Headerc::Header_srv_decrypt_opt_set", _wrap_Header_srv_decrypt_opt_set},
4268 {"Amanda::Headerc::Header_srv_decrypt_opt_get", _wrap_Header_srv_decrypt_opt_get},
4269 {"Amanda::Headerc::Header_clnt_decrypt_opt_set", _wrap_Header_clnt_decrypt_opt_set},
4270 {"Amanda::Headerc::Header_clnt_decrypt_opt_get", _wrap_Header_clnt_decrypt_opt_get},
4271 {"Amanda::Headerc::Header_cont_filename_set", _wrap_Header_cont_filename_set},
4272 {"Amanda::Headerc::Header_cont_filename_get", _wrap_Header_cont_filename_get},
4273 {"Amanda::Headerc::Header_dle_str_set", _wrap_Header_dle_str_set},
4274 {"Amanda::Headerc::Header_dle_str_get", _wrap_Header_dle_str_get},
4275 {"Amanda::Headerc::Header_is_partial_set", _wrap_Header_is_partial_set},
4276 {"Amanda::Headerc::Header_is_partial_get", _wrap_Header_is_partial_get},
4277 {"Amanda::Headerc::Header_partnum_set", _wrap_Header_partnum_set},
4278 {"Amanda::Headerc::Header_partnum_get", _wrap_Header_partnum_get},
4279 {"Amanda::Headerc::Header_totalparts_set", _wrap_Header_totalparts_set},
4280 {"Amanda::Headerc::Header_totalparts_get", _wrap_Header_totalparts_get},
4281 {"Amanda::Headerc::Header_blocksize_set", _wrap_Header_blocksize_set},
4282 {"Amanda::Headerc::Header_blocksize_get", _wrap_Header_blocksize_get},
4283 {"Amanda::Headerc::Header_orig_size_set", _wrap_Header_orig_size_set},
4284 {"Amanda::Headerc::Header_orig_size_get", _wrap_Header_orig_size_get},
4285 {"Amanda::Headerc::new_Header", _wrap_new_Header},
4286 {"Amanda::Headerc::Header_to_string", _wrap_Header_to_string},
4287 {"Amanda::Headerc::Header_debug_dump", _wrap_Header_debug_dump},
4288 {"Amanda::Headerc::Header_summary", _wrap_Header_summary},
4289 {"Amanda::Headerc::delete_Header", _wrap_delete_Header},
4290 {"Amanda::Headerc::C_from_string", _wrap_C_from_string},
4293 /* -----------------------------------------------------------------------------
4294 * Type initialization:
4295 * This problem is tough by the requirement that no dynamic
4296 * memory is used. Also, since swig_type_info structures store pointers to
4297 * swig_cast_info structures and swig_cast_info structures store pointers back
4298 * to swig_type_info structures, we need some lookup code at initialization.
4299 * The idea is that swig generates all the structures that are needed.
4300 * The runtime then collects these partially filled structures.
4301 * The SWIG_InitializeModule function takes these initial arrays out of
4302 * swig_module, and does all the lookup, filling in the swig_module.types
4303 * array with the correct data and linking the correct swig_cast_info
4304 * structures together.
4306 * The generated swig_type_info structures are assigned staticly to an initial
4307 * array. We just loop through that array, and handle each type individually.
4308 * First we lookup if this type has been already loaded, and if so, use the
4309 * loaded structure instead of the generated one. Then we have to fill in the
4310 * cast linked list. The cast data is initially stored in something like a
4311 * two-dimensional array. Each row corresponds to a type (there are the same
4312 * number of rows as there are in the swig_type_initial array). Each entry in
4313 * a column is one of the swig_cast_info structures for that type.
4314 * The cast_initial array is actually an array of arrays, because each row has
4315 * a variable number of columns. So to actually build the cast linked list,
4316 * we find the array of casts associated with the type, and loop through it
4317 * adding the casts to the list. The one last trick we need to do is making
4318 * sure the type pointer in the swig_cast_info struct is correct.
4320 * First off, we lookup the cast->type name to see if it is already loaded.
4321 * There are three cases to handle:
4322 * 1) If the cast->type has already been loaded AND the type we are adding
4323 * casting info to has not been loaded (it is in this module), THEN we
4324 * replace the cast->type pointer with the type pointer that has already
4326 * 2) If BOTH types (the one we are adding casting info to, and the
4327 * cast->type) are loaded, THEN the cast info has already been loaded by
4328 * the previous module so we just ignore it.
4329 * 3) Finally, if cast->type has not already been loaded, then we add that
4330 * swig_cast_info to the linked list (because the cast->type) pointer will
4332 * ----------------------------------------------------------------------------- */
4342 #define SWIGRUNTIME_DEBUG
4347 SWIG_InitializeModule(void *clientdata) {
4349 swig_module_info *module_head, *iter;
4352 clientdata = clientdata;
4354 /* check to see if the circular list has been setup, if not, set it up */
4355 if (swig_module.next==0) {
4356 /* Initialize the swig_module */
4357 swig_module.type_initial = swig_type_initial;
4358 swig_module.cast_initial = swig_cast_initial;
4359 swig_module.next = &swig_module;
4365 /* Try and load any already created modules */
4366 module_head = SWIG_GetModule(clientdata);
4368 /* This is the first module loaded for this interpreter */
4369 /* so set the swig module into the interpreter */
4370 SWIG_SetModule(clientdata, &swig_module);
4371 module_head = &swig_module;
4373 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4377 if (iter==&swig_module) {
4382 } while (iter!= module_head);
4384 /* if the is found in the list, then all is done and we may leave */
4386 /* otherwise we must add out module into the list */
4387 swig_module.next = module_head->next;
4388 module_head->next = &swig_module;
4391 /* When multiple interpeters are used, a module could have already been initialized in
4392 a different interpreter, but not yet have a pointer in this interpreter.
4393 In this case, we do not want to continue adding types... everything should be
4395 if (init == 0) return;
4397 /* Now work on filling in swig_module.types */
4398 #ifdef SWIGRUNTIME_DEBUG
4399 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
4401 for (i = 0; i < swig_module.size; ++i) {
4402 swig_type_info *type = 0;
4403 swig_type_info *ret;
4404 swig_cast_info *cast;
4406 #ifdef SWIGRUNTIME_DEBUG
4407 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4410 /* if there is another module already loaded */
4411 if (swig_module.next != &swig_module) {
4412 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4415 /* Overwrite clientdata field */
4416 #ifdef SWIGRUNTIME_DEBUG
4417 printf("SWIG_InitializeModule: found type %s\n", type->name);
4419 if (swig_module.type_initial[i]->clientdata) {
4420 type->clientdata = swig_module.type_initial[i]->clientdata;
4421 #ifdef SWIGRUNTIME_DEBUG
4422 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4426 type = swig_module.type_initial[i];
4429 /* Insert casting types */
4430 cast = swig_module.cast_initial[i];
4431 while (cast->type) {
4432 /* Don't need to add information already in the list */
4434 #ifdef SWIGRUNTIME_DEBUG
4435 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4437 if (swig_module.next != &swig_module) {
4438 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4439 #ifdef SWIGRUNTIME_DEBUG
4440 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4444 if (type == swig_module.type_initial[i]) {
4445 #ifdef SWIGRUNTIME_DEBUG
4446 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4451 /* Check for casting already in the list */
4452 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4453 #ifdef SWIGRUNTIME_DEBUG
4454 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4456 if (!ocast) ret = 0;
4461 #ifdef SWIGRUNTIME_DEBUG
4462 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4465 type->cast->prev = cast;
4466 cast->next = type->cast;
4472 /* Set entry in modules->types array equal to the type */
4473 swig_module.types[i] = type;
4475 swig_module.types[i] = 0;
4477 #ifdef SWIGRUNTIME_DEBUG
4478 printf("**** SWIG_InitializeModule: Cast List ******\n");
4479 for (i = 0; i < swig_module.size; ++i) {
4481 swig_cast_info *cast = swig_module.cast_initial[i];
4482 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4483 while (cast->type) {
4484 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4488 printf("---- Total casts: %d\n",j);
4490 printf("**** SWIG_InitializeModule: Cast List ******\n");
4494 /* This function will propagate the clientdata field of type to
4495 * any new swig_type_info structures that have been added into the list
4496 * of equivalent types. It is like calling
4497 * SWIG_TypeClientData(type, clientdata) a second time.
4500 SWIG_PropagateClientData(void) {
4502 swig_cast_info *equiv;
4503 static int init_run = 0;
4505 if (init_run) return;
4508 for (i = 0; i < swig_module.size; i++) {
4509 if (swig_module.types[i]->clientdata) {
4510 equiv = swig_module.types[i]->cast;
4512 if (!equiv->converter) {
4513 if (equiv->type && !equiv->type->clientdata)
4514 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4516 equiv = equiv->next;
4540 SWIG_InitializeModule(0);
4542 /* Install commands */
4543 for (i = 0; swig_commands[i].name; i++) {
4544 newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
4547 /* Install variables */
4548 for (i = 0; swig_variables[i].name; i++) {
4550 sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
4551 if (swig_variables[i].type) {
4552 SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
4554 sv_setiv(sv,(IV) 0);
4556 swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
4559 /* Install constant */
4560 for (i = 0; swig_constants[i].type; i++) {
4562 sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
4563 switch(swig_constants[i].type) {
4565 sv_setiv(sv, (IV) swig_constants[i].lvalue);
4568 sv_setnv(sv, (double) swig_constants[i].dvalue);
4571 sv_setpv(sv, (char *) swig_constants[i].pvalue);
4574 SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
4577 SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
4585 /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4586 SV *sv = get_sv((char*) SWIG_prefix "F_UNKNOWN", TRUE | 0x2 | GV_ADDMULTI);
4587 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_UNKNOWN)));
4589 } while(0) /*@SWIG@*/;
4590 /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4591 SV *sv = get_sv((char*) SWIG_prefix "F_WEIRD", TRUE | 0x2 | GV_ADDMULTI);
4592 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_WEIRD)));
4594 } while(0) /*@SWIG@*/;
4595 /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4596 SV *sv = get_sv((char*) SWIG_prefix "F_TAPESTART", TRUE | 0x2 | GV_ADDMULTI);
4597 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_TAPESTART)));
4599 } while(0) /*@SWIG@*/;
4600 /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4601 SV *sv = get_sv((char*) SWIG_prefix "F_TAPEEND", TRUE | 0x2 | GV_ADDMULTI);
4602 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_TAPEEND)));
4604 } while(0) /*@SWIG@*/;
4605 /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4606 SV *sv = get_sv((char*) SWIG_prefix "F_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
4607 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_DUMPFILE)));
4609 } while(0) /*@SWIG@*/;
4610 /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4611 SV *sv = get_sv((char*) SWIG_prefix "F_CONT_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
4612 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_CONT_DUMPFILE)));
4614 } while(0) /*@SWIG@*/;
4615 /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4616 SV *sv = get_sv((char*) SWIG_prefix "F_SPLIT_DUMPFILE", TRUE | 0x2 | GV_ADDMULTI);
4617 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_SPLIT_DUMPFILE)));
4619 } while(0) /*@SWIG@*/;
4620 /*@SWIG:/usr/share/swig/1.3.39/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4621 SV *sv = get_sv((char*) SWIG_prefix "F_EMPTY", TRUE | 0x2 | GV_ADDMULTI);
4622 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(F_EMPTY)));
4624 } while(0) /*@SWIG@*/;
4625 SWIG_TypeClientData(SWIGTYPE_p_dumpfile_t, (void*) "Amanda::Header::Header");