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 an 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_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
901 #define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
903 /* for raw packed data */
904 #define SWIG_ConvertPacked(obj, p, s, type) SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
905 #define SWIG_NewPackedObj(p, s, type) SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
907 /* for class or struct pointers */
908 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
909 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
911 /* for C or C++ function pointers */
912 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
913 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
915 /* for C++ member pointers, ie, member methods */
916 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_ConvertPacked(obj, ptr, sz, ty)
917 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_NewPackedObj(ptr, sz, type)
922 #define SWIG_GetModule(clientdata) SWIG_Perl_GetModule()
923 #define SWIG_SetModule(clientdata, pointer) SWIG_Perl_SetModule(pointer)
926 /* Error manipulation */
928 #define SWIG_ErrorType(code) SWIG_Perl_ErrorType(code)
929 #define SWIG_Error(code, msg) sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
930 #define SWIG_fail goto fail
932 /* Perl-specific SWIG API */
934 #define SWIG_MakePtr(sv, ptr, type, flags) SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
935 #define SWIG_MakePackedObj(sv, p, s, type) SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
936 #define SWIG_SetError(str) SWIG_Error(SWIG_RuntimeError, str)
939 #define SWIG_PERL_DECL_ARGS_1(arg1) (SWIG_PERL_OBJECT_DECL arg1)
940 #define SWIG_PERL_CALL_ARGS_1(arg1) (SWIG_PERL_OBJECT_CALL arg1)
941 #define SWIG_PERL_DECL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_DECL arg1, arg2)
942 #define SWIG_PERL_CALL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_CALL arg1, arg2)
944 /* -----------------------------------------------------------------------------
945 * pointers/data manipulation
946 * ----------------------------------------------------------------------------- */
948 /* For backward compatibility only */
949 #define SWIG_POINTER_EXCEPTION 0
955 #define SWIG_OWNER SWIG_POINTER_OWN
956 #define SWIG_SHADOW SWIG_OWNER << 1
958 #define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
960 /* SWIG Perl macros */
962 /* Macro to declare an XS function */
964 # define XSPROTO(name) void name(pTHX_ CV* cv)
967 /* Macro to call an XS function */
969 # define SWIG_CALLXS(_name) _name(cv,pPerl)
971 # ifndef MULTIPLICITY
972 # define SWIG_CALLXS(_name) _name(cv)
974 # define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
979 #define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this;
984 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
989 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
990 #define SWIGCLASS_STATIC
992 #else /* PERL_OBJECT */
995 #define SWIGCLASS_STATIC static SWIGUNUSED
998 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
1003 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
1008 #else /* MULTIPLICITY */
1010 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
1015 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
1020 #endif /* MULTIPLICITY */
1021 #endif /* PERL_OBJECT */
1023 /* Workaround for bug in perl 5.6.x croak and earlier */
1024 #if (PERL_VERSION < 8)
1026 # define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
1027 static void SWIG_Perl_croak_null(CPerlObj *pPerl)
1029 static void SWIG_croak_null()
1033 # if (PERL_VERSION < 6)
1036 if (SvOK(err) && !SvROK(err)) croak("%_", err);
1041 # define SWIG_croak_null() croak(Nullch)
1046 Define how strict is the cast between strings and integers/doubles
1047 when overloading between these types occurs.
1049 The default is making it as strict as possible by using SWIG_AddCast
1052 You can use -DSWIG_PERL_NO_STRICT_STR2NUM at compilation time to
1053 disable the SWIG_AddCast, making the casting between string and
1054 numbers less strict.
1056 In the end, we try to solve the overloading between strings and
1057 numerical types in the more natural way, but if you can avoid it,
1058 well, avoid it using %rename, for example.
1060 #ifndef SWIG_PERL_NO_STRICT_STR2NUM
1061 # ifndef SWIG_PERL_STRICT_STR2NUM
1062 # define SWIG_PERL_STRICT_STR2NUM
1065 #ifdef SWIG_PERL_STRICT_STR2NUM
1066 /* string takes precedence */
1067 #define SWIG_Str2NumCast(x) SWIG_AddCast(x)
1069 /* number takes precedence */
1070 #define SWIG_Str2NumCast(x) x
1077 SWIGRUNTIME const char *
1078 SWIG_Perl_TypeProxyName(const swig_type_info *type) {
1079 if (!type) return NULL;
1080 if (type->clientdata != NULL) {
1081 return (const char*) type->clientdata;
1088 /* Identical to SWIG_TypeCheck, except for strcmp comparison */
1089 SWIGRUNTIME swig_cast_info *
1090 SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
1092 swig_cast_info *iter = ty->cast;
1094 if ( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) ||
1095 (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0)) ) {
1096 if (iter == ty->cast)
1098 /* Move iter to the top of the linked list */
1099 iter->prev->next = iter->next;
1101 iter->next->prev = iter->prev;
1102 iter->next = ty->cast;
1104 if (ty->cast) ty->cast->prev = iter;
1114 /* Function for getting a pointer value */
1117 SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
1119 void *voidptr = (void *)0;
1125 /* If magical, apply more magic */
1129 /* Check to see if this is an object */
1130 if (sv_isobject(sv)) {
1132 tsv = (SV*) SvRV(sv);
1133 if ((SvTYPE(tsv) == SVt_PVHV)) {
1135 if (SvMAGICAL(tsv)) {
1136 mg = mg_find(tsv,'P');
1139 if (sv_isobject(sv)) {
1140 tsv = (SV*)SvRV(sv);
1150 voidptr = INT2PTR(void *,tmp);
1151 } else if (! SvOK(sv)) { /* Check for undef */
1152 *(ptr) = (void *) 0;
1154 } else if (SvTYPE(sv) == SVt_RV) { /* Check for NULL pointer */
1156 /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value. */
1160 /* NULL pointer (reference to undef). */
1161 *(ptr) = (void *) 0;
1167 } else { /* Don't know what it is */
1171 /* Now see if the types match */
1172 char *_c = HvNAME(SvSTASH(SvRV(sv)));
1173 tc = SWIG_TypeProxyCheck(_c,_t);
1179 *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
1180 if (newmemory == SWIG_CAST_NEW_MEMORY) {
1181 assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
1183 *own = *own | SWIG_CAST_NEW_MEMORY;
1191 * DISOWN implementation: we need a perl guru to check this one.
1193 if (tsv && (flags & SWIG_POINTER_DISOWN)) {
1195 * almost copy paste code from below SWIG_POINTER_OWN setting
1198 HV *stash = SvSTASH(SvRV(obj));
1199 GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1203 * To set ownership (see below), a newSViv(1) entry is added.
1204 * Hence, to remove ownership, we delete the entry.
1206 if (hv_exists_ent(hv, obj, 0)) {
1207 hv_delete_ent(hv, obj, 0, 0);
1215 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
1216 return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
1220 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
1221 if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
1226 sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1227 stash=SvSTASH(SvRV(obj));
1228 if (flags & SWIG_POINTER_OWN) {
1230 GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
1232 gv_init(gv, stash, "OWNER", 5, FALSE);
1234 hv_store_ent(hv, obj, newSViv(1), 0);
1236 sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
1238 self=newRV_noinc((SV *)hash);
1240 SvREFCNT_dec((SV *)self);
1241 sv_bless(sv, stash);
1244 sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
1248 SWIGRUNTIMEINLINE SV *
1249 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
1250 SV *result = sv_newmortal();
1251 SWIG_MakePtr(result, ptr, t, flags);
1256 SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
1259 if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
1261 r = SWIG_PackData(r,ptr,sz);
1262 strcpy(r,SWIG_Perl_TypeProxyName(type));
1263 sv_setpv(sv, result);
1267 SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
1268 SV *result = sv_newmortal();
1269 SWIG_Perl_MakePackedObj(result, ptr, sz, type);
1273 /* Convert a packed value value */
1275 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
1279 if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
1280 c = SvPV_nolen(obj);
1281 /* Pointer values must start with leading underscore */
1282 if (*c != '_') return SWIG_ERROR;
1284 c = SWIG_UnpackData(c,ptr,sz);
1286 tc = SWIG_TypeCheck(c,ty);
1287 if (!tc) return SWIG_ERROR;
1293 /* Macros for low-level exception handling */
1294 #define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
1297 typedef XSPROTO(SwigPerlWrapper);
1298 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
1300 /* Structure for command table */
1303 SwigPerlWrapperPtr wrapper;
1304 } swig_command_info;
1306 /* Information for constant table */
1309 #define SWIG_FLOAT 2
1310 #define SWIG_STRING 3
1311 #define SWIG_POINTER 4
1312 #define SWIG_BINARY 5
1314 /* Constant information structure */
1315 typedef struct swig_constant_info {
1321 swig_type_info **ptype;
1322 } swig_constant_info;
1325 /* Structure for variable table */
1330 swig_type_info **type;
1331 } swig_variable_info;
1333 /* Magic variable code */
1335 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
1336 #ifndef MULTIPLICITY
1337 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
1339 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
1342 # define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
1343 SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
1347 sv_magic(sv,sv,'U',(char *) name,strlen(name));
1348 mg = mg_find(sv,'U');
1349 mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
1350 mg->mg_virtual->svt_get = (SwigMagicFunc) get;
1351 mg->mg_virtual->svt_set = (SwigMagicFunc) set;
1352 mg->mg_virtual->svt_len = 0;
1353 mg->mg_virtual->svt_clear = 0;
1354 mg->mg_virtual->svt_free = 0;
1358 SWIGRUNTIME swig_module_info *
1359 SWIG_Perl_GetModule(void) {
1360 static void *type_pointer = (void *)0;
1363 /* first check if pointer already created */
1364 if (!type_pointer) {
1365 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
1366 if (pointer && SvOK(pointer)) {
1367 type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
1371 return (swig_module_info *) type_pointer;
1375 SWIG_Perl_SetModule(swig_module_info *module) {
1378 /* create a new pointer */
1379 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
1380 sv_setiv(pointer, PTR2IV(module));
1387 /* Workaround perl5 global namespace pollution. Note that undefining library
1388 * functions like fopen will not solve the problem on all platforms as fopen
1389 * might be a macro on Windows but not necessarily on other operating systems. */
1498 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1500 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1504 #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
1507 /* -------- TYPES TABLE (BEGIN) -------- */
1509 #define SWIGTYPE_p_Device swig_types[0]
1510 #define SWIGTYPE_p_DevicePropertyBase swig_types[1]
1511 #define SWIGTYPE_p_DirectTCPAddr swig_types[2]
1512 #define SWIGTYPE_p_DirectTCPConnection swig_types[3]
1513 #define SWIGTYPE_p_GSList swig_types[4]
1514 #define SWIGTYPE_p_GValue swig_types[5]
1515 #define SWIGTYPE_p_a_STRMAX__char swig_types[6]
1516 #define SWIGTYPE_p_char swig_types[7]
1517 #define SWIGTYPE_p_double swig_types[8]
1518 #define SWIGTYPE_p_dumpfile_t swig_types[9]
1519 #define SWIGTYPE_p_float swig_types[10]
1520 #define SWIGTYPE_p_guint swig_types[11]
1521 #define SWIGTYPE_p_guint32 swig_types[12]
1522 #define SWIGTYPE_p_guint64 swig_types[13]
1523 #define SWIGTYPE_p_int swig_types[14]
1524 #define SWIGTYPE_p_p_DirectTCPAddr swig_types[15]
1525 #define SWIGTYPE_p_unsigned_char swig_types[16]
1526 static swig_type_info *swig_types[18];
1527 static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0};
1528 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1529 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1531 /* -------- TYPES TABLE (END) -------- */
1533 #define SWIG_init boot_Amanda__Device
1535 #define SWIG_name "Amanda::Devicec::boot_Amanda__Device"
1536 #define SWIG_prefix "Amanda::Devicec::"
1538 #define SWIGVERSION 0x020004
1539 #define SWIG_VERSION SWIGVERSION
1542 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1543 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1550 #ifndef MULTIPLICITY
1551 SWIGEXPORT void SWIG_init (CV* cv);
1553 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
1556 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
1570 #include "property.h"
1571 #include "fileheader.h"
1572 #include "glib-util.h"
1573 #include "simpleprng.h"
1575 #include "sockaddr-util.h"
1579 /* Utility functions for typemaps, below */
1581 /* return a new, mortal SV corresponding to the given GValue
1583 * @param value: the value to convert
1584 * @returns: a new, mortal SV
1587 set_sv_from_gvalue(GValue *value)
1589 GType fundamental = G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value));
1592 /* complex reference types */
1593 switch (fundamental) {
1595 return sv_2mortal(amglue_newSVi64(g_value_get_long(value)));
1598 return sv_2mortal(amglue_newSVu64(g_value_get_ulong(value)));
1601 return sv_2mortal(amglue_newSVi64(g_value_get_int64(value)));
1604 return sv_2mortal(amglue_newSVu64(g_value_get_uint64(value)));
1607 /* simple types that can be constructed with sv_set*v */
1608 sv = sv_newmortal();
1609 switch (fundamental) {
1611 sv_setiv(sv, g_value_get_char(value));
1615 sv_setuv(sv, g_value_get_uchar(value));
1618 case G_TYPE_BOOLEAN:
1619 sv_setiv(sv, g_value_get_boolean(value));
1623 sv_setiv(sv, g_value_get_int(value));
1627 sv_setuv(sv, g_value_get_uint(value));
1631 sv_setnv(sv, g_value_get_float(value));
1635 sv_setnv(sv, g_value_get_double(value));
1639 sv_setpv(sv, g_value_get_string(value));
1643 sv_setiv(sv, g_value_get_enum(value));
1647 sv_setiv(sv, g_value_get_flags(value));
1652 case G_TYPE_POINTER:
1653 case G_TYPE_INTERFACE:
1656 warn("Unsupported fundamental property type #%d", (int)fundamental);
1657 sv_setsv(sv, &PL_sv_undef);
1664 /* Given an SV and an initialized GValue, set the GValue to the value
1665 * represented by the SV. The GValue's type must already be set.
1667 * For basic corresponding types (string -> string, integer -> integer),
1668 * the translation is straightforward. However, if the GValue is not a
1669 * string, but the SV has a string value, then g_value_set_from_string will
1670 * be used to parse the string.
1672 * @param sv: SV to convert
1673 * @param value: (input/output) destination
1674 * @returns: TRUE on success
1677 set_gvalue_from_sv(SV *sv, GValue *value)
1679 GType fundamental = G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value));
1681 /* if we got a string, use g_value_set_from_string to parse any funny
1682 * values or suffixes */
1684 if (g_value_set_from_string(value, SvPV_nolen(sv)))
1688 /* otherwise, handle numeric types with SvIV, SvNV, or the amglue_* functions */
1689 switch (fundamental) {
1690 case G_TYPE_BOOLEAN:
1691 g_value_set_boolean(value, SvIV(sv));
1695 g_value_set_char(value, amglue_SvI8(sv));
1699 g_value_set_uchar(value, amglue_SvU8(sv));
1703 g_value_set_int(value, amglue_SvI32(sv));
1707 g_value_set_uint(value, amglue_SvU32(sv));
1711 g_value_set_int64(value, amglue_SvI64(sv));
1715 g_value_set_uint64(value, amglue_SvU64(sv));
1719 g_value_set_int64(value, amglue_SvI64(sv));
1723 g_value_set_uint64(value, amglue_SvU64(sv));
1727 g_value_set_float(value, SvNV(sv));
1731 g_value_set_double(value, SvNV(sv));
1735 g_value_set_enum(value, SvIV(sv));
1739 g_value_set_flags(value, SvIV(sv));
1743 /* for anything else, let perl stringify it for us and try parsing it */
1744 return g_value_set_from_string(value, SvPV_nolen(sv));
1749 SWIGINTERN void delete_DirectTCPConnection(DirectTCPConnection *self){
1750 g_object_unref(self);
1752 SWIGINTERN char *DirectTCPConnection_close(DirectTCPConnection *self){
1753 return directtcp_connection_close(self);
1756 SWIGINTERNINLINE SV *
1757 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1759 SV *obj = sv_newmortal();
1761 sv_setpvn(obj, carray, size);
1763 sv_setsv(obj, &PL_sv_undef);
1769 SWIGINTERNINLINE SV *
1770 SWIG_FromCharPtr(const char *cptr)
1772 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1776 SWIGINTERN swig_type_info*
1777 SWIG_pchar_descriptor(void)
1779 static int init = 0;
1780 static swig_type_info* info = 0;
1782 info = SWIG_TypeQuery("_p_char");
1790 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
1792 if (SvMAGICAL(obj)) {
1793 SV *tmp = sv_newmortal();
1799 char *cstr = SvPV(obj, len);
1800 size_t size = len + 1;
1803 if (*alloc == SWIG_NEWOBJ) {
1804 *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
1807 *alloc = SWIG_OLDOBJ;
1811 if (psize) *psize = size;
1814 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
1815 if (pchar_descriptor) {
1817 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
1818 if (cptr) *cptr = vptr;
1819 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1820 if (alloc) *alloc = SWIG_OLDOBJ;
1825 return SWIG_TypeError;
1831 SWIGINTERN Device *new_Device(char *device_name){
1832 return device_open(device_name);
1834 SWIGINTERN void delete_Device(Device *self){
1835 g_object_unref(self);
1839 #if !defined(SWIG_NO_LLONG_MAX)
1840 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1841 # define LLONG_MAX __LONG_LONG_MAX__
1842 # define LLONG_MIN (-LLONG_MAX - 1LL)
1843 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1849 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
1852 if (val) *val = SvNV(obj);
1854 } else if (SvIOK(obj)) {
1855 if (val) *val = (double) SvIV(obj);
1856 return SWIG_AddCast(SWIG_OK);
1858 const char *nptr = SvPV_nolen(obj);
1863 v = strtod(nptr, &endptr);
1864 if (errno == ERANGE) {
1866 return SWIG_OverflowError;
1868 if (*endptr == '\0') {
1870 return SWIG_Str2NumCast(SWIG_OK);
1875 return SWIG_TypeError;
1885 SWIGINTERNINLINE int
1886 SWIG_CanCastAsInteger(double *d, double min, double max) {
1888 if ((min <= x && x <= max)) {
1889 double fx = floor(x);
1890 double cx = ceil(x);
1891 double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
1892 if ((errno == EDOM) || (errno == ERANGE)) {
1895 double summ, reps, diff;
1898 } else if (rd > x) {
1905 if (reps < 8*DBL_EPSILON) {
1916 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
1919 if (val) *val = SvIV(obj);
1923 const char *nptr = SvPV_nolen(obj);
1928 v = strtol(nptr, &endptr,0);
1929 if (errno == ERANGE) {
1931 return SWIG_OverflowError;
1933 if (*endptr == '\0') {
1935 return SWIG_Str2NumCast(SWIG_OK);
1941 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
1942 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
1943 if (val) *val = (long)(d);
1948 return SWIG_TypeError;
1953 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
1956 int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
1957 if (SWIG_IsOK(res)) {
1958 if ((v < INT_MIN || v > INT_MAX)) {
1959 return SWIG_OverflowError;
1961 if (val) *val = (int)(v);
1967 SWIGINTERN gboolean Device_configure(Device *self,gboolean use_global_config){
1968 return device_configure(self, use_global_config);
1970 SWIGINTERN char *Device_error(Device *self){
1971 return device_error(self);
1973 SWIGINTERN char *Device_status_error(Device *self){
1974 return device_status_error(self);
1976 SWIGINTERN char *Device_error_or_status(Device *self){
1977 return device_error_or_status(self);
1979 SWIGINTERN DeviceStatusFlags Device_read_label(Device *self){
1980 return device_read_label(self);
1982 SWIGINTERN gboolean Device_start(Device *self,DeviceAccessMode mode,char *label,char *timestamp){
1983 return device_start(self, mode, label, timestamp);
1985 SWIGINTERN gboolean Device_finish(Device *self){
1986 return device_finish(self);
1988 SWIGINTERN gboolean Device_start_file(Device *self,dumpfile_t *jobInfo){
1989 return device_start_file(self, jobInfo);
1991 SWIGINTERN gboolean Device_write_block(Device *self,guint size,gpointer data){
1992 return device_write_block(self, size, data);
1994 SWIGINTERN gboolean Device_finish_file(Device *self){
1995 return device_finish_file(self);
1997 SWIGINTERN dumpfile_t *Device_seek_file(Device *self,guint file){
1998 return device_seek_file(self, file);
2000 SWIGINTERN gboolean Device_seek_block(Device *self,guint64 block){
2001 return device_seek_block(self, block);
2003 SWIGINTERN int Device_read_block(Device *self,gpointer buffer,int *size){
2004 return device_read_block(self, buffer, size);
2006 SWIGINTERN gboolean Device_erase(Device *self){
2007 return device_erase(self);
2009 SWIGINTERN gboolean Device_eject(Device *self){
2010 return device_eject(self);
2012 SWIGINTERN gboolean Device_directtcp_supported(Device *self){
2013 return device_directtcp_supported(self);
2015 SWIGINTERN void Device_listen(Device *self,gboolean for_writing,DirectTCPAddr **addrs){
2016 /* ensure that the addresses are empty if there was an error */
2017 if (!device_listen(self, for_writing, addrs))
2020 SWIGINTERN DirectTCPConnection *Device_accept(Device *self){
2021 DirectTCPConnection *conn = NULL;
2024 rv = device_accept(self, &conn, NULL, NULL);
2026 /* conn is ref'd for our convenience, but we don't want it */
2027 g_object_unref(conn);
2032 SWIGINTERN DirectTCPConnection *Device_connect(Device *self,gboolean for_writing,DirectTCPAddr *addrs){
2033 DirectTCPConnection *conn = NULL;
2036 rv = device_connect(self, for_writing, addrs, &conn, NULL, NULL);
2038 /* conn is ref'd for our convenience, but we don't want it */
2039 g_object_unref(conn);
2044 SWIGINTERN gboolean Device_use_connection(Device *self,DirectTCPConnection *conn){
2045 return device_use_connection(self, conn);
2047 SWIGINTERN gboolean Device_write_from_connection(Device *self,guint64 size,guint64 *actual_size){
2048 return device_write_from_connection(self, size, actual_size);
2050 SWIGINTERN gboolean Device_read_to_connection(Device *self,guint64 size,guint64 *actual_size){
2051 return device_read_to_connection(self, size, actual_size);
2053 SWIGINTERN GSList const *Device_property_list(Device *self){
2054 return device_property_get_list(self);
2056 SWIGINTERN void Device_property_get(Device *self,DevicePropertyBase *pbase,GValue *out_val,PropertySurety *surety,PropertySource *source,gboolean *val_found){
2058 *val_found = device_property_get_ex(self, pbase->ID, out_val, surety, source);
2063 SWIGINTERN gboolean Device_property_set(Device *self,DevicePropertyBase *pbase,SV *sv){
2068 memset(&gval, 0, sizeof(gval));
2069 g_value_init(&gval, pbase->type);
2070 if (!set_gvalue_from_sv(sv, &gval))
2073 if (!device_property_set(self, pbase->ID, &gval))
2076 g_value_unset(&gval);
2079 g_value_unset(&gval);
2083 SWIGINTERN gboolean Device_property_set_ex(Device *self,DevicePropertyBase *pbase,SV *sv,PropertySurety surety,PropertySource source){
2085 memset(&gval, 0, sizeof(gval));
2086 g_value_init(&gval, pbase->type);
2087 if (!set_gvalue_from_sv(sv, &gval))
2090 if (!device_property_set_ex(self, pbase->ID, &gval, surety, source))
2093 g_value_unset(&gval);
2096 g_value_unset(&gval);
2099 SWIGINTERN gboolean Device_recycle_file(Device *self,guint filenum){
2100 return device_recycle_file(self, filenum);
2102 SWIGINTERN int Device_file(Device *self){ return self->file; }
2103 SWIGINTERN guint64 Device_block(Device *self){ return self->block; }
2104 SWIGINTERN gboolean Device_in_file(Device *self){ return self->in_file; }
2105 SWIGINTERN char *Device_device_name(Device *self){ return self->device_name; }
2106 SWIGINTERN DeviceAccessMode Device_access_mode(Device *self){ return self->access_mode; }
2107 SWIGINTERN gboolean Device_is_eof(Device *self){ return self->is_eof; }
2108 SWIGINTERN gboolean Device_is_eom(Device *self){ return self->is_eom; }
2109 SWIGINTERN char *Device_volume_label(Device *self){ return self->volume_label; }
2110 SWIGINTERN char *Device_volume_time(Device *self){ return self->volume_time; }
2111 SWIGINTERN DeviceStatusFlags Device_status(Device *self){ return self->status; }
2112 SWIGINTERN gsize Device_min_block_size(Device *self){ return self->min_block_size; }
2113 SWIGINTERN gsize Device_max_block_size(Device *self){ return self->max_block_size; }
2114 SWIGINTERN gsize Device_block_size(Device *self){ return self->block_size; }
2115 SWIGINTERN gsize Device_header_block_size(Device *self){ return self->header_block_size; }
2116 SWIGINTERN dumpfile_t *Device_volume_header(Device *self){ return self->volume_header; }
2119 /* write LENGTH bytes of random data to FILENAME, seeded with SEED */
2121 write_random_to_device(guint32 seed, size_t length, Device *device) {
2122 simpleprng_state_t prng;
2124 gsize block_size = device->block_size;
2125 g_assert(block_size < G_MAXUINT);
2127 buf = g_malloc(block_size);
2128 simpleprng_seed(&prng, seed);
2131 size_t to_write = min(block_size, length);
2133 simpleprng_fill_buffer(&prng, buf, to_write);
2134 if (!device_write_block(device, (guint)block_size, buf)) {
2145 /* read LENGTH bytes of random data from FILENAME verifying it against
2146 * a PRNG seeded with SEED. Sends any error messages to stderr.
2149 verify_random_from_device(guint32 seed, size_t length, Device *device) {
2150 simpleprng_state_t prng;
2151 char *buf = NULL; /* first device_read_block will get the size */
2154 simpleprng_seed(&prng, seed);
2158 int size = block_size;
2160 bytes_read = device_read_block(device, buf, &size);
2161 if (bytes_read == 0 && size > block_size) {
2164 buf = g_malloc(block_size);
2167 if (bytes_read == -1) {
2168 if (device->status == DEVICE_STATUS_SUCCESS) {
2169 g_assert(device->is_eof);
2170 g_debug("verify_random_from_device got unexpected EOF");
2176 bytes_read = min(bytes_read, length);
2178 if (!simpleprng_verify_buffer(&prng, buf, bytes_read))
2181 length -= bytes_read;
2194 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
2197 if (val) *val = SvUV(obj);
2199 } else if (SvIOK(obj)) {
2205 return SWIG_OverflowError;
2209 const char *nptr = SvPV_nolen(obj);
2214 v = strtoul(nptr, &endptr,0);
2215 if (errno == ERANGE) {
2217 return SWIG_OverflowError;
2219 if (*endptr == '\0') {
2221 return SWIG_Str2NumCast(SWIG_OK);
2227 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
2228 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
2229 if (val) *val = (unsigned long)(d);
2234 return SWIG_TypeError;
2238 SWIGINTERNINLINE int
2239 SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
2242 int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
2243 if (SWIG_IsOK(res) && val) *val = (size_t)(v);
2248 SWIGINTERNINLINE SV *
2249 SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value)
2251 SV *obj = sv_newmortal();
2252 sv_setiv(obj, (IV) value);
2257 SWIGINTERNINLINE SV *
2258 SWIG_From_int SWIG_PERL_DECL_ARGS_1(int value)
2260 return SWIG_From_long SWIG_PERL_CALL_ARGS_1(value);
2268 #define MAGIC_CLASS _wrap_Amanda__Device_var::
2269 class _wrap_Amanda__Device_var : public CPerlObj {
2274 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
2276 croak("Value is read-only.");
2292 XS(_wrap_delete_DirectTCPConnection) {
2294 DirectTCPConnection *arg1 = (DirectTCPConnection *) 0 ;
2300 if ((items < 1) || (items > 1)) {
2301 SWIG_croak("Usage: delete_DirectTCPConnection(self);");
2303 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_DirectTCPConnection, SWIG_POINTER_DISOWN | 0 );
2304 if (!SWIG_IsOK(res1)) {
2305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DirectTCPConnection" "', argument " "1"" of type '" "DirectTCPConnection *""'");
2307 arg1 = (DirectTCPConnection *)(argp1);
2308 delete_DirectTCPConnection(arg1);
2309 ST(argvi) = sv_newmortal();
2319 XS(_wrap_DirectTCPConnection_close) {
2321 DirectTCPConnection *arg1 = (DirectTCPConnection *) 0 ;
2328 if ((items < 1) || (items > 1)) {
2329 SWIG_croak("Usage: DirectTCPConnection_close(self);");
2331 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_DirectTCPConnection, 0 | 0 );
2332 if (!SWIG_IsOK(res1)) {
2333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirectTCPConnection_close" "', argument " "1"" of type '" "DirectTCPConnection *""'");
2335 arg1 = (DirectTCPConnection *)(argp1);
2336 result = (char *)DirectTCPConnection_close(arg1);
2337 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2339 free((char*)result);
2348 XS(_wrap_new_DirectTCPConnection) {
2351 DirectTCPConnection *result = 0 ;
2354 if ((items < 0) || (items > 0)) {
2355 SWIG_croak("Usage: new_DirectTCPConnection();");
2357 result = (DirectTCPConnection *)calloc(1, sizeof(DirectTCPConnection));
2358 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2366 XS(_wrap_unaliased_name) {
2368 char *arg1 = (char *) 0 ;
2376 if ((items < 1) || (items > 1)) {
2377 SWIG_croak("Usage: unaliased_name(char *);");
2379 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2380 if (!SWIG_IsOK(res1)) {
2381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unaliased_name" "', argument " "1"" of type '" "char *""'");
2383 arg1 = (char *)(buf1);
2384 result = (char *)device_unaliased_name(arg1);
2385 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2386 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2389 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2395 XS(_wrap_new_Device) {
2397 char *arg1 = (char *) 0 ;
2402 Device *result = 0 ;
2405 if ((items < 1) || (items > 1)) {
2406 SWIG_croak("Usage: new_Device(device_name);");
2408 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
2409 if (!SWIG_IsOK(res1)) {
2410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Device" "', argument " "1"" of type '" "char *""'");
2412 arg1 = (char *)(buf1);
2413 result = (Device *)new_Device(arg1);
2414 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Device, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
2415 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2418 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2424 XS(_wrap_delete_Device) {
2426 Device *arg1 = (Device *) 0 ;
2432 if ((items < 1) || (items > 1)) {
2433 SWIG_croak("Usage: delete_Device(self);");
2435 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, SWIG_POINTER_DISOWN | 0 );
2436 if (!SWIG_IsOK(res1)) {
2437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Device" "', argument " "1"" of type '" "Device *""'");
2439 arg1 = (Device *)(argp1);
2440 delete_Device(arg1);
2441 ST(argvi) = sv_newmortal();
2451 XS(_wrap_Device_configure) {
2453 Device *arg1 = (Device *) 0 ;
2461 if ((items < 2) || (items > 2)) {
2462 SWIG_croak("Usage: Device_configure(self,use_global_config);");
2464 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2465 if (!SWIG_IsOK(res1)) {
2466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_configure" "', argument " "1"" of type '" "Device *""'");
2468 arg1 = (Device *)(argp1);
2470 arg2 = SvTRUE(ST(1));
2472 result = (gboolean)Device_configure(arg1,arg2);
2475 ST(argvi) = &PL_sv_yes;
2477 ST(argvi) = &PL_sv_no;
2491 XS(_wrap_Device_error) {
2493 Device *arg1 = (Device *) 0 ;
2500 if ((items < 1) || (items > 1)) {
2501 SWIG_croak("Usage: Device_error(self);");
2503 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2504 if (!SWIG_IsOK(res1)) {
2505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_error" "', argument " "1"" of type '" "Device *""'");
2507 arg1 = (Device *)(argp1);
2508 result = (char *)Device_error(arg1);
2509 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2519 XS(_wrap_Device_status_error) {
2521 Device *arg1 = (Device *) 0 ;
2528 if ((items < 1) || (items > 1)) {
2529 SWIG_croak("Usage: Device_status_error(self);");
2531 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2532 if (!SWIG_IsOK(res1)) {
2533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_status_error" "', argument " "1"" of type '" "Device *""'");
2535 arg1 = (Device *)(argp1);
2536 result = (char *)Device_status_error(arg1);
2537 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2547 XS(_wrap_Device_error_or_status) {
2549 Device *arg1 = (Device *) 0 ;
2556 if ((items < 1) || (items > 1)) {
2557 SWIG_croak("Usage: Device_error_or_status(self);");
2559 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2560 if (!SWIG_IsOK(res1)) {
2561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_error_or_status" "', argument " "1"" of type '" "Device *""'");
2563 arg1 = (Device *)(argp1);
2564 result = (char *)Device_error_or_status(arg1);
2565 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
2575 XS(_wrap_Device_read_label) {
2577 Device *arg1 = (Device *) 0 ;
2581 DeviceStatusFlags result;
2584 if ((items < 1) || (items > 1)) {
2585 SWIG_croak("Usage: Device_read_label(self);");
2587 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2588 if (!SWIG_IsOK(res1)) {
2589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_label" "', argument " "1"" of type '" "Device *""'");
2591 arg1 = (Device *)(argp1);
2592 result = (DeviceStatusFlags)Device_read_label(arg1);
2595 SP += argvi; PUTBACK;
2596 for_stack = sv_2mortal(amglue_newSVi64(result));
2597 SPAGAIN; SP -= argvi;
2598 ST(argvi) = for_stack;
2610 XS(_wrap_Device_start) {
2612 Device *arg1 = (Device *) 0 ;
2613 DeviceAccessMode arg2 ;
2614 char *arg3 = (char *) 0 ;
2615 char *arg4 = (char *) 0 ;
2628 if ((items < 4) || (items > 4)) {
2629 SWIG_croak("Usage: Device_start(self,mode,label,timestamp);");
2631 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2632 if (!SWIG_IsOK(res1)) {
2633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_start" "', argument " "1"" of type '" "Device *""'");
2635 arg1 = (Device *)(argp1);
2637 if (sizeof(signed int) == 1) {
2638 arg2 = amglue_SvI8(ST(1));
2639 } else if (sizeof(signed int) == 2) {
2640 arg2 = amglue_SvI16(ST(1));
2641 } else if (sizeof(signed int) == 4) {
2642 arg2 = amglue_SvI32(ST(1));
2643 } else if (sizeof(signed int) == 8) {
2644 arg2 = amglue_SvI64(ST(1));
2646 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
2649 res3 = SWIG_AsCharPtrAndSize(ST(2), &buf3, NULL, &alloc3);
2650 if (!SWIG_IsOK(res3)) {
2651 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_start" "', argument " "3"" of type '" "char *""'");
2653 arg3 = (char *)(buf3);
2654 res4 = SWIG_AsCharPtrAndSize(ST(3), &buf4, NULL, &alloc4);
2655 if (!SWIG_IsOK(res4)) {
2656 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Device_start" "', argument " "4"" of type '" "char *""'");
2658 arg4 = (char *)(buf4);
2659 result = (gboolean)Device_start(arg1,arg2,arg3,arg4);
2662 ST(argvi) = &PL_sv_yes;
2664 ST(argvi) = &PL_sv_no;
2669 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2670 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2675 if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2676 if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2682 XS(_wrap_Device_finish) {
2684 Device *arg1 = (Device *) 0 ;
2691 if ((items < 1) || (items > 1)) {
2692 SWIG_croak("Usage: Device_finish(self);");
2694 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2695 if (!SWIG_IsOK(res1)) {
2696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_finish" "', argument " "1"" of type '" "Device *""'");
2698 arg1 = (Device *)(argp1);
2699 result = (gboolean)Device_finish(arg1);
2702 ST(argvi) = &PL_sv_yes;
2704 ST(argvi) = &PL_sv_no;
2716 XS(_wrap_Device_start_file) {
2718 Device *arg1 = (Device *) 0 ;
2719 dumpfile_t *arg2 = (dumpfile_t *) 0 ;
2728 if ((items < 2) || (items > 2)) {
2729 SWIG_croak("Usage: Device_start_file(self,jobInfo);");
2731 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2732 if (!SWIG_IsOK(res1)) {
2733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_start_file" "', argument " "1"" of type '" "Device *""'");
2735 arg1 = (Device *)(argp1);
2736 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_dumpfile_t, 0 | 0 );
2737 if (!SWIG_IsOK(res2)) {
2738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_start_file" "', argument " "2"" of type '" "dumpfile_t *""'");
2740 arg2 = (dumpfile_t *)(argp2);
2741 result = (gboolean)Device_start_file(arg1,arg2);
2744 ST(argvi) = &PL_sv_yes;
2746 ST(argvi) = &PL_sv_no;
2760 XS(_wrap_Device_write_block) {
2762 Device *arg1 = (Device *) 0 ;
2764 gpointer arg3 = (gpointer) 0 ;
2772 if ((items < 3) || (items > 3)) {
2773 SWIG_croak("Usage: Device_write_block(self,size,data);");
2775 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2776 if (!SWIG_IsOK(res1)) {
2777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_block" "', argument " "1"" of type '" "Device *""'");
2779 arg1 = (Device *)(argp1);
2781 if (sizeof(guint) == 1) {
2782 arg2 = amglue_SvU8(ST(1));
2783 } else if (sizeof(guint) == 2) {
2784 arg2 = amglue_SvU16(ST(1));
2785 } else if (sizeof(guint) == 4) {
2786 arg2 = amglue_SvU32(ST(1));
2787 } else if (sizeof(guint) == 8) {
2788 arg2 = amglue_SvU64(ST(1));
2790 croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
2793 res3 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg3), 0, 0);
2794 if (!SWIG_IsOK(res3)) {
2795 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_write_block" "', argument " "3"" of type '" "gpointer""'");
2797 result = (gboolean)Device_write_block(arg1,arg2,arg3);
2800 ST(argvi) = &PL_sv_yes;
2802 ST(argvi) = &PL_sv_no;
2816 XS(_wrap_Device_finish_file) {
2818 Device *arg1 = (Device *) 0 ;
2825 if ((items < 1) || (items > 1)) {
2826 SWIG_croak("Usage: Device_finish_file(self);");
2828 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2829 if (!SWIG_IsOK(res1)) {
2830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_finish_file" "', argument " "1"" of type '" "Device *""'");
2832 arg1 = (Device *)(argp1);
2833 result = (gboolean)Device_finish_file(arg1);
2836 ST(argvi) = &PL_sv_yes;
2838 ST(argvi) = &PL_sv_no;
2850 XS(_wrap_Device_seek_file) {
2852 Device *arg1 = (Device *) 0 ;
2857 dumpfile_t *result = 0 ;
2860 if ((items < 2) || (items > 2)) {
2861 SWIG_croak("Usage: Device_seek_file(self,file);");
2863 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2864 if (!SWIG_IsOK(res1)) {
2865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_seek_file" "', argument " "1"" of type '" "Device *""'");
2867 arg1 = (Device *)(argp1);
2869 if (sizeof(guint) == 1) {
2870 arg2 = amglue_SvU8(ST(1));
2871 } else if (sizeof(guint) == 2) {
2872 arg2 = amglue_SvU16(ST(1));
2873 } else if (sizeof(guint) == 4) {
2874 arg2 = amglue_SvU32(ST(1));
2875 } else if (sizeof(guint) == 8) {
2876 arg2 = amglue_SvU64(ST(1));
2878 croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
2881 result = (dumpfile_t *)Device_seek_file(arg1,arg2);
2882 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, 0 | SWIG_SHADOW); argvi++ ;
2892 XS(_wrap_Device_seek_block) {
2894 Device *arg1 = (Device *) 0 ;
2902 if ((items < 2) || (items > 2)) {
2903 SWIG_croak("Usage: Device_seek_block(self,block);");
2905 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2906 if (!SWIG_IsOK(res1)) {
2907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_seek_block" "', argument " "1"" of type '" "Device *""'");
2909 arg1 = (Device *)(argp1);
2911 arg2 = amglue_SvU64(ST(1));
2913 result = (gboolean)Device_seek_block(arg1,arg2);
2916 ST(argvi) = &PL_sv_yes;
2918 ST(argvi) = &PL_sv_no;
2930 XS(_wrap_Device_read_block) {
2932 Device *arg1 = (Device *) 0 ;
2933 gpointer arg2 = (gpointer) 0 ;
2934 int *arg3 = (int *) 0 ;
2944 if ((items < 3) || (items > 3)) {
2945 SWIG_croak("Usage: Device_read_block(self,buffer,size);");
2947 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2948 if (!SWIG_IsOK(res1)) {
2949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_block" "', argument " "1"" of type '" "Device *""'");
2951 arg1 = (Device *)(argp1);
2952 res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
2953 if (!SWIG_IsOK(res2)) {
2954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_read_block" "', argument " "2"" of type '" "gpointer""'");
2956 res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_int, 0 | 0 );
2957 if (!SWIG_IsOK(res3)) {
2958 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_read_block" "', argument " "3"" of type '" "int *""'");
2960 arg3 = (int *)(argp3);
2961 result = (int)Device_read_block(arg1,arg2,arg3);
2964 SP += argvi; PUTBACK;
2965 for_stack = sv_2mortal(amglue_newSVi64(result));
2966 SPAGAIN; SP -= argvi;
2967 ST(argvi) = for_stack;
2983 XS(_wrap_Device_erase) {
2985 Device *arg1 = (Device *) 0 ;
2992 if ((items < 1) || (items > 1)) {
2993 SWIG_croak("Usage: Device_erase(self);");
2995 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
2996 if (!SWIG_IsOK(res1)) {
2997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_erase" "', argument " "1"" of type '" "Device *""'");
2999 arg1 = (Device *)(argp1);
3000 result = (gboolean)Device_erase(arg1);
3003 ST(argvi) = &PL_sv_yes;
3005 ST(argvi) = &PL_sv_no;
3017 XS(_wrap_Device_eject) {
3019 Device *arg1 = (Device *) 0 ;
3026 if ((items < 1) || (items > 1)) {
3027 SWIG_croak("Usage: Device_eject(self);");
3029 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3030 if (!SWIG_IsOK(res1)) {
3031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_eject" "', argument " "1"" of type '" "Device *""'");
3033 arg1 = (Device *)(argp1);
3034 result = (gboolean)Device_eject(arg1);
3037 ST(argvi) = &PL_sv_yes;
3039 ST(argvi) = &PL_sv_no;
3051 XS(_wrap_Device_directtcp_supported) {
3053 Device *arg1 = (Device *) 0 ;
3060 if ((items < 1) || (items > 1)) {
3061 SWIG_croak("Usage: Device_directtcp_supported(self);");
3063 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3064 if (!SWIG_IsOK(res1)) {
3065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_directtcp_supported" "', argument " "1"" of type '" "Device *""'");
3067 arg1 = (Device *)(argp1);
3068 result = (gboolean)Device_directtcp_supported(arg1);
3071 ST(argvi) = &PL_sv_yes;
3073 ST(argvi) = &PL_sv_no;
3085 XS(_wrap_Device_listen) {
3087 Device *arg1 = (Device *) 0 ;
3089 DirectTCPAddr **arg3 = (DirectTCPAddr **) 0 ;
3092 DirectTCPAddr *addrs3 ;
3100 if ((items < 2) || (items > 2)) {
3101 SWIG_croak("Usage: Device_listen(self,for_writing);");
3103 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3104 if (!SWIG_IsOK(res1)) {
3105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_listen" "', argument " "1"" of type '" "Device *""'");
3107 arg1 = (Device *)(argp1);
3109 arg2 = SvTRUE(ST(1));
3111 Device_listen(arg1,arg2,arg3);
3112 ST(argvi) = sv_newmortal();
3114 if (arg3 && *arg3) {
3115 DirectTCPAddr *iter = *arg3;
3119 while (iter && SU_GET_FAMILY(iter) != 0) {
3120 char *addr = str_sockaddr_no_port(iter);
3121 AV *tuple = newAV();
3123 g_assert(NULL != av_store(tuple, 0, newSVpv(addr, 0)));
3124 g_assert(NULL != av_store(tuple, 1, newSViv(SU_GET_PORT(iter))));
3125 g_assert(NULL != av_store(av, i++, newRV_noinc((SV *)tuple)));
3129 ST(argvi) = newRV_noinc((SV *)av);
3146 XS(_wrap_Device_accept) {
3148 Device *arg1 = (Device *) 0 ;
3152 DirectTCPConnection *result = 0 ;
3155 if ((items < 1) || (items > 1)) {
3156 SWIG_croak("Usage: Device_accept(self);");
3158 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3159 if (!SWIG_IsOK(res1)) {
3160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_accept" "', argument " "1"" of type '" "Device *""'");
3162 arg1 = (Device *)(argp1);
3163 result = (DirectTCPConnection *)Device_accept(arg1);
3164 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3174 XS(_wrap_Device_connect) {
3176 Device *arg1 = (Device *) 0 ;
3178 DirectTCPAddr *arg3 = (DirectTCPAddr *) 0 ;
3182 DirectTCPConnection *result = 0 ;
3185 if ((items < 3) || (items > 3)) {
3186 SWIG_croak("Usage: Device_connect(self,for_writing,addrs);");
3188 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3189 if (!SWIG_IsOK(res1)) {
3190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_connect" "', argument " "1"" of type '" "Device *""'");
3192 arg1 = (Device *)(argp1);
3194 arg2 = SvTRUE(ST(1));
3200 if (!SvROK(ST(2)) || SvTYPE(SvRV(ST(2))) != SVt_PVAV) {
3201 SWIG_exception_fail(SWIG_TypeError, "must provide an arrayref of DirectTCPAddrs");
3203 addrs_av = (AV *)SvRV(ST(2));
3204 num_addrs = av_len(addrs_av)+1;
3206 arg3 = g_new0(DirectTCPAddr, num_addrs+1);
3208 for (i = 0; i < num_addrs; i++) {
3209 SV **svp = av_fetch(addrs_av, i, 0);
3211 sockaddr_union addr;
3214 if (!svp || !SvROK(*svp) || SvTYPE(SvRV(*svp)) != SVt_PVAV
3215 || av_len((AV *)SvRV(*svp))+1 != 2) {
3216 SWIG_exception_fail(SWIG_TypeError, "each DirectTCPAddr must be a 2-element arrayref");
3219 addr_av = (AV *)SvRV(*svp);
3222 svp = av_fetch(addr_av, 0, 0);
3223 if (!svp || !SvPOK(*svp) || !str_to_sockaddr(SvPV_nolen(*svp), &addr)) {
3224 SWIG_exception_fail(SWIG_TypeError, "invalid IPv4 addr in address");
3228 svp = av_fetch(addr_av, 1, 0);
3229 if (!svp || !SvIOK(*svp) || (port = SvIV(*svp)) <= 0 || port >= 65536) {
3230 SWIG_exception_fail(SWIG_TypeError, "invalid port in address");
3232 SU_SET_PORT(&addr, port);
3234 copy_sockaddr(arg3, &addr);
3237 result = (DirectTCPConnection *)Device_connect(arg1,arg2,arg3);
3238 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
3252 XS(_wrap_Device_use_connection) {
3254 Device *arg1 = (Device *) 0 ;
3255 DirectTCPConnection *arg2 = (DirectTCPConnection *) 0 ;
3264 if ((items < 2) || (items > 2)) {
3265 SWIG_croak("Usage: Device_use_connection(self,conn);");
3267 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3268 if (!SWIG_IsOK(res1)) {
3269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_use_connection" "', argument " "1"" of type '" "Device *""'");
3271 arg1 = (Device *)(argp1);
3272 res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_DirectTCPConnection, 0 | 0 );
3273 if (!SWIG_IsOK(res2)) {
3274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_use_connection" "', argument " "2"" of type '" "DirectTCPConnection *""'");
3276 arg2 = (DirectTCPConnection *)(argp2);
3277 result = (gboolean)Device_use_connection(arg1,arg2);
3280 ST(argvi) = &PL_sv_yes;
3282 ST(argvi) = &PL_sv_no;
3296 XS(_wrap_Device_write_from_connection) {
3298 Device *arg1 = (Device *) 0 ;
3300 guint64 *arg3 = (guint64 *) 0 ;
3312 if ((items < 2) || (items > 2)) {
3313 SWIG_croak("Usage: Device_write_from_connection(self,size);");
3315 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3316 if (!SWIG_IsOK(res1)) {
3317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_from_connection" "', argument " "1"" of type '" "Device *""'");
3319 arg1 = (Device *)(argp1);
3321 arg2 = amglue_SvU64(ST(1));
3323 result = (gboolean)Device_write_from_connection(arg1,arg2,arg3);
3326 ST(argvi) = &PL_sv_yes;
3328 ST(argvi) = &PL_sv_no;
3332 SP += argvi; PUTBACK;
3333 ST(argvi) = sv_2mortal(amglue_newSVu64(*arg3));
3334 SPAGAIN; SP -= argvi; argvi++;
3347 XS(_wrap_Device_read_to_connection) {
3349 Device *arg1 = (Device *) 0 ;
3351 guint64 *arg3 = (guint64 *) 0 ;
3363 if ((items < 2) || (items > 2)) {
3364 SWIG_croak("Usage: Device_read_to_connection(self,size);");
3366 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3367 if (!SWIG_IsOK(res1)) {
3368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_to_connection" "', argument " "1"" of type '" "Device *""'");
3370 arg1 = (Device *)(argp1);
3372 arg2 = amglue_SvU64(ST(1));
3374 result = (gboolean)Device_read_to_connection(arg1,arg2,arg3);
3377 ST(argvi) = &PL_sv_yes;
3379 ST(argvi) = &PL_sv_no;
3383 SP += argvi; PUTBACK;
3384 ST(argvi) = sv_2mortal(amglue_newSVu64(*arg3));
3385 SPAGAIN; SP -= argvi; argvi++;
3398 XS(_wrap_Device_property_list) {
3400 Device *arg1 = (Device *) 0 ;
3404 GSList *result = 0 ;
3407 if ((items < 1) || (items > 1)) {
3408 SWIG_croak("Usage: Device_property_list(self);");
3410 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3411 if (!SWIG_IsOK(res1)) {
3412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_list" "', argument " "1"" of type '" "Device *""'");
3414 arg1 = (Device *)(argp1);
3415 result = (GSList *)Device_property_list(arg1);
3419 /* Count the DeviceProperties */
3420 EXTEND(SP, g_slist_length(result)); /* make room for return values */
3422 /* Note that we set ST(argvi) several times. the nature of
3423 * SWIG's wrapping is such that incrementing argvi points
3424 * ST(argvi) to the next location in perl's argument stack.
3427 for (iter = result; iter; iter = g_slist_next(iter)) {
3428 DeviceProperty *prop = iter->data;
3430 SV *rv = newRV_noinc((SV *)hash);
3432 hv_store(hash, "name", 4,
3433 newSVpv(prop->base->name, 0), 0);
3434 hv_store(hash, "description", 11,
3435 newSVpv(prop->base->description, 0), 0);
3436 hv_store(hash, "access", 6,
3437 newSViv(prop->access), 0);
3438 ST(argvi) = sv_2mortal(rv);
3451 XS(_wrap_Device_property_get) {
3453 Device *arg1 = (Device *) 0 ;
3454 DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
3455 GValue *arg3 = (GValue *) 0 ;
3456 PropertySurety *arg4 = (PropertySurety *) 0 ;
3457 PropertySource *arg5 = (PropertySource *) 0 ;
3458 gboolean *arg6 = (gboolean *) 0 ;
3462 PropertySurety surety3 ;
3463 PropertySource source3 ;
3469 memset(&val3, 0, sizeof(val3));
3471 if (GIMME_V == G_ARRAY) {
3477 if ((items < 2) || (items > 2)) {
3478 SWIG_croak("Usage: Device_property_get(self,pbase,surety,source,val_found);");
3480 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3481 if (!SWIG_IsOK(res1)) {
3482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_get" "', argument " "1"" of type '" "Device *""'");
3484 arg1 = (Device *)(argp1);
3489 pname = SvPV_nolen(ST(1));
3492 arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
3496 Device_property_get(arg1,arg2,arg3,arg4,arg5,arg6);
3497 ST(argvi) = sv_newmortal();
3499 /* if the result is valid */
3501 /* move data from arg3 to ST(argvi), somehow, being careful to
3502 * save the perl stack while doing so */
3503 SP += argvi; PUTBACK;
3504 ST(argvi) = set_sv_from_gvalue(arg3);
3505 SPAGAIN; SP -= argvi; argvi++;
3507 /* free any memory for the GValue */
3508 g_value_unset(arg3);
3510 if (GIMME_V == G_ARRAY) {
3511 ST(argvi) = newSViv(*arg4);
3513 ST(argvi) = newSViv(*arg5);
3517 /* otherwise, return nothing */
3530 XS(_wrap_Device_property_set) {
3532 Device *arg1 = (Device *) 0 ;
3533 DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
3534 SV *arg3 = (SV *) 0 ;
3541 if ((items < 3) || (items > 3)) {
3542 SWIG_croak("Usage: Device_property_set(self,pbase,sv);");
3544 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3545 if (!SWIG_IsOK(res1)) {
3546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_set" "', argument " "1"" of type '" "Device *""'");
3548 arg1 = (Device *)(argp1);
3553 pname = SvPV_nolen(ST(1));
3556 arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
3561 result = (gboolean)Device_property_set(arg1,arg2,arg3);
3564 ST(argvi) = &PL_sv_yes;
3566 ST(argvi) = &PL_sv_no;
3582 XS(_wrap_Device_property_set_ex) {
3584 Device *arg1 = (Device *) 0 ;
3585 DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
3586 SV *arg3 = (SV *) 0 ;
3587 PropertySurety arg4 ;
3588 PropertySource arg5 ;
3595 if ((items < 5) || (items > 5)) {
3596 SWIG_croak("Usage: Device_property_set_ex(self,pbase,sv,surety,source);");
3598 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3599 if (!SWIG_IsOK(res1)) {
3600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_set_ex" "', argument " "1"" of type '" "Device *""'");
3602 arg1 = (Device *)(argp1);
3607 pname = SvPV_nolen(ST(1));
3610 arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
3616 if (sizeof(signed int) == 1) {
3617 arg4 = amglue_SvI8(ST(3));
3618 } else if (sizeof(signed int) == 2) {
3619 arg4 = amglue_SvI16(ST(3));
3620 } else if (sizeof(signed int) == 4) {
3621 arg4 = amglue_SvI32(ST(3));
3622 } else if (sizeof(signed int) == 8) {
3623 arg4 = amglue_SvI64(ST(3));
3625 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3629 if (sizeof(signed int) == 1) {
3630 arg5 = amglue_SvI8(ST(4));
3631 } else if (sizeof(signed int) == 2) {
3632 arg5 = amglue_SvI16(ST(4));
3633 } else if (sizeof(signed int) == 4) {
3634 arg5 = amglue_SvI32(ST(4));
3635 } else if (sizeof(signed int) == 8) {
3636 arg5 = amglue_SvI64(ST(4));
3638 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
3641 result = (gboolean)Device_property_set_ex(arg1,arg2,arg3,arg4,arg5);
3644 ST(argvi) = &PL_sv_yes;
3646 ST(argvi) = &PL_sv_no;
3666 XS(_wrap_Device_recycle_file) {
3668 Device *arg1 = (Device *) 0 ;
3676 if ((items < 2) || (items > 2)) {
3677 SWIG_croak("Usage: Device_recycle_file(self,filenum);");
3679 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3680 if (!SWIG_IsOK(res1)) {
3681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_recycle_file" "', argument " "1"" of type '" "Device *""'");
3683 arg1 = (Device *)(argp1);
3685 if (sizeof(guint) == 1) {
3686 arg2 = amglue_SvU8(ST(1));
3687 } else if (sizeof(guint) == 2) {
3688 arg2 = amglue_SvU16(ST(1));
3689 } else if (sizeof(guint) == 4) {
3690 arg2 = amglue_SvU32(ST(1));
3691 } else if (sizeof(guint) == 8) {
3692 arg2 = amglue_SvU64(ST(1));
3694 croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
3697 result = (gboolean)Device_recycle_file(arg1,arg2);
3700 ST(argvi) = &PL_sv_yes;
3702 ST(argvi) = &PL_sv_no;
3714 XS(_wrap_Device_file) {
3716 Device *arg1 = (Device *) 0 ;
3723 if ((items < 1) || (items > 1)) {
3724 SWIG_croak("Usage: Device_file(self);");
3726 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3727 if (!SWIG_IsOK(res1)) {
3728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_file" "', argument " "1"" of type '" "Device *""'");
3730 arg1 = (Device *)(argp1);
3731 result = (int)Device_file(arg1);
3734 SP += argvi; PUTBACK;
3735 for_stack = sv_2mortal(amglue_newSVi64(result));
3736 SPAGAIN; SP -= argvi;
3737 ST(argvi) = for_stack;
3749 XS(_wrap_Device_block) {
3751 Device *arg1 = (Device *) 0 ;
3758 if ((items < 1) || (items > 1)) {
3759 SWIG_croak("Usage: Device_block(self);");
3761 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3762 if (!SWIG_IsOK(res1)) {
3763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_block" "', argument " "1"" of type '" "Device *""'");
3765 arg1 = (Device *)(argp1);
3766 result = Device_block(arg1);
3769 SP += argvi; PUTBACK;
3770 for_stack = sv_2mortal(amglue_newSVu64(result));
3771 SPAGAIN; SP -= argvi;
3772 ST(argvi) = for_stack;
3784 XS(_wrap_Device_in_file) {
3786 Device *arg1 = (Device *) 0 ;
3793 if ((items < 1) || (items > 1)) {
3794 SWIG_croak("Usage: Device_in_file(self);");
3796 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3797 if (!SWIG_IsOK(res1)) {
3798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_in_file" "', argument " "1"" of type '" "Device *""'");
3800 arg1 = (Device *)(argp1);
3801 result = (gboolean)Device_in_file(arg1);
3804 ST(argvi) = &PL_sv_yes;
3806 ST(argvi) = &PL_sv_no;
3818 XS(_wrap_Device_device_name) {
3820 Device *arg1 = (Device *) 0 ;
3827 if ((items < 1) || (items > 1)) {
3828 SWIG_croak("Usage: Device_device_name(self);");
3830 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3831 if (!SWIG_IsOK(res1)) {
3832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_device_name" "', argument " "1"" of type '" "Device *""'");
3834 arg1 = (Device *)(argp1);
3835 result = (char *)Device_device_name(arg1);
3836 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3846 XS(_wrap_Device_access_mode) {
3848 Device *arg1 = (Device *) 0 ;
3852 DeviceAccessMode result;
3855 if ((items < 1) || (items > 1)) {
3856 SWIG_croak("Usage: Device_access_mode(self);");
3858 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3859 if (!SWIG_IsOK(res1)) {
3860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_access_mode" "', argument " "1"" of type '" "Device *""'");
3862 arg1 = (Device *)(argp1);
3863 result = (DeviceAccessMode)Device_access_mode(arg1);
3866 SP += argvi; PUTBACK;
3867 for_stack = sv_2mortal(amglue_newSVi64(result));
3868 SPAGAIN; SP -= argvi;
3869 ST(argvi) = for_stack;
3881 XS(_wrap_Device_is_eof) {
3883 Device *arg1 = (Device *) 0 ;
3890 if ((items < 1) || (items > 1)) {
3891 SWIG_croak("Usage: Device_is_eof(self);");
3893 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3894 if (!SWIG_IsOK(res1)) {
3895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_is_eof" "', argument " "1"" of type '" "Device *""'");
3897 arg1 = (Device *)(argp1);
3898 result = (gboolean)Device_is_eof(arg1);
3901 ST(argvi) = &PL_sv_yes;
3903 ST(argvi) = &PL_sv_no;
3915 XS(_wrap_Device_is_eom) {
3917 Device *arg1 = (Device *) 0 ;
3924 if ((items < 1) || (items > 1)) {
3925 SWIG_croak("Usage: Device_is_eom(self);");
3927 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3928 if (!SWIG_IsOK(res1)) {
3929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_is_eom" "', argument " "1"" of type '" "Device *""'");
3931 arg1 = (Device *)(argp1);
3932 result = (gboolean)Device_is_eom(arg1);
3935 ST(argvi) = &PL_sv_yes;
3937 ST(argvi) = &PL_sv_no;
3949 XS(_wrap_Device_volume_label) {
3951 Device *arg1 = (Device *) 0 ;
3958 if ((items < 1) || (items > 1)) {
3959 SWIG_croak("Usage: Device_volume_label(self);");
3961 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3962 if (!SWIG_IsOK(res1)) {
3963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_label" "', argument " "1"" of type '" "Device *""'");
3965 arg1 = (Device *)(argp1);
3966 result = (char *)Device_volume_label(arg1);
3967 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
3977 XS(_wrap_Device_volume_time) {
3979 Device *arg1 = (Device *) 0 ;
3986 if ((items < 1) || (items > 1)) {
3987 SWIG_croak("Usage: Device_volume_time(self);");
3989 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
3990 if (!SWIG_IsOK(res1)) {
3991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_time" "', argument " "1"" of type '" "Device *""'");
3993 arg1 = (Device *)(argp1);
3994 result = (char *)Device_volume_time(arg1);
3995 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
4005 XS(_wrap_Device_status) {
4007 Device *arg1 = (Device *) 0 ;
4011 DeviceStatusFlags result;
4014 if ((items < 1) || (items > 1)) {
4015 SWIG_croak("Usage: Device_status(self);");
4017 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
4018 if (!SWIG_IsOK(res1)) {
4019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_status" "', argument " "1"" of type '" "Device *""'");
4021 arg1 = (Device *)(argp1);
4022 result = (DeviceStatusFlags)Device_status(arg1);
4025 SP += argvi; PUTBACK;
4026 for_stack = sv_2mortal(amglue_newSVi64(result));
4027 SPAGAIN; SP -= argvi;
4028 ST(argvi) = for_stack;
4040 XS(_wrap_Device_min_block_size) {
4042 Device *arg1 = (Device *) 0 ;
4049 if ((items < 1) || (items > 1)) {
4050 SWIG_croak("Usage: Device_min_block_size(self);");
4052 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
4053 if (!SWIG_IsOK(res1)) {
4054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_min_block_size" "', argument " "1"" of type '" "Device *""'");
4056 arg1 = (Device *)(argp1);
4057 result = Device_min_block_size(arg1);
4060 SP += argvi; PUTBACK;
4061 for_stack = sv_2mortal(amglue_newSVu64(result));
4062 SPAGAIN; SP -= argvi;
4063 ST(argvi) = for_stack;
4075 XS(_wrap_Device_max_block_size) {
4077 Device *arg1 = (Device *) 0 ;
4084 if ((items < 1) || (items > 1)) {
4085 SWIG_croak("Usage: Device_max_block_size(self);");
4087 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
4088 if (!SWIG_IsOK(res1)) {
4089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_max_block_size" "', argument " "1"" of type '" "Device *""'");
4091 arg1 = (Device *)(argp1);
4092 result = Device_max_block_size(arg1);
4095 SP += argvi; PUTBACK;
4096 for_stack = sv_2mortal(amglue_newSVu64(result));
4097 SPAGAIN; SP -= argvi;
4098 ST(argvi) = for_stack;
4110 XS(_wrap_Device_block_size) {
4112 Device *arg1 = (Device *) 0 ;
4119 if ((items < 1) || (items > 1)) {
4120 SWIG_croak("Usage: Device_block_size(self);");
4122 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
4123 if (!SWIG_IsOK(res1)) {
4124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_block_size" "', argument " "1"" of type '" "Device *""'");
4126 arg1 = (Device *)(argp1);
4127 result = Device_block_size(arg1);
4130 SP += argvi; PUTBACK;
4131 for_stack = sv_2mortal(amglue_newSVu64(result));
4132 SPAGAIN; SP -= argvi;
4133 ST(argvi) = for_stack;
4145 XS(_wrap_Device_header_block_size) {
4147 Device *arg1 = (Device *) 0 ;
4154 if ((items < 1) || (items > 1)) {
4155 SWIG_croak("Usage: Device_header_block_size(self);");
4157 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
4158 if (!SWIG_IsOK(res1)) {
4159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_header_block_size" "', argument " "1"" of type '" "Device *""'");
4161 arg1 = (Device *)(argp1);
4162 result = Device_header_block_size(arg1);
4165 SP += argvi; PUTBACK;
4166 for_stack = sv_2mortal(amglue_newSVu64(result));
4167 SPAGAIN; SP -= argvi;
4168 ST(argvi) = for_stack;
4180 XS(_wrap_Device_volume_header) {
4182 Device *arg1 = (Device *) 0 ;
4186 dumpfile_t *result = 0 ;
4189 if ((items < 1) || (items > 1)) {
4190 SWIG_croak("Usage: Device_volume_header(self);");
4192 res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 | 0 );
4193 if (!SWIG_IsOK(res1)) {
4194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_header" "', argument " "1"" of type '" "Device *""'");
4196 arg1 = (Device *)(argp1);
4197 result = (dumpfile_t *)Device_volume_header(arg1);
4198 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, 0 | SWIG_SHADOW); argvi++ ;
4208 XS(_wrap_rait_device_open_from_children) {
4210 GSList *arg1 = (GSList *) 0 ;
4212 Device *result = 0 ;
4215 if ((items < 1) || (items > 1)) {
4216 SWIG_croak("Usage: rait_device_open_from_children(child_devices);");
4222 if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
4223 SWIG_exception(SWIG_TypeError, "Expected an arrayref");
4225 av = (AV *)SvRV(ST(0));
4229 for (i = 0; i <= len; i++) {
4230 SV **elt = av_fetch(av, i, 0);
4233 if (elt && !SvOK(*elt)) {
4234 arg1 = g_slist_append(arg1, NULL); /* 'undef' => NULL */
4235 } else if (!elt || SWIG_ConvertPtr(*elt, (void **)&d, SWIGTYPE_p_Device, 0) == -1) {
4236 SWIG_exception(SWIG_TypeError, "array member is not a Device");
4238 arg1 = g_slist_append(arg1, d);
4242 result = (Device *)rait_device_open_from_children(arg1);
4243 ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Device, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
4257 XS(_wrap_write_random_to_device) {
4261 Device *arg3 = (Device *) 0 ;
4268 if ((items < 3) || (items > 3)) {
4269 SWIG_croak("Usage: write_random_to_device(seed,length,device);");
4272 arg1 = amglue_SvU32(ST(0));
4275 if (sizeof(size_t) == 1) {
4276 arg2 = amglue_SvU8(ST(1));
4277 } else if (sizeof(size_t) == 2) {
4278 arg2 = amglue_SvU16(ST(1));
4279 } else if (sizeof(size_t) == 4) {
4280 arg2 = amglue_SvU32(ST(1));
4281 } else if (sizeof(size_t) == 8) {
4282 arg2 = amglue_SvU64(ST(1));
4284 croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
4287 res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_Device, 0 | 0 );
4288 if (!SWIG_IsOK(res3)) {
4289 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "write_random_to_device" "', argument " "3"" of type '" "Device *""'");
4291 arg3 = (Device *)(argp3);
4292 result = (gboolean)write_random_to_device(arg1,arg2,arg3);
4295 ST(argvi) = &PL_sv_yes;
4297 ST(argvi) = &PL_sv_no;
4311 XS(_wrap_verify_random_from_device) {
4315 Device *arg3 = (Device *) 0 ;
4322 if ((items < 3) || (items > 3)) {
4323 SWIG_croak("Usage: verify_random_from_device(seed,length,device);");
4326 arg1 = amglue_SvU32(ST(0));
4329 if (sizeof(size_t) == 1) {
4330 arg2 = amglue_SvU8(ST(1));
4331 } else if (sizeof(size_t) == 2) {
4332 arg2 = amglue_SvU16(ST(1));
4333 } else if (sizeof(size_t) == 4) {
4334 arg2 = amglue_SvU32(ST(1));
4335 } else if (sizeof(size_t) == 8) {
4336 arg2 = amglue_SvU64(ST(1));
4338 croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
4341 res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_Device, 0 | 0 );
4342 if (!SWIG_IsOK(res3)) {
4343 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "verify_random_from_device" "', argument " "3"" of type '" "Device *""'");
4345 arg3 = (Device *)(argp3);
4346 result = (gboolean)verify_random_from_device(arg1,arg2,arg3);
4349 ST(argvi) = &PL_sv_yes;
4351 ST(argvi) = &PL_sv_no;
4365 XS(_wrap_IS_WRITABLE_ACCESS_MODE) {
4367 DeviceAccessMode arg1 ;
4372 if ((items < 1) || (items > 1)) {
4373 SWIG_croak("Usage: IS_WRITABLE_ACCESS_MODE(mode);");
4376 if (sizeof(signed int) == 1) {
4377 arg1 = amglue_SvI8(ST(0));
4378 } else if (sizeof(signed int) == 2) {
4379 arg1 = amglue_SvI16(ST(0));
4380 } else if (sizeof(signed int) == 4) {
4381 arg1 = amglue_SvI32(ST(0));
4382 } else if (sizeof(signed int) == 8) {
4383 arg1 = amglue_SvI64(ST(0));
4385 g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
4388 result = (gboolean)IS_WRITABLE_ACCESS_MODE(arg1);
4391 ST(argvi) = &PL_sv_yes;
4393 ST(argvi) = &PL_sv_no;
4406 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
4408 static swig_type_info _swigt__p_Device = {"_p_Device", "struct Device *|Device *", 0, 0, (void*)"Amanda::Device::Device", 0};
4409 static swig_type_info _swigt__p_DevicePropertyBase = {"_p_DevicePropertyBase", "DevicePropertyBase *", 0, 0, (void*)0, 0};
4410 static swig_type_info _swigt__p_DirectTCPAddr = {"_p_DirectTCPAddr", "DirectTCPAddr *", 0, 0, (void*)0, 0};
4411 static swig_type_info _swigt__p_DirectTCPConnection = {"_p_DirectTCPConnection", "struct DirectTCPConnection *|DirectTCPConnection *", 0, 0, (void*)"Amanda::Device::DirectTCPConnection", 0};
4412 static swig_type_info _swigt__p_GSList = {"_p_GSList", "GSList *", 0, 0, (void*)0, 0};
4413 static swig_type_info _swigt__p_GValue = {"_p_GValue", "GValue *", 0, 0, (void*)0, 0};
4414 static swig_type_info _swigt__p_a_STRMAX__char = {"_p_a_STRMAX__char", "char (*)[STRMAX]|string_t *", 0, 0, (void*)0, 0};
4415 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
4416 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
4417 static swig_type_info _swigt__p_dumpfile_t = {"_p_dumpfile_t", "dumpfile_t *", 0, 0, (void*)"Amanda::Header::Header", 0};
4418 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
4419 static swig_type_info _swigt__p_guint = {"_p_guint", "guint *", 0, 0, (void*)0, 0};
4420 static swig_type_info _swigt__p_guint32 = {"_p_guint32", "guint32 *", 0, 0, (void*)0, 0};
4421 static swig_type_info _swigt__p_guint64 = {"_p_guint64", "guint64 *", 0, 0, (void*)0, 0};
4422 static swig_type_info _swigt__p_int = {"_p_int", "int *|PropertySurety *|ConcurrencyParadigm *|filetype_t *|PropertySource *|StreamingRequirement *|gboolean *|DeviceAccessMode *|MediaAccessMode *|DeviceStatusFlags *|PropertyPhaseFlags *|PropertyAccessFlags *", 0, 0, (void*)0, 0};
4423 static swig_type_info _swigt__p_p_DirectTCPAddr = {"_p_p_DirectTCPAddr", "DirectTCPAddr **", 0, 0, (void*)0, 0};
4424 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
4426 static swig_type_info *swig_type_initial[] = {
4428 &_swigt__p_DevicePropertyBase,
4429 &_swigt__p_DirectTCPAddr,
4430 &_swigt__p_DirectTCPConnection,
4433 &_swigt__p_a_STRMAX__char,
4436 &_swigt__p_dumpfile_t,
4442 &_swigt__p_p_DirectTCPAddr,
4443 &_swigt__p_unsigned_char,
4446 static swig_cast_info _swigc__p_Device[] = { {&_swigt__p_Device, 0, 0, 0},{0, 0, 0, 0}};
4447 static swig_cast_info _swigc__p_DevicePropertyBase[] = { {&_swigt__p_DevicePropertyBase, 0, 0, 0},{0, 0, 0, 0}};
4448 static swig_cast_info _swigc__p_DirectTCPAddr[] = { {&_swigt__p_DirectTCPAddr, 0, 0, 0},{0, 0, 0, 0}};
4449 static swig_cast_info _swigc__p_DirectTCPConnection[] = { {&_swigt__p_DirectTCPConnection, 0, 0, 0},{0, 0, 0, 0}};
4450 static swig_cast_info _swigc__p_GSList[] = { {&_swigt__p_GSList, 0, 0, 0},{0, 0, 0, 0}};
4451 static swig_cast_info _swigc__p_GValue[] = { {&_swigt__p_GValue, 0, 0, 0},{0, 0, 0, 0}};
4452 static swig_cast_info _swigc__p_a_STRMAX__char[] = { {&_swigt__p_a_STRMAX__char, 0, 0, 0},{0, 0, 0, 0}};
4453 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
4454 static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
4455 static swig_cast_info _swigc__p_dumpfile_t[] = { {&_swigt__p_dumpfile_t, 0, 0, 0},{0, 0, 0, 0}};
4456 static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
4457 static swig_cast_info _swigc__p_guint[] = { {&_swigt__p_guint, 0, 0, 0},{0, 0, 0, 0}};
4458 static swig_cast_info _swigc__p_guint32[] = { {&_swigt__p_guint32, 0, 0, 0},{0, 0, 0, 0}};
4459 static swig_cast_info _swigc__p_guint64[] = { {&_swigt__p_guint64, 0, 0, 0},{0, 0, 0, 0}};
4460 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
4461 static swig_cast_info _swigc__p_p_DirectTCPAddr[] = { {&_swigt__p_p_DirectTCPAddr, 0, 0, 0},{0, 0, 0, 0}};
4462 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
4464 static swig_cast_info *swig_cast_initial[] = {
4466 _swigc__p_DevicePropertyBase,
4467 _swigc__p_DirectTCPAddr,
4468 _swigc__p_DirectTCPConnection,
4471 _swigc__p_a_STRMAX__char,
4474 _swigc__p_dumpfile_t,
4480 _swigc__p_p_DirectTCPAddr,
4481 _swigc__p_unsigned_char,
4485 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
4487 static swig_constant_info swig_constants[] = {
4493 static swig_variable_info swig_variables[] = {
4496 static swig_command_info swig_commands[] = {
4497 {"Amanda::Devicec::delete_DirectTCPConnection", _wrap_delete_DirectTCPConnection},
4498 {"Amanda::Devicec::DirectTCPConnection_close", _wrap_DirectTCPConnection_close},
4499 {"Amanda::Devicec::new_DirectTCPConnection", _wrap_new_DirectTCPConnection},
4500 {"Amanda::Devicec::unaliased_name", _wrap_unaliased_name},
4501 {"Amanda::Devicec::new_Device", _wrap_new_Device},
4502 {"Amanda::Devicec::delete_Device", _wrap_delete_Device},
4503 {"Amanda::Devicec::Device_configure", _wrap_Device_configure},
4504 {"Amanda::Devicec::Device_error", _wrap_Device_error},
4505 {"Amanda::Devicec::Device_status_error", _wrap_Device_status_error},
4506 {"Amanda::Devicec::Device_error_or_status", _wrap_Device_error_or_status},
4507 {"Amanda::Devicec::Device_read_label", _wrap_Device_read_label},
4508 {"Amanda::Devicec::Device_start", _wrap_Device_start},
4509 {"Amanda::Devicec::Device_finish", _wrap_Device_finish},
4510 {"Amanda::Devicec::Device_start_file", _wrap_Device_start_file},
4511 {"Amanda::Devicec::Device_write_block", _wrap_Device_write_block},
4512 {"Amanda::Devicec::Device_finish_file", _wrap_Device_finish_file},
4513 {"Amanda::Devicec::Device_seek_file", _wrap_Device_seek_file},
4514 {"Amanda::Devicec::Device_seek_block", _wrap_Device_seek_block},
4515 {"Amanda::Devicec::Device_read_block", _wrap_Device_read_block},
4516 {"Amanda::Devicec::Device_erase", _wrap_Device_erase},
4517 {"Amanda::Devicec::Device_eject", _wrap_Device_eject},
4518 {"Amanda::Devicec::Device_directtcp_supported", _wrap_Device_directtcp_supported},
4519 {"Amanda::Devicec::Device_listen", _wrap_Device_listen},
4520 {"Amanda::Devicec::Device_accept", _wrap_Device_accept},
4521 {"Amanda::Devicec::Device_connect", _wrap_Device_connect},
4522 {"Amanda::Devicec::Device_use_connection", _wrap_Device_use_connection},
4523 {"Amanda::Devicec::Device_write_from_connection", _wrap_Device_write_from_connection},
4524 {"Amanda::Devicec::Device_read_to_connection", _wrap_Device_read_to_connection},
4525 {"Amanda::Devicec::Device_property_list", _wrap_Device_property_list},
4526 {"Amanda::Devicec::Device_property_get", _wrap_Device_property_get},
4527 {"Amanda::Devicec::Device_property_set", _wrap_Device_property_set},
4528 {"Amanda::Devicec::Device_property_set_ex", _wrap_Device_property_set_ex},
4529 {"Amanda::Devicec::Device_recycle_file", _wrap_Device_recycle_file},
4530 {"Amanda::Devicec::Device_file", _wrap_Device_file},
4531 {"Amanda::Devicec::Device_block", _wrap_Device_block},
4532 {"Amanda::Devicec::Device_in_file", _wrap_Device_in_file},
4533 {"Amanda::Devicec::Device_device_name", _wrap_Device_device_name},
4534 {"Amanda::Devicec::Device_access_mode", _wrap_Device_access_mode},
4535 {"Amanda::Devicec::Device_is_eof", _wrap_Device_is_eof},
4536 {"Amanda::Devicec::Device_is_eom", _wrap_Device_is_eom},
4537 {"Amanda::Devicec::Device_volume_label", _wrap_Device_volume_label},
4538 {"Amanda::Devicec::Device_volume_time", _wrap_Device_volume_time},
4539 {"Amanda::Devicec::Device_status", _wrap_Device_status},
4540 {"Amanda::Devicec::Device_min_block_size", _wrap_Device_min_block_size},
4541 {"Amanda::Devicec::Device_max_block_size", _wrap_Device_max_block_size},
4542 {"Amanda::Devicec::Device_block_size", _wrap_Device_block_size},
4543 {"Amanda::Devicec::Device_header_block_size", _wrap_Device_header_block_size},
4544 {"Amanda::Devicec::Device_volume_header", _wrap_Device_volume_header},
4545 {"Amanda::Devicec::rait_device_open_from_children", _wrap_rait_device_open_from_children},
4546 {"Amanda::Devicec::write_random_to_device", _wrap_write_random_to_device},
4547 {"Amanda::Devicec::verify_random_from_device", _wrap_verify_random_from_device},
4548 {"Amanda::Devicec::IS_WRITABLE_ACCESS_MODE", _wrap_IS_WRITABLE_ACCESS_MODE},
4551 /* -----------------------------------------------------------------------------
4552 * Type initialization:
4553 * This problem is tough by the requirement that no dynamic
4554 * memory is used. Also, since swig_type_info structures store pointers to
4555 * swig_cast_info structures and swig_cast_info structures store pointers back
4556 * to swig_type_info structures, we need some lookup code at initialization.
4557 * The idea is that swig generates all the structures that are needed.
4558 * The runtime then collects these partially filled structures.
4559 * The SWIG_InitializeModule function takes these initial arrays out of
4560 * swig_module, and does all the lookup, filling in the swig_module.types
4561 * array with the correct data and linking the correct swig_cast_info
4562 * structures together.
4564 * The generated swig_type_info structures are assigned staticly to an initial
4565 * array. We just loop through that array, and handle each type individually.
4566 * First we lookup if this type has been already loaded, and if so, use the
4567 * loaded structure instead of the generated one. Then we have to fill in the
4568 * cast linked list. The cast data is initially stored in something like a
4569 * two-dimensional array. Each row corresponds to a type (there are the same
4570 * number of rows as there are in the swig_type_initial array). Each entry in
4571 * a column is one of the swig_cast_info structures for that type.
4572 * The cast_initial array is actually an array of arrays, because each row has
4573 * a variable number of columns. So to actually build the cast linked list,
4574 * we find the array of casts associated with the type, and loop through it
4575 * adding the casts to the list. The one last trick we need to do is making
4576 * sure the type pointer in the swig_cast_info struct is correct.
4578 * First off, we lookup the cast->type name to see if it is already loaded.
4579 * There are three cases to handle:
4580 * 1) If the cast->type has already been loaded AND the type we are adding
4581 * casting info to has not been loaded (it is in this module), THEN we
4582 * replace the cast->type pointer with the type pointer that has already
4584 * 2) If BOTH types (the one we are adding casting info to, and the
4585 * cast->type) are loaded, THEN the cast info has already been loaded by
4586 * the previous module so we just ignore it.
4587 * 3) Finally, if cast->type has not already been loaded, then we add that
4588 * swig_cast_info to the linked list (because the cast->type) pointer will
4590 * ----------------------------------------------------------------------------- */
4600 #define SWIGRUNTIME_DEBUG
4605 SWIG_InitializeModule(void *clientdata) {
4607 swig_module_info *module_head, *iter;
4610 clientdata = clientdata;
4612 /* check to see if the circular list has been setup, if not, set it up */
4613 if (swig_module.next==0) {
4614 /* Initialize the swig_module */
4615 swig_module.type_initial = swig_type_initial;
4616 swig_module.cast_initial = swig_cast_initial;
4617 swig_module.next = &swig_module;
4623 /* Try and load any already created modules */
4624 module_head = SWIG_GetModule(clientdata);
4626 /* This is the first module loaded for this interpreter */
4627 /* so set the swig module into the interpreter */
4628 SWIG_SetModule(clientdata, &swig_module);
4629 module_head = &swig_module;
4631 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
4635 if (iter==&swig_module) {
4640 } while (iter!= module_head);
4642 /* if the is found in the list, then all is done and we may leave */
4644 /* otherwise we must add out module into the list */
4645 swig_module.next = module_head->next;
4646 module_head->next = &swig_module;
4649 /* When multiple interpeters are used, a module could have already been initialized in
4650 a different interpreter, but not yet have a pointer in this interpreter.
4651 In this case, we do not want to continue adding types... everything should be
4653 if (init == 0) return;
4655 /* Now work on filling in swig_module.types */
4656 #ifdef SWIGRUNTIME_DEBUG
4657 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
4659 for (i = 0; i < swig_module.size; ++i) {
4660 swig_type_info *type = 0;
4661 swig_type_info *ret;
4662 swig_cast_info *cast;
4664 #ifdef SWIGRUNTIME_DEBUG
4665 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4668 /* if there is another module already loaded */
4669 if (swig_module.next != &swig_module) {
4670 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
4673 /* Overwrite clientdata field */
4674 #ifdef SWIGRUNTIME_DEBUG
4675 printf("SWIG_InitializeModule: found type %s\n", type->name);
4677 if (swig_module.type_initial[i]->clientdata) {
4678 type->clientdata = swig_module.type_initial[i]->clientdata;
4679 #ifdef SWIGRUNTIME_DEBUG
4680 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
4684 type = swig_module.type_initial[i];
4687 /* Insert casting types */
4688 cast = swig_module.cast_initial[i];
4689 while (cast->type) {
4690 /* Don't need to add information already in the list */
4692 #ifdef SWIGRUNTIME_DEBUG
4693 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
4695 if (swig_module.next != &swig_module) {
4696 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
4697 #ifdef SWIGRUNTIME_DEBUG
4698 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
4702 if (type == swig_module.type_initial[i]) {
4703 #ifdef SWIGRUNTIME_DEBUG
4704 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
4709 /* Check for casting already in the list */
4710 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
4711 #ifdef SWIGRUNTIME_DEBUG
4712 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
4714 if (!ocast) ret = 0;
4719 #ifdef SWIGRUNTIME_DEBUG
4720 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
4723 type->cast->prev = cast;
4724 cast->next = type->cast;
4730 /* Set entry in modules->types array equal to the type */
4731 swig_module.types[i] = type;
4733 swig_module.types[i] = 0;
4735 #ifdef SWIGRUNTIME_DEBUG
4736 printf("**** SWIG_InitializeModule: Cast List ******\n");
4737 for (i = 0; i < swig_module.size; ++i) {
4739 swig_cast_info *cast = swig_module.cast_initial[i];
4740 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
4741 while (cast->type) {
4742 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
4746 printf("---- Total casts: %d\n",j);
4748 printf("**** SWIG_InitializeModule: Cast List ******\n");
4752 /* This function will propagate the clientdata field of type to
4753 * any new swig_type_info structures that have been added into the list
4754 * of equivalent types. It is like calling
4755 * SWIG_TypeClientData(type, clientdata) a second time.
4758 SWIG_PropagateClientData(void) {
4760 swig_cast_info *equiv;
4761 static int init_run = 0;
4763 if (init_run) return;
4766 for (i = 0; i < swig_module.size; i++) {
4767 if (swig_module.types[i]->clientdata) {
4768 equiv = swig_module.types[i]->cast;
4770 if (!equiv->converter) {
4771 if (equiv->type && !equiv->type->clientdata)
4772 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
4774 equiv = equiv->next;
4798 SWIG_InitializeModule(0);
4800 /* Install commands */
4801 for (i = 0; swig_commands[i].name; i++) {
4802 newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
4805 /* Install variables */
4806 for (i = 0; swig_variables[i].name; i++) {
4808 sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
4809 if (swig_variables[i].type) {
4810 SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
4812 sv_setiv(sv,(IV) 0);
4814 swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
4817 /* Install constant */
4818 for (i = 0; swig_constants[i].type; i++) {
4820 sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
4821 switch(swig_constants[i].type) {
4823 sv_setiv(sv, (IV) swig_constants[i].lvalue);
4826 sv_setnv(sv, (double) swig_constants[i].dvalue);
4829 sv_setpv(sv, (char *) swig_constants[i].pvalue);
4832 SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
4835 SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
4844 /* Initialize the Device API on load */
4847 SWIG_TypeClientData(SWIGTYPE_p_DirectTCPConnection, (void*) "Amanda::Device::DirectTCPConnection");
4848 SWIG_TypeClientData(SWIGTYPE_p_Device, (void*) "Amanda::Device::Device");
4849 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4850 SV *sv = get_sv((char*) SWIG_prefix "ACCESS_NULL", TRUE | 0x2 | GV_ADDMULTI);
4851 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(ACCESS_NULL)));
4853 } while(0) /*@SWIG@*/;
4854 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4855 SV *sv = get_sv((char*) SWIG_prefix "ACCESS_READ", TRUE | 0x2 | GV_ADDMULTI);
4856 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(ACCESS_READ)));
4858 } while(0) /*@SWIG@*/;
4859 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4860 SV *sv = get_sv((char*) SWIG_prefix "ACCESS_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4861 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(ACCESS_WRITE)));
4863 } while(0) /*@SWIG@*/;
4864 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4865 SV *sv = get_sv((char*) SWIG_prefix "ACCESS_APPEND", TRUE | 0x2 | GV_ADDMULTI);
4866 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(ACCESS_APPEND)));
4868 } while(0) /*@SWIG@*/;
4869 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4870 SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
4871 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_SUCCESS)));
4873 } while(0) /*@SWIG@*/;
4874 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4875 SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_DEVICE_ERROR", TRUE | 0x2 | GV_ADDMULTI);
4876 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_DEVICE_ERROR)));
4878 } while(0) /*@SWIG@*/;
4879 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4880 SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_DEVICE_BUSY", TRUE | 0x2 | GV_ADDMULTI);
4881 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_DEVICE_BUSY)));
4883 } while(0) /*@SWIG@*/;
4884 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4885 SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_MISSING", TRUE | 0x2 | GV_ADDMULTI);
4886 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_MISSING)));
4888 } while(0) /*@SWIG@*/;
4889 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4890 SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_UNLABELED", TRUE | 0x2 | GV_ADDMULTI);
4891 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_UNLABELED)));
4893 } while(0) /*@SWIG@*/;
4894 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4895 SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_ERROR", TRUE | 0x2 | GV_ADDMULTI);
4896 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_ERROR)));
4898 } while(0) /*@SWIG@*/;
4899 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4900 SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_FLAGS_MAX", TRUE | 0x2 | GV_ADDMULTI);
4901 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_FLAGS_MAX)));
4903 } while(0) /*@SWIG@*/;
4904 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4905 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
4906 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BEFORE_START)));
4908 } while(0) /*@SWIG@*/;
4909 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4910 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4911 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BETWEEN_FILE_WRITE)));
4913 } while(0) /*@SWIG@*/;
4914 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4915 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4916 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_INSIDE_FILE_WRITE)));
4918 } while(0) /*@SWIG@*/;
4919 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4920 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4921 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BETWEEN_FILE_READ)));
4923 } while(0) /*@SWIG@*/;
4924 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4925 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4926 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_INSIDE_FILE_READ)));
4928 } while(0) /*@SWIG@*/;
4929 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4930 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_MAX", TRUE | 0x2 | GV_ADDMULTI);
4931 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_MAX)));
4933 } while(0) /*@SWIG@*/;
4934 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4935 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_MASK", TRUE | 0x2 | GV_ADDMULTI);
4936 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_MASK)));
4938 } while(0) /*@SWIG@*/;
4939 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4940 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_SHIFT", TRUE | 0x2 | GV_ADDMULTI);
4941 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_SHIFT)));
4943 } while(0) /*@SWIG@*/;
4944 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4945 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
4946 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BEFORE_START)));
4948 } while(0) /*@SWIG@*/;
4949 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4950 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4951 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE)));
4953 } while(0) /*@SWIG@*/;
4954 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4955 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4956 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE)));
4958 } while(0) /*@SWIG@*/;
4959 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4960 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4961 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BETWEEN_FILE_READ)));
4963 } while(0) /*@SWIG@*/;
4964 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4965 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4966 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_INSIDE_FILE_READ)));
4968 } while(0) /*@SWIG@*/;
4969 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4970 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
4971 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BEFORE_START)));
4973 } while(0) /*@SWIG@*/;
4974 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4975 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4976 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE)));
4978 } while(0) /*@SWIG@*/;
4979 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4980 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
4981 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE)));
4983 } while(0) /*@SWIG@*/;
4984 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4985 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4986 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BETWEEN_FILE_READ)));
4988 } while(0) /*@SWIG@*/;
4989 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4990 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
4991 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_INSIDE_FILE_READ)));
4993 } while(0) /*@SWIG@*/;
4994 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
4995 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_MASK", TRUE | 0x2 | GV_ADDMULTI);
4996 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_MASK)));
4998 } while(0) /*@SWIG@*/;
4999 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5000 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_MASK", TRUE | 0x2 | GV_ADDMULTI);
5001 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_MASK)));
5003 } while(0) /*@SWIG@*/;
5004 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5005 SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_EXCLUSIVE", TRUE | 0x2 | GV_ADDMULTI);
5006 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_EXCLUSIVE)));
5008 } while(0) /*@SWIG@*/;
5009 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5010 SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_SHARED_READ", TRUE | 0x2 | GV_ADDMULTI);
5011 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_SHARED_READ)));
5013 } while(0) /*@SWIG@*/;
5014 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5015 SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_RANDOM_ACCESS", TRUE | 0x2 | GV_ADDMULTI);
5016 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_RANDOM_ACCESS)));
5018 } while(0) /*@SWIG@*/;
5019 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5020 SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_NONE", TRUE | 0x2 | GV_ADDMULTI);
5021 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_NONE)));
5023 } while(0) /*@SWIG@*/;
5024 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5025 SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_DESIRED", TRUE | 0x2 | GV_ADDMULTI);
5026 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_DESIRED)));
5028 } while(0) /*@SWIG@*/;
5029 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5030 SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_REQUIRED", TRUE | 0x2 | GV_ADDMULTI);
5031 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_REQUIRED)));
5033 } while(0) /*@SWIG@*/;
5034 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5035 SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_READ_ONLY", TRUE | 0x2 | GV_ADDMULTI);
5036 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_READ_ONLY)));
5038 } while(0) /*@SWIG@*/;
5039 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5040 SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_WORM", TRUE | 0x2 | GV_ADDMULTI);
5041 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_WORM)));
5043 } while(0) /*@SWIG@*/;
5044 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5045 SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_READ_WRITE", TRUE | 0x2 | GV_ADDMULTI);
5046 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_READ_WRITE)));
5048 } while(0) /*@SWIG@*/;
5049 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5050 SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_WRITE_ONLY", TRUE | 0x2 | GV_ADDMULTI);
5051 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_WRITE_ONLY)));
5053 } while(0) /*@SWIG@*/;
5054 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5055 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SURETY_BAD", TRUE | 0x2 | GV_ADDMULTI);
5056 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SURETY_BAD)));
5058 } while(0) /*@SWIG@*/;
5059 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5060 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SURETY_GOOD", TRUE | 0x2 | GV_ADDMULTI);
5061 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SURETY_GOOD)));
5063 } while(0) /*@SWIG@*/;
5064 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5065 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_DEFAULT", TRUE | 0x2 | GV_ADDMULTI);
5066 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_DEFAULT)));
5068 } while(0) /*@SWIG@*/;
5069 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5070 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_DETECTED", TRUE | 0x2 | GV_ADDMULTI);
5071 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_DETECTED)));
5073 } while(0) /*@SWIG@*/;
5074 /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
5075 SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_USER", TRUE | 0x2 | GV_ADDMULTI);
5076 sv_setsv(sv, SWIG_From_int SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_USER)));
5078 } while(0) /*@SWIG@*/;