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