git.gag.com Git - debian/amanda/blob - perl/Amanda/Logfile.c

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