perl/IDZebra_wrap.c

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.15u-20021003-1203
   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 /***********************************************************************
  12  * common.swg
  13  *
  14  *     This file contains generic SWIG runtime support for pointer
  15  *     type checking as well as a few commonly used macros to control
  16  *     external linkage.
  17  *
  18  * Author : David Beazley (beazley@cs.uchicago.edu)
  19  *
  20  * Copyright (c) 1999-2000, The University of Chicago
  21  *
  22  * This file may be freely redistributed without license or fee provided
  23  * this copyright message remains intact.
  24  ************************************************************************/
  25
  26 #include <string.h>
  27
  28 #if defined(_WIN32) || defined(__WIN32__)
  29 #       if defined(_MSC_VER)
  30 #               if defined(STATIC_LINKED)
  31 #                       define SWIGEXPORT(a) a
  32 #                       define SWIGIMPORT(a) extern a
  33 #               else
  34 #                       define SWIGEXPORT(a) __declspec(dllexport) a
  35 #                       define SWIGIMPORT(a) extern a
  36 #               endif
  37 #       else
  38 #               if defined(__BORLANDC__)
  39 #                       define SWIGEXPORT(a) a _export
  40 #                       define SWIGIMPORT(a) a _export
  41 #               else
  42 #                       define SWIGEXPORT(a) a
  43 #                       define SWIGIMPORT(a) a
  44 #               endif
  45 #       endif
  46 #else
  47 #       define SWIGEXPORT(a) a
  48 #       define SWIGIMPORT(a) a
  49 #endif
  50
  51 #ifdef SWIG_GLOBAL
  52 #define SWIGRUNTIME(a) SWIGEXPORT(a)
  53 #else
  54 #define SWIGRUNTIME(a) static a
  55 #endif
  56
  57 #ifdef __cplusplus
  58 extern "C" {
  59 #endif
  60
  61 typedef void *(*swig_converter_func)(void *);
  62 typedef struct swig_type_info *(*swig_dycast_func)(void **);
  63
  64 typedef struct swig_type_info {
  65   const char             *name;
  66   swig_converter_func     converter;
  67   const char             *str;
  68   void                   *clientdata;
  69   swig_dycast_func        dcast;
  70   struct swig_type_info  *next;
  71   struct swig_type_info  *prev;
  72 } swig_type_info;
  73
  74 #ifdef SWIG_NOINCLUDE
  75
  76 SWIGIMPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
  77 SWIGIMPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
  78 SWIGIMPORT(void *)           SWIG_TypeCast(swig_type_info *, void *);
  79 SWIGIMPORT(swig_type_info *) SWIG_TypeDynamicCast(swig_type_info *, void **);
  80 SWIGIMPORT(swig_type_info *) SWIG_TypeQuery(const char *);
  81 SWIGIMPORT(void)             SWIG_TypeClientData(swig_type_info *, void *);
  82
  83 #else
  84
  85 static swig_type_info *swig_type_list = 0;
  86
  87 /* Register a type mapping with the type-checking */
  88 SWIGRUNTIME(swig_type_info *)
  89 SWIG_TypeRegister(swig_type_info *ti)
  90 {
  91   swig_type_info *tc, *head, *ret, *next;
  92   /* Check to see if this type has already been registered */
  93   tc = swig_type_list;
  94   while (tc) {
  95     if (strcmp(tc->name, ti->name) == 0) {
  96       /* Already exists in the table.  Just add additional types to the list */
  97       if (tc->clientdata) ti->clientdata = tc->clientdata;
  98       head = tc;
  99       next = tc->next;
 100       goto l1;
 101     }
 102     tc = tc->prev;
 103   }
 104   head = ti;
 105   next = 0;
 106
 107   /* Place in list */
 108   ti->prev = swig_type_list;
 109   swig_type_list = ti;
 110
 111   /* Build linked lists */
 112  l1:
 113   ret = head;
 114   tc = ti + 1;
 115   /* Patch up the rest of the links */
 116   while (tc->name) {
 117     head->next = tc;
 118     tc->prev = head;
 119     head = tc;
 120     tc++;
 121   }
 122   head->next = next;
 123   return ret;
 124 }
 125
 126 /* Check the typename */
 127 SWIGRUNTIME(swig_type_info *)
 128 SWIG_TypeCheck(char *c, swig_type_info *ty)
 129 {
 130   swig_type_info *s;
 131   if (!ty) return 0;        /* Void pointer */
 132   s = ty->next;             /* First element always just a name */
 133   do {
 134     if (strcmp(s->name,c) == 0) {
 135       if (s == ty->next) return s;
 136       /* Move s to the top of the linked list */
 137       s->prev->next = s->next;
 138       if (s->next) {
 139         s->next->prev = s->prev;
 140       }
 141       /* Insert s as second element in the list */
 142       s->next = ty->next;
 143       if (ty->next) ty->next->prev = s;
 144       ty->next = s;
 145       return s;
 146     }
 147     s = s->next;
 148   } while (s && (s != ty->next));
 149   return 0;
 150 }
 151
 152 /* Cast a pointer up an inheritance hierarchy */
 153 SWIGRUNTIME(void *)
 154 SWIG_TypeCast(swig_type_info *ty, void *ptr)
 155 {
 156   if ((!ty) || (!ty->converter)) return ptr;
 157   return (*ty->converter)(ptr);
 158 }
 159
 160 /* Dynamic pointer casting. Down an inheritance hierarchy */
 161 SWIGRUNTIME(swig_type_info *)
 162 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr)
 163 {
 164   swig_type_info *lastty = ty;
 165   if (!ty || !ty->dcast) return ty;
 166   while (ty && (ty->dcast)) {
 167      ty = (*ty->dcast)(ptr);
 168      if (ty) lastty = ty;
 169   }
 170   return lastty;
 171 }
 172
 173 /* Search for a swig_type_info structure */
 174 SWIGRUNTIME(swig_type_info *)
 175 SWIG_TypeQuery(const char *name) {
 176   swig_type_info *ty = swig_type_list;
 177   while (ty) {
 178     if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
 179     if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
 180     ty = ty->prev;
 181   }
 182   return 0;
 183 }
 184
 185 /* Set the clientdata field for a type */
 186 SWIGRUNTIME(void)
 187 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 188   swig_type_info *tc, *equiv;
 189   if (ti->clientdata) return;
 190   ti->clientdata = clientdata;
 191   equiv = ti->next;
 192   while (equiv) {
 193     if (!equiv->converter) {
 194       tc = swig_type_list;
 195       while (tc) {
 196         if ((strcmp(tc->name, equiv->name) == 0))
 197           SWIG_TypeClientData(tc,clientdata);
 198         tc = tc->prev;
 199       }
 200     }
 201     equiv = equiv->next;
 202   }
 203 }
 204 #endif
 205
 206 #ifdef __cplusplus
 207 }
 208
 209 #endif
 210
 211 /* -----------------------------------------------------------------------------
 212  * perl5.swg
 213  *
 214  * Perl5 runtime library
 215  * $Header: /home/cvsroot/idis/perl/Attic/IDZebra_wrap.c,v 1.12 2003-03-04 23:32:55 pop Exp $
 216  * ----------------------------------------------------------------------------- */
 217
 218 #define SWIGPERL
 219 #define SWIGPERL5
 220 #ifdef __cplusplus
 221 /* Needed on some windows machines---since MS plays funny
 222    games with the header files under C++ */
 223 #include <math.h>
 224 #include <stdlib.h>
 225 extern "C" {
 226 #endif
 227 #include "EXTERN.h"
 228 #include "perl.h"
 229 #include "XSUB.h"
 230
 231 /* Get rid of free and malloc defined by perl */
 232 #undef free
 233 #undef malloc
 234
 235 #ifndef pTHX_
 236 #define pTHX_
 237 #endif
 238
 239 #include <string.h>
 240 #ifdef __cplusplus
 241 }
 242 #endif
 243
 244 /* Macro to call an XS function */
 245
 246 #ifdef PERL_OBJECT
 247 #define SWIG_CALLXS(_name) _name(cv,pPerl)
 248 #else
 249 #ifndef MULTIPLICITY
 250 #define SWIG_CALLXS(_name) _name(cv)
 251 #else
 252 #define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
 253 #endif
 254 #endif
 255
 256 /* Macros for low-level exception handling */
 257 #define SWIG_fail      goto fail
 258 #define SWIG_croak(x)  while ((_swigerr = (const char *) x)) goto fail
 259 #define SWIG_MAX_ERRMSG 256
 260
 261 /* Note: SwigMagicFuncHack is a typedef used to get the C++
 262    compiler to just shut up already */
 263
 264 #ifdef PERL_OBJECT
 265 #define MAGIC_PPERL  CPerlObj *pPerl = (CPerlObj *) this;
 266 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
 267
 268 #ifdef __cplusplus
 269 extern "C" {
 270 #endif
 271 typedef int (CPerlObj::*SwigMagicFuncHack)(SV *, MAGIC *);
 272 #ifdef __cplusplus
 273 }
 274 #endif
 275
 276 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
 277 #define SWIGCLASS_STATIC
 278 #else
 279 #define MAGIC_PPERL
 280 #define SWIGCLASS_STATIC static
 281 #ifndef MULTIPLICITY
 282 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
 283 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
 284
 285 #ifdef __cplusplus
 286 extern "C" {
 287 #endif
 288 typedef int (*SwigMagicFuncHack)(SV *, MAGIC *);
 289 #ifdef __cplusplus
 290 }
 291 #endif
 292
 293
 294 #else
 295 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
 296 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
 297 #ifdef __cplusplus
 298 extern "C" {
 299 #endif
 300 typedef int (*SwigMagicFuncHack)(struct interpreter *, SV *, MAGIC *);
 301 #ifdef __cplusplus
 302 }
 303 #endif
 304
 305 #endif
 306 #endif
 307
 308 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
 309 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
 310 #endif
 311
 312 /* Modifications for newer Perl 5.005 releases */
 313
 314 #if !defined(PERL_REVISION) || ((PERL_REVISION >= 5) && ((PERL_VERSION < 5) || ((PERL_VERSION == 5) && (PERL_SUBVERSION < 50))))
 315 #ifndef PL_sv_yes
 316 #define PL_sv_yes sv_yes
 317 #endif
 318 #ifndef PL_sv_undef
 319 #define PL_sv_undef sv_undef
 320 #endif
 321 #ifndef PL_na
 322 #define PL_na na
 323 #endif
 324 #endif
 325
 326 #include <stdlib.h>
 327
 328 #ifdef __cplusplus
 329 extern "C" {
 330 #endif
 331
 332 #ifdef SWIG_NOINCLUDE
 333
 334 #ifndef PERL_OBJECT
 335 extern int SWIG_ConvertPtr(SV *, void **, swig_type_info *, int flags);
 336 extern void SWIG_MakePtr(SV *, void *, swig_type_info *, int flags);
 337 #else
 338 extern int _SWIG_ConvertPtr(CPerlObj *, SV *, void **, swig_type_info *,int flags);
 339 extern void _SWIG_MakePtr(CPerlObj *, SV *, void *, swig_type_info *, int flags);
 340 #define SWIG_ConvertPtr(a,b,c,d) _SWIG_ConvertPtr(pPerl,a,b,c,d)
 341 #define SWIG_MakePtr(a,b,c,d) _SWIG_MakePtr(pPerl,a,b,c,d)
 342 #endif
 343
 344 #else
 345
 346 /* Function for getting a pointer value */
 347
 348 #ifndef PERL_OBJECT
 349 SWIGRUNTIME(int)
 350 SWIG_ConvertPtr(SV *sv, void **ptr, swig_type_info *_t, int flags)
 351 #else
 352 #define SWIG_ConvertPtr(a,b,c,d) _SWIG_ConvertPtr(pPerl,a,b,c,d)
 353 SWIGRUNTIME(int)
 354 _SWIG_ConvertPtr(CPerlObj *pPerl, SV *sv, void **ptr, swig_type_info *_t, int flags)
 355 #endif
 356 {
 357   char *_c;
 358   swig_type_info *tc;
 359   IV   tmp;
 360
 361   /* If magical, apply more magic */
 362   if (SvGMAGICAL(sv))
 363     mg_get(sv);
 364
 365   /* Check to see if this is an object */
 366   if (sv_isobject(sv)) {
 367     SV *tsv = (SV*) SvRV(sv);
 368     if ((SvTYPE(tsv) == SVt_PVHV)) {
 369       MAGIC *mg;
 370       if (SvMAGICAL(tsv)) {
 371         mg = mg_find(tsv,'P');
 372         if (mg) {
 373           SV *rsv = mg->mg_obj;
 374           if (sv_isobject(rsv)) {
 375             tmp = SvIV((SV*)SvRV(rsv));
 376           }
 377         }
 378       } else {
 379         return -1;
 380       }
 381     } else {
 382       tmp = SvIV((SV*)SvRV(sv));
 383     }
 384     if (!_t) {
 385       *(ptr) = (void *) tmp;
 386       return 0;
 387     }
 388   } else if (! SvOK(sv)) {            /* Check for undef */
 389     *(ptr) = (void *) 0;
 390     return 0;
 391   } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
 392     *(ptr) = (void *) 0;
 393     if (!SvROK(sv))
 394       return 0;
 395     else
 396       return -1;
 397   } else {                            /* Don't know what it is */
 398       *(ptr) = (void *) 0;
 399       return -1;
 400   }
 401   if (_t) {
 402     /* Now see if the types match */
 403     _c = HvNAME(SvSTASH(SvRV(sv)));
 404     tc = SWIG_TypeCheck(_c,_t);
 405     if (!tc) {
 406       *ptr = (void *) tmp;
 407       return -1;
 408     }
 409     *ptr = SWIG_TypeCast(tc,(void *)tmp);
 410     return 0;
 411   }
 412   *ptr = (void *) tmp;
 413   return 0;
 414 }
 415 #ifndef PERL_OBJECT
 416 SWIGRUNTIME(void)
 417 SWIG_MakePtr(SV *sv, void *ptr, swig_type_info *t,int flags)
 418 #else
 419 #define SWIG_MakePtr(a,b,c,d) _SWIG_MakePtr(pPerl,a,b,c,d)
 420 SWIGRUNTIME(void)
 421 _SWIG_MakePtr(CPerlObj *pPerl, SV *sv, void *ptr, swig_type_info *t, int flags)
 422 #endif
 423 {
 424   sv_setref_pv(sv, (char *) t->name, ptr);
 425 }
 426
 427 #endif
 428
 429 typedef XS(SwigPerlWrapper);
 430 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
 431
 432 /* Structure for command table */
 433 typedef struct {
 434   const char         *name;
 435   SwigPerlWrapperPtr  wrapper;
 436 } swig_command_info;
 437
 438 /* Information for constant table */
 439
 440 #define SWIG_INT     1
 441 #define SWIG_FLOAT   2
 442 #define SWIG_STRING  3
 443 #define SWIG_POINTER 4
 444 #define SWIG_BINARY  5
 445
 446 /* Constant information structure */
 447 typedef struct swig_constant_info {
 448     int              type;
 449     const char      *name;
 450     long             lvalue;
 451     double           dvalue;
 452     void            *pvalue;
 453     swig_type_info **ptype;
 454 } swig_constant_info;
 455
 456 #ifdef __cplusplus
 457 }
 458 #endif
 459
 460 /* Structure for variable table */
 461 typedef struct {
 462   const char   *name;
 463   SwigMagicFunc   set;
 464   SwigMagicFunc   get;
 465   swig_type_info  **type;
 466 } swig_variable_info;
 467
 468 /* Magic variable code */
 469 #ifndef PERL_OBJECT
 470 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
 471   #ifndef MULTIPLICITY
 472        static void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int \
 473 (*get)(SV *,MAGIC *)) {
 474   #else
 475        static void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*,\
 476  SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *)) {
 477   #endif
 478 #else
 479 #define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
 480 static void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) {
 481 #endif
 482   MAGIC *mg;
 483   sv_magic(sv,sv,'U',(char *) name,strlen(name));
 484   mg = mg_find(sv,'U');
 485   mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
 486   mg->mg_virtual->svt_get = (SwigMagicFuncHack) get;
 487   mg->mg_virtual->svt_set = (SwigMagicFuncHack) set;
 488   mg->mg_virtual->svt_len = 0;
 489   mg->mg_virtual->svt_clear = 0;
 490   mg->mg_virtual->svt_free = 0;
 491 }
 492
 493
 494
 495
 496
 497
 498
 499 /* -------- TYPES TABLE (BEGIN) -------- */
 500
 501 #define  SWIGTYPE_p_ZebraService swig_types[0]
 502 #define  SWIGTYPE_p_cql_transform_t swig_types[1]
 503 #define  SWIGTYPE_p_data1_esetname swig_types[2]
 504 #define  SWIGTYPE_p_data1_maptab swig_types[3]
 505 #define  SWIGTYPE_p_ODR swig_types[4]
 506 #define  SWIGTYPE_p_f_p_void__int swig_types[5]
 507 #define  SWIGTYPE_p_p_char swig_types[6]
 508 #define  SWIGTYPE_p_data1_absyn swig_types[7]
 509 #define  SWIGTYPE_p_ZebraHandle swig_types[8]
 510 #define  SWIGTYPE_p_void swig_types[9]
 511 #define  SWIGTYPE_p_data1_attset swig_types[10]
 512 #define  SWIGTYPE_p_size_t swig_types[11]
 513 #define  SWIGTYPE_p_WRBUF swig_types[12]
 514 #define  SWIGTYPE_p_f_data1_handle_p_void_p_data1_absyn__void swig_types[13]
 515 #define  SWIGTYPE_p_Z_Espec1 swig_types[14]
 516 #define  SWIGTYPE_p_off_t swig_types[15]
 517 #define  SWIGTYPE_p_Odr_oid swig_types[16]
 518 #define  SWIGTYPE_p_data1_varset swig_types[17]
 519 #define  SWIGTYPE_p_RetrievalRecordBuf swig_types[18]
 520 #define  SWIGTYPE_p_perl_context swig_types[19]
 521 #define  SWIGTYPE_p_data1_node swig_types[20]
 522 #define  SWIGTYPE_p_ScanObj swig_types[21]
 523 #define  SWIGTYPE_p_RetrievalObj swig_types[22]
 524 #define  SWIGTYPE_p_data1_tagset swig_types[23]
 525 #define  SWIGTYPE_p_data1_tag swig_types[24]
 526 #define  SWIGTYPE_p_ZebraRetrievalRecord swig_types[25]
 527 #define  SWIGTYPE_p_RetrievalRecord swig_types[26]
 528 #define  SWIGTYPE_p_NMEM swig_types[27]
 529 #define  SWIGTYPE_p_Z_ExplainRecord swig_types[28]
 530 #define  SWIGTYPE_p_data1_marctab swig_types[29]
 531 #define  SWIGTYPE_p_ZebraTransactionStatus swig_types[30]
 532 #define  SWIGTYPE_p_Z_BriefBib swig_types[31]
 533 #define  SWIGTYPE_p_scanEntry swig_types[32]
 534 #define  SWIGTYPE_p_f_p_void_p_char_size_t__int swig_types[33]
 535 #define  SWIGTYPE_p_FILE swig_types[34]
 536 #define  SWIGTYPE_p_data1_element swig_types[35]
 537 #define  SWIGTYPE_p_recordGroup swig_types[36]
 538 #define  SWIGTYPE_p_int swig_types[37]
 539 #define  SWIGTYPE_p_data1_handle swig_types[38]
 540 #define  SWIGTYPE_p_p_int swig_types[39]
 541 #define  SWIGTYPE_p_data1_absyn_cache swig_types[40]
 542 #define  SWIGTYPE_p_data1_attset_cache swig_types[41]
 543 #define  SWIGTYPE_p_Z_GenericRecord swig_types[42]
 544 #define  SWIGTYPE_p_data1_vartype swig_types[43]
 545 static swig_type_info *swig_types[45];
 546
 547 /* -------- TYPES TABLE (END) -------- */
 548
 549 #define SWIG_init    boot_IDZebra
 550
 551 #define SWIG_name   "IDZebrac::boot_IDZebra"
 552 #define SWIG_prefix "IDZebrac::"
 553
 554 #ifdef __cplusplus
 555 extern "C"
 556 #endif
 557 #ifndef PERL_OBJECT
 558 #ifndef MULTIPLICITY
 559 SWIGEXPORT(void) SWIG_init (CV* cv);
 560 #else
 561 SWIGEXPORT(void) SWIG_init (pTHXo_ CV* cv);
 562 #endif
 563 #else
 564 SWIGEXPORT(void) SWIG_init (CV *cv, CPerlObj *);
 565 #endif
 566
 567
 568 #include "zebraapi.h"
 569 #include "zebra_perl.h"
 570 #include "data1.h"
 571 #include "yaz/odr.h"
 572 #include "yaz/cql.h"
 573
 574 #ifdef PERL_OBJECT
 575 #define MAGIC_CLASS _wrap_IDZebra_var::
 576 class _wrap_IDZebra_var : public CPerlObj {
 577 public:
 578 #else
 579 #define MAGIC_CLASS
 580 #endif
 581 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *sv, MAGIC *mg) {
 582     MAGIC_PPERL
 583     sv = sv; mg = mg;
 584     croak("Value is read-only.");
 585     return 0;
 586 }
 587
 588
 589 #ifdef PERL_OBJECT
 590 };
 591 #endif
 592
 593 #ifdef __cplusplus
 594 extern "C" {
 595 #endif
 596 XS(_wrap_recordGroup_groupName_set) {
 597     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 598     const char *_swigerr = _swigmsg;
 599     {
 600         recordGroup *arg1 ;
 601         char *arg2 ;
 602         int argvi = 0;
 603         dXSARGS;
 604
 605         if ((items < 2) || (items > 2)) {
 606             SWIG_croak("Usage: recordGroup_groupName_set(self,groupName);");
 607         }
 608         {
 609             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 610                 SWIG_croak("Type error in argument 1 of recordGroup_groupName_set. Expected _p_recordGroup");
 611             }
 612         }
 613         if (!SvOK((SV*) ST(1))) arg2 = 0;
 614         else arg2 = (char *) SvPV(ST(1), PL_na);
 615         {
 616             if (arg1->groupName) free((char*)arg1->groupName);
 617             arg1->groupName = (char *) malloc(strlen(arg2)+1);
 618             strcpy((char*)arg1->groupName,arg2);
 619         }
 620
 621         XSRETURN(argvi);
 622         fail:
 623         (void) _swigerr;
 624     }
 625     croak(_swigerr);
 626 }
 627
 628
 629 XS(_wrap_recordGroup_groupName_get) {
 630     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 631     const char *_swigerr = _swigmsg;
 632     {
 633         recordGroup *arg1 ;
 634         char *result;
 635         int argvi = 0;
 636         dXSARGS;
 637
 638         if ((items < 1) || (items > 1)) {
 639             SWIG_croak("Usage: recordGroup_groupName_get(self);");
 640         }
 641         {
 642             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 643                 SWIG_croak("Type error in argument 1 of recordGroup_groupName_get. Expected _p_recordGroup");
 644             }
 645         }
 646         result = (char *) ((arg1)->groupName);
 647
 648         ST(argvi) = sv_newmortal();
 649         if (result) {
 650             sv_setpv((SV*)ST(argvi++), (char *) result);
 651         }else {
 652             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
 653         }
 654         XSRETURN(argvi);
 655         fail:
 656         (void) _swigerr;
 657     }
 658     croak(_swigerr);
 659 }
 660
 661
 662 XS(_wrap_recordGroup_databaseName_set) {
 663     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 664     const char *_swigerr = _swigmsg;
 665     {
 666         recordGroup *arg1 ;
 667         char *arg2 ;
 668         int argvi = 0;
 669         dXSARGS;
 670
 671         if ((items < 2) || (items > 2)) {
 672             SWIG_croak("Usage: recordGroup_databaseName_set(self,databaseName);");
 673         }
 674         {
 675             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 676                 SWIG_croak("Type error in argument 1 of recordGroup_databaseName_set. Expected _p_recordGroup");
 677             }
 678         }
 679         if (!SvOK((SV*) ST(1))) arg2 = 0;
 680         else arg2 = (char *) SvPV(ST(1), PL_na);
 681         {
 682             if (arg1->databaseName) free((char*)arg1->databaseName);
 683             arg1->databaseName = (char *) malloc(strlen(arg2)+1);
 684             strcpy((char*)arg1->databaseName,arg2);
 685         }
 686
 687         XSRETURN(argvi);
 688         fail:
 689         (void) _swigerr;
 690     }
 691     croak(_swigerr);
 692 }
 693
 694
 695 XS(_wrap_recordGroup_databaseName_get) {
 696     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 697     const char *_swigerr = _swigmsg;
 698     {
 699         recordGroup *arg1 ;
 700         char *result;
 701         int argvi = 0;
 702         dXSARGS;
 703
 704         if ((items < 1) || (items > 1)) {
 705             SWIG_croak("Usage: recordGroup_databaseName_get(self);");
 706         }
 707         {
 708             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 709                 SWIG_croak("Type error in argument 1 of recordGroup_databaseName_get. Expected _p_recordGroup");
 710             }
 711         }
 712         result = (char *) ((arg1)->databaseName);
 713
 714         ST(argvi) = sv_newmortal();
 715         if (result) {
 716             sv_setpv((SV*)ST(argvi++), (char *) result);
 717         }else {
 718             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
 719         }
 720         XSRETURN(argvi);
 721         fail:
 722         (void) _swigerr;
 723     }
 724     croak(_swigerr);
 725 }
 726
 727
 728 XS(_wrap_recordGroup_path_set) {
 729     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 730     const char *_swigerr = _swigmsg;
 731     {
 732         recordGroup *arg1 ;
 733         char *arg2 ;
 734         int argvi = 0;
 735         dXSARGS;
 736
 737         if ((items < 2) || (items > 2)) {
 738             SWIG_croak("Usage: recordGroup_path_set(self,path);");
 739         }
 740         {
 741             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 742                 SWIG_croak("Type error in argument 1 of recordGroup_path_set. Expected _p_recordGroup");
 743             }
 744         }
 745         if (!SvOK((SV*) ST(1))) arg2 = 0;
 746         else arg2 = (char *) SvPV(ST(1), PL_na);
 747         {
 748             if (arg1->path) free((char*)arg1->path);
 749             arg1->path = (char *) malloc(strlen(arg2)+1);
 750             strcpy((char*)arg1->path,arg2);
 751         }
 752
 753         XSRETURN(argvi);
 754         fail:
 755         (void) _swigerr;
 756     }
 757     croak(_swigerr);
 758 }
 759
 760
 761 XS(_wrap_recordGroup_path_get) {
 762     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 763     const char *_swigerr = _swigmsg;
 764     {
 765         recordGroup *arg1 ;
 766         char *result;
 767         int argvi = 0;
 768         dXSARGS;
 769
 770         if ((items < 1) || (items > 1)) {
 771             SWIG_croak("Usage: recordGroup_path_get(self);");
 772         }
 773         {
 774             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 775                 SWIG_croak("Type error in argument 1 of recordGroup_path_get. Expected _p_recordGroup");
 776             }
 777         }
 778         result = (char *) ((arg1)->path);
 779
 780         ST(argvi) = sv_newmortal();
 781         if (result) {
 782             sv_setpv((SV*)ST(argvi++), (char *) result);
 783         }else {
 784             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
 785         }
 786         XSRETURN(argvi);
 787         fail:
 788         (void) _swigerr;
 789     }
 790     croak(_swigerr);
 791 }
 792
 793
 794 XS(_wrap_recordGroup_recordId_set) {
 795     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 796     const char *_swigerr = _swigmsg;
 797     {
 798         recordGroup *arg1 ;
 799         char *arg2 ;
 800         int argvi = 0;
 801         dXSARGS;
 802
 803         if ((items < 2) || (items > 2)) {
 804             SWIG_croak("Usage: recordGroup_recordId_set(self,recordId);");
 805         }
 806         {
 807             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 808                 SWIG_croak("Type error in argument 1 of recordGroup_recordId_set. Expected _p_recordGroup");
 809             }
 810         }
 811         if (!SvOK((SV*) ST(1))) arg2 = 0;
 812         else arg2 = (char *) SvPV(ST(1), PL_na);
 813         {
 814             if (arg1->recordId) free((char*)arg1->recordId);
 815             arg1->recordId = (char *) malloc(strlen(arg2)+1);
 816             strcpy((char*)arg1->recordId,arg2);
 817         }
 818
 819         XSRETURN(argvi);
 820         fail:
 821         (void) _swigerr;
 822     }
 823     croak(_swigerr);
 824 }
 825
 826
 827 XS(_wrap_recordGroup_recordId_get) {
 828     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 829     const char *_swigerr = _swigmsg;
 830     {
 831         recordGroup *arg1 ;
 832         char *result;
 833         int argvi = 0;
 834         dXSARGS;
 835
 836         if ((items < 1) || (items > 1)) {
 837             SWIG_croak("Usage: recordGroup_recordId_get(self);");
 838         }
 839         {
 840             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 841                 SWIG_croak("Type error in argument 1 of recordGroup_recordId_get. Expected _p_recordGroup");
 842             }
 843         }
 844         result = (char *) ((arg1)->recordId);
 845
 846         ST(argvi) = sv_newmortal();
 847         if (result) {
 848             sv_setpv((SV*)ST(argvi++), (char *) result);
 849         }else {
 850             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
 851         }
 852         XSRETURN(argvi);
 853         fail:
 854         (void) _swigerr;
 855     }
 856     croak(_swigerr);
 857 }
 858
 859
 860 XS(_wrap_recordGroup_recordType_set) {
 861     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 862     const char *_swigerr = _swigmsg;
 863     {
 864         recordGroup *arg1 ;
 865         char *arg2 ;
 866         int argvi = 0;
 867         dXSARGS;
 868
 869         if ((items < 2) || (items > 2)) {
 870             SWIG_croak("Usage: recordGroup_recordType_set(self,recordType);");
 871         }
 872         {
 873             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 874                 SWIG_croak("Type error in argument 1 of recordGroup_recordType_set. Expected _p_recordGroup");
 875             }
 876         }
 877         if (!SvOK((SV*) ST(1))) arg2 = 0;
 878         else arg2 = (char *) SvPV(ST(1), PL_na);
 879         {
 880             if (arg1->recordType) free((char*)arg1->recordType);
 881             arg1->recordType = (char *) malloc(strlen(arg2)+1);
 882             strcpy((char*)arg1->recordType,arg2);
 883         }
 884
 885         XSRETURN(argvi);
 886         fail:
 887         (void) _swigerr;
 888     }
 889     croak(_swigerr);
 890 }
 891
 892
 893 XS(_wrap_recordGroup_recordType_get) {
 894     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 895     const char *_swigerr = _swigmsg;
 896     {
 897         recordGroup *arg1 ;
 898         char *result;
 899         int argvi = 0;
 900         dXSARGS;
 901
 902         if ((items < 1) || (items > 1)) {
 903             SWIG_croak("Usage: recordGroup_recordType_get(self);");
 904         }
 905         {
 906             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 907                 SWIG_croak("Type error in argument 1 of recordGroup_recordType_get. Expected _p_recordGroup");
 908             }
 909         }
 910         result = (char *) ((arg1)->recordType);
 911
 912         ST(argvi) = sv_newmortal();
 913         if (result) {
 914             sv_setpv((SV*)ST(argvi++), (char *) result);
 915         }else {
 916             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
 917         }
 918         XSRETURN(argvi);
 919         fail:
 920         (void) _swigerr;
 921     }
 922     croak(_swigerr);
 923 }
 924
 925
 926 XS(_wrap_recordGroup_flagStoreData_set) {
 927     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 928     const char *_swigerr = _swigmsg;
 929     {
 930         recordGroup *arg1 ;
 931         int arg2 ;
 932         int argvi = 0;
 933         dXSARGS;
 934
 935         if ((items < 2) || (items > 2)) {
 936             SWIG_croak("Usage: recordGroup_flagStoreData_set(self,flagStoreData);");
 937         }
 938         {
 939             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 940                 SWIG_croak("Type error in argument 1 of recordGroup_flagStoreData_set. Expected _p_recordGroup");
 941             }
 942         }
 943         arg2 = (int) SvIV(ST(1));
 944         if (arg1) (arg1)->flagStoreData = arg2;
 945
 946
 947         XSRETURN(argvi);
 948         fail:
 949         (void) _swigerr;
 950     }
 951     croak(_swigerr);
 952 }
 953
 954
 955 XS(_wrap_recordGroup_flagStoreData_get) {
 956     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 957     const char *_swigerr = _swigmsg;
 958     {
 959         recordGroup *arg1 ;
 960         int result;
 961         int argvi = 0;
 962         dXSARGS;
 963
 964         if ((items < 1) || (items > 1)) {
 965             SWIG_croak("Usage: recordGroup_flagStoreData_get(self);");
 966         }
 967         {
 968             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 969                 SWIG_croak("Type error in argument 1 of recordGroup_flagStoreData_get. Expected _p_recordGroup");
 970             }
 971         }
 972         result = (int) ((arg1)->flagStoreData);
 973
 974         ST(argvi) = sv_newmortal();
 975         sv_setiv(ST(argvi++), (IV) result);
 976         XSRETURN(argvi);
 977         fail:
 978         (void) _swigerr;
 979     }
 980     croak(_swigerr);
 981 }
 982
 983
 984 XS(_wrap_recordGroup_flagStoreKeys_set) {
 985     char _swigmsg[SWIG_MAX_ERRMSG] = "";
 986     const char *_swigerr = _swigmsg;
 987     {
 988         recordGroup *arg1 ;
 989         int arg2 ;
 990         int argvi = 0;
 991         dXSARGS;
 992
 993         if ((items < 2) || (items > 2)) {
 994             SWIG_croak("Usage: recordGroup_flagStoreKeys_set(self,flagStoreKeys);");
 995         }
 996         {
 997             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
 998                 SWIG_croak("Type error in argument 1 of recordGroup_flagStoreKeys_set. Expected _p_recordGroup");
 999             }
1000         }
1001         arg2 = (int) SvIV(ST(1));
1002         if (arg1) (arg1)->flagStoreKeys = arg2;
1003
1004
1005         XSRETURN(argvi);
1006         fail:
1007         (void) _swigerr;
1008     }
1009     croak(_swigerr);
1010 }
1011
1012
1013 XS(_wrap_recordGroup_flagStoreKeys_get) {
1014     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1015     const char *_swigerr = _swigmsg;
1016     {
1017         recordGroup *arg1 ;
1018         int result;
1019         int argvi = 0;
1020         dXSARGS;
1021
1022         if ((items < 1) || (items > 1)) {
1023             SWIG_croak("Usage: recordGroup_flagStoreKeys_get(self);");
1024         }
1025         {
1026             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1027                 SWIG_croak("Type error in argument 1 of recordGroup_flagStoreKeys_get. Expected _p_recordGroup");
1028             }
1029         }
1030         result = (int) ((arg1)->flagStoreKeys);
1031
1032         ST(argvi) = sv_newmortal();
1033         sv_setiv(ST(argvi++), (IV) result);
1034         XSRETURN(argvi);
1035         fail:
1036         (void) _swigerr;
1037     }
1038     croak(_swigerr);
1039 }
1040
1041
1042 XS(_wrap_recordGroup_flagRw_set) {
1043     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1044     const char *_swigerr = _swigmsg;
1045     {
1046         recordGroup *arg1 ;
1047         int arg2 ;
1048         int argvi = 0;
1049         dXSARGS;
1050
1051         if ((items < 2) || (items > 2)) {
1052             SWIG_croak("Usage: recordGroup_flagRw_set(self,flagRw);");
1053         }
1054         {
1055             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1056                 SWIG_croak("Type error in argument 1 of recordGroup_flagRw_set. Expected _p_recordGroup");
1057             }
1058         }
1059         arg2 = (int) SvIV(ST(1));
1060         if (arg1) (arg1)->flagRw = arg2;
1061
1062
1063         XSRETURN(argvi);
1064         fail:
1065         (void) _swigerr;
1066     }
1067     croak(_swigerr);
1068 }
1069
1070
1071 XS(_wrap_recordGroup_flagRw_get) {
1072     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1073     const char *_swigerr = _swigmsg;
1074     {
1075         recordGroup *arg1 ;
1076         int result;
1077         int argvi = 0;
1078         dXSARGS;
1079
1080         if ((items < 1) || (items > 1)) {
1081             SWIG_croak("Usage: recordGroup_flagRw_get(self);");
1082         }
1083         {
1084             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1085                 SWIG_croak("Type error in argument 1 of recordGroup_flagRw_get. Expected _p_recordGroup");
1086             }
1087         }
1088         result = (int) ((arg1)->flagRw);
1089
1090         ST(argvi) = sv_newmortal();
1091         sv_setiv(ST(argvi++), (IV) result);
1092         XSRETURN(argvi);
1093         fail:
1094         (void) _swigerr;
1095     }
1096     croak(_swigerr);
1097 }
1098
1099
1100 XS(_wrap_recordGroup_fileVerboseLimit_set) {
1101     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1102     const char *_swigerr = _swigmsg;
1103     {
1104         recordGroup *arg1 ;
1105         int arg2 ;
1106         int argvi = 0;
1107         dXSARGS;
1108
1109         if ((items < 2) || (items > 2)) {
1110             SWIG_croak("Usage: recordGroup_fileVerboseLimit_set(self,fileVerboseLimit);");
1111         }
1112         {
1113             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1114                 SWIG_croak("Type error in argument 1 of recordGroup_fileVerboseLimit_set. Expected _p_recordGroup");
1115             }
1116         }
1117         arg2 = (int) SvIV(ST(1));
1118         if (arg1) (arg1)->fileVerboseLimit = arg2;
1119
1120
1121         XSRETURN(argvi);
1122         fail:
1123         (void) _swigerr;
1124     }
1125     croak(_swigerr);
1126 }
1127
1128
1129 XS(_wrap_recordGroup_fileVerboseLimit_get) {
1130     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1131     const char *_swigerr = _swigmsg;
1132     {
1133         recordGroup *arg1 ;
1134         int result;
1135         int argvi = 0;
1136         dXSARGS;
1137
1138         if ((items < 1) || (items > 1)) {
1139             SWIG_croak("Usage: recordGroup_fileVerboseLimit_get(self);");
1140         }
1141         {
1142             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1143                 SWIG_croak("Type error in argument 1 of recordGroup_fileVerboseLimit_get. Expected _p_recordGroup");
1144             }
1145         }
1146         result = (int) ((arg1)->fileVerboseLimit);
1147
1148         ST(argvi) = sv_newmortal();
1149         sv_setiv(ST(argvi++), (IV) result);
1150         XSRETURN(argvi);
1151         fail:
1152         (void) _swigerr;
1153     }
1154     croak(_swigerr);
1155 }
1156
1157
1158 XS(_wrap_recordGroup_databaseNamePath_set) {
1159     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1160     const char *_swigerr = _swigmsg;
1161     {
1162         recordGroup *arg1 ;
1163         int arg2 ;
1164         int argvi = 0;
1165         dXSARGS;
1166
1167         if ((items < 2) || (items > 2)) {
1168             SWIG_croak("Usage: recordGroup_databaseNamePath_set(self,databaseNamePath);");
1169         }
1170         {
1171             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1172                 SWIG_croak("Type error in argument 1 of recordGroup_databaseNamePath_set. Expected _p_recordGroup");
1173             }
1174         }
1175         arg2 = (int) SvIV(ST(1));
1176         if (arg1) (arg1)->databaseNamePath = arg2;
1177
1178
1179         XSRETURN(argvi);
1180         fail:
1181         (void) _swigerr;
1182     }
1183     croak(_swigerr);
1184 }
1185
1186
1187 XS(_wrap_recordGroup_databaseNamePath_get) {
1188     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1189     const char *_swigerr = _swigmsg;
1190     {
1191         recordGroup *arg1 ;
1192         int result;
1193         int argvi = 0;
1194         dXSARGS;
1195
1196         if ((items < 1) || (items > 1)) {
1197             SWIG_croak("Usage: recordGroup_databaseNamePath_get(self);");
1198         }
1199         {
1200             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1201                 SWIG_croak("Type error in argument 1 of recordGroup_databaseNamePath_get. Expected _p_recordGroup");
1202             }
1203         }
1204         result = (int) ((arg1)->databaseNamePath);
1205
1206         ST(argvi) = sv_newmortal();
1207         sv_setiv(ST(argvi++), (IV) result);
1208         XSRETURN(argvi);
1209         fail:
1210         (void) _swigerr;
1211     }
1212     croak(_swigerr);
1213 }
1214
1215
1216 XS(_wrap_recordGroup_explainDatabase_set) {
1217     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1218     const char *_swigerr = _swigmsg;
1219     {
1220         recordGroup *arg1 ;
1221         int arg2 ;
1222         int argvi = 0;
1223         dXSARGS;
1224
1225         if ((items < 2) || (items > 2)) {
1226             SWIG_croak("Usage: recordGroup_explainDatabase_set(self,explainDatabase);");
1227         }
1228         {
1229             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1230                 SWIG_croak("Type error in argument 1 of recordGroup_explainDatabase_set. Expected _p_recordGroup");
1231             }
1232         }
1233         arg2 = (int) SvIV(ST(1));
1234         if (arg1) (arg1)->explainDatabase = arg2;
1235
1236
1237         XSRETURN(argvi);
1238         fail:
1239         (void) _swigerr;
1240     }
1241     croak(_swigerr);
1242 }
1243
1244
1245 XS(_wrap_recordGroup_explainDatabase_get) {
1246     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1247     const char *_swigerr = _swigmsg;
1248     {
1249         recordGroup *arg1 ;
1250         int result;
1251         int argvi = 0;
1252         dXSARGS;
1253
1254         if ((items < 1) || (items > 1)) {
1255             SWIG_croak("Usage: recordGroup_explainDatabase_get(self);");
1256         }
1257         {
1258             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1259                 SWIG_croak("Type error in argument 1 of recordGroup_explainDatabase_get. Expected _p_recordGroup");
1260             }
1261         }
1262         result = (int) ((arg1)->explainDatabase);
1263
1264         ST(argvi) = sv_newmortal();
1265         sv_setiv(ST(argvi++), (IV) result);
1266         XSRETURN(argvi);
1267         fail:
1268         (void) _swigerr;
1269     }
1270     croak(_swigerr);
1271 }
1272
1273
1274 XS(_wrap_recordGroup_followLinks_set) {
1275     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1276     const char *_swigerr = _swigmsg;
1277     {
1278         recordGroup *arg1 ;
1279         int arg2 ;
1280         int argvi = 0;
1281         dXSARGS;
1282
1283         if ((items < 2) || (items > 2)) {
1284             SWIG_croak("Usage: recordGroup_followLinks_set(self,followLinks);");
1285         }
1286         {
1287             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1288                 SWIG_croak("Type error in argument 1 of recordGroup_followLinks_set. Expected _p_recordGroup");
1289             }
1290         }
1291         arg2 = (int) SvIV(ST(1));
1292         if (arg1) (arg1)->followLinks = arg2;
1293
1294
1295         XSRETURN(argvi);
1296         fail:
1297         (void) _swigerr;
1298     }
1299     croak(_swigerr);
1300 }
1301
1302
1303 XS(_wrap_recordGroup_followLinks_get) {
1304     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1305     const char *_swigerr = _swigmsg;
1306     {
1307         recordGroup *arg1 ;
1308         int result;
1309         int argvi = 0;
1310         dXSARGS;
1311
1312         if ((items < 1) || (items > 1)) {
1313             SWIG_croak("Usage: recordGroup_followLinks_get(self);");
1314         }
1315         {
1316             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1317                 SWIG_croak("Type error in argument 1 of recordGroup_followLinks_get. Expected _p_recordGroup");
1318             }
1319         }
1320         result = (int) ((arg1)->followLinks);
1321
1322         ST(argvi) = sv_newmortal();
1323         sv_setiv(ST(argvi++), (IV) result);
1324         XSRETURN(argvi);
1325         fail:
1326         (void) _swigerr;
1327     }
1328     croak(_swigerr);
1329 }
1330
1331
1332 XS(_wrap_new_recordGroup) {
1333     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1334     const char *_swigerr = _swigmsg;
1335     {
1336         recordGroup *result;
1337         int argvi = 0;
1338         dXSARGS;
1339
1340         if ((items < 0) || (items > 0)) {
1341             SWIG_croak("Usage: new_recordGroup();");
1342         }
1343         result = (recordGroup *)(recordGroup *) calloc(1, sizeof(recordGroup));
1344
1345         ST(argvi) = sv_newmortal();
1346         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_recordGroup,0);
1347         XSRETURN(argvi);
1348         fail:
1349         (void) _swigerr;
1350     }
1351     croak(_swigerr);
1352 }
1353
1354
1355 XS(_wrap_delete_recordGroup) {
1356     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1357     const char *_swigerr = _swigmsg;
1358     {
1359         recordGroup *arg1 ;
1360         int argvi = 0;
1361         dXSARGS;
1362
1363         if ((items < 1) || (items > 1)) {
1364             SWIG_croak("Usage: delete_recordGroup(self);");
1365         }
1366         {
1367             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
1368                 SWIG_croak("Type error in argument 1 of delete_recordGroup. Expected _p_recordGroup");
1369             }
1370         }
1371         free((char *) arg1);
1372
1373
1374         XSRETURN(argvi);
1375         fail:
1376         (void) _swigerr;
1377     }
1378     croak(_swigerr);
1379 }
1380
1381
1382 XS(_wrap_RetrievalObj_noOfRecords_set) {
1383     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1384     const char *_swigerr = _swigmsg;
1385     {
1386         RetrievalObj *arg1 ;
1387         int arg2 ;
1388         int argvi = 0;
1389         dXSARGS;
1390
1391         if ((items < 2) || (items > 2)) {
1392             SWIG_croak("Usage: RetrievalObj_noOfRecords_set(self,noOfRecords);");
1393         }
1394         {
1395             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalObj,0) < 0) {
1396                 SWIG_croak("Type error in argument 1 of RetrievalObj_noOfRecords_set. Expected _p_RetrievalObj");
1397             }
1398         }
1399         arg2 = (int) SvIV(ST(1));
1400         if (arg1) (arg1)->noOfRecords = arg2;
1401
1402
1403         XSRETURN(argvi);
1404         fail:
1405         (void) _swigerr;
1406     }
1407     croak(_swigerr);
1408 }
1409
1410
1411 XS(_wrap_RetrievalObj_noOfRecords_get) {
1412     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1413     const char *_swigerr = _swigmsg;
1414     {
1415         RetrievalObj *arg1 ;
1416         int result;
1417         int argvi = 0;
1418         dXSARGS;
1419
1420         if ((items < 1) || (items > 1)) {
1421             SWIG_croak("Usage: RetrievalObj_noOfRecords_get(self);");
1422         }
1423         {
1424             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalObj,0) < 0) {
1425                 SWIG_croak("Type error in argument 1 of RetrievalObj_noOfRecords_get. Expected _p_RetrievalObj");
1426             }
1427         }
1428         result = (int) ((arg1)->noOfRecords);
1429
1430         ST(argvi) = sv_newmortal();
1431         sv_setiv(ST(argvi++), (IV) result);
1432         XSRETURN(argvi);
1433         fail:
1434         (void) _swigerr;
1435     }
1436     croak(_swigerr);
1437 }
1438
1439
1440 XS(_wrap_RetrievalObj_records_set) {
1441     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1442     const char *_swigerr = _swigmsg;
1443     {
1444         RetrievalObj *arg1 ;
1445         ZebraRetrievalRecord *arg2 ;
1446         int argvi = 0;
1447         dXSARGS;
1448
1449         if ((items < 2) || (items > 2)) {
1450             SWIG_croak("Usage: RetrievalObj_records_set(self,records);");
1451         }
1452         {
1453             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalObj,0) < 0) {
1454                 SWIG_croak("Type error in argument 1 of RetrievalObj_records_set. Expected _p_RetrievalObj");
1455             }
1456         }
1457         {
1458             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ZebraRetrievalRecord,0) < 0) {
1459                 SWIG_croak("Type error in argument 2 of RetrievalObj_records_set. Expected _p_ZebraRetrievalRecord");
1460             }
1461         }
1462         if (arg1) (arg1)->records = arg2;
1463
1464
1465         XSRETURN(argvi);
1466         fail:
1467         (void) _swigerr;
1468     }
1469     croak(_swigerr);
1470 }
1471
1472
1473 XS(_wrap_RetrievalObj_records_get) {
1474     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1475     const char *_swigerr = _swigmsg;
1476     {
1477         RetrievalObj *arg1 ;
1478         ZebraRetrievalRecord *result;
1479         int argvi = 0;
1480         dXSARGS;
1481
1482         if ((items < 1) || (items > 1)) {
1483             SWIG_croak("Usage: RetrievalObj_records_get(self);");
1484         }
1485         {
1486             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalObj,0) < 0) {
1487                 SWIG_croak("Type error in argument 1 of RetrievalObj_records_get. Expected _p_RetrievalObj");
1488             }
1489         }
1490         result = (ZebraRetrievalRecord *) ((arg1)->records);
1491
1492         ST(argvi) = sv_newmortal();
1493         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ZebraRetrievalRecord,0);
1494         XSRETURN(argvi);
1495         fail:
1496         (void) _swigerr;
1497     }
1498     croak(_swigerr);
1499 }
1500
1501
1502 XS(_wrap_new_RetrievalObj) {
1503     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1504     const char *_swigerr = _swigmsg;
1505     {
1506         RetrievalObj *result;
1507         int argvi = 0;
1508         dXSARGS;
1509
1510         if ((items < 0) || (items > 0)) {
1511             SWIG_croak("Usage: new_RetrievalObj();");
1512         }
1513         result = (RetrievalObj *)(RetrievalObj *) calloc(1, sizeof(RetrievalObj));
1514
1515         ST(argvi) = sv_newmortal();
1516         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_RetrievalObj,0);
1517         XSRETURN(argvi);
1518         fail:
1519         (void) _swigerr;
1520     }
1521     croak(_swigerr);
1522 }
1523
1524
1525 XS(_wrap_delete_RetrievalObj) {
1526     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1527     const char *_swigerr = _swigmsg;
1528     {
1529         RetrievalObj *arg1 ;
1530         int argvi = 0;
1531         dXSARGS;
1532
1533         if ((items < 1) || (items > 1)) {
1534             SWIG_croak("Usage: delete_RetrievalObj(self);");
1535         }
1536         {
1537             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalObj,0) < 0) {
1538                 SWIG_croak("Type error in argument 1 of delete_RetrievalObj. Expected _p_RetrievalObj");
1539             }
1540         }
1541         free((char *) arg1);
1542
1543
1544         XSRETURN(argvi);
1545         fail:
1546         (void) _swigerr;
1547     }
1548     croak(_swigerr);
1549 }
1550
1551
1552 XS(_wrap_RetrievalRecord_errCode_set) {
1553     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1554     const char *_swigerr = _swigmsg;
1555     {
1556         RetrievalRecord *arg1 ;
1557         int arg2 ;
1558         int argvi = 0;
1559         dXSARGS;
1560
1561         if ((items < 2) || (items > 2)) {
1562             SWIG_croak("Usage: RetrievalRecord_errCode_set(self,errCode);");
1563         }
1564         {
1565             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1566                 SWIG_croak("Type error in argument 1 of RetrievalRecord_errCode_set. Expected _p_RetrievalRecord");
1567             }
1568         }
1569         arg2 = (int) SvIV(ST(1));
1570         if (arg1) (arg1)->errCode = arg2;
1571
1572
1573         XSRETURN(argvi);
1574         fail:
1575         (void) _swigerr;
1576     }
1577     croak(_swigerr);
1578 }
1579
1580
1581 XS(_wrap_RetrievalRecord_errCode_get) {
1582     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1583     const char *_swigerr = _swigmsg;
1584     {
1585         RetrievalRecord *arg1 ;
1586         int result;
1587         int argvi = 0;
1588         dXSARGS;
1589
1590         if ((items < 1) || (items > 1)) {
1591             SWIG_croak("Usage: RetrievalRecord_errCode_get(self);");
1592         }
1593         {
1594             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1595                 SWIG_croak("Type error in argument 1 of RetrievalRecord_errCode_get. Expected _p_RetrievalRecord");
1596             }
1597         }
1598         result = (int) ((arg1)->errCode);
1599
1600         ST(argvi) = sv_newmortal();
1601         sv_setiv(ST(argvi++), (IV) result);
1602         XSRETURN(argvi);
1603         fail:
1604         (void) _swigerr;
1605     }
1606     croak(_swigerr);
1607 }
1608
1609
1610 XS(_wrap_RetrievalRecord_errString_set) {
1611     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1612     const char *_swigerr = _swigmsg;
1613     {
1614         RetrievalRecord *arg1 ;
1615         char *arg2 ;
1616         int argvi = 0;
1617         dXSARGS;
1618
1619         if ((items < 2) || (items > 2)) {
1620             SWIG_croak("Usage: RetrievalRecord_errString_set(self,errString);");
1621         }
1622         {
1623             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1624                 SWIG_croak("Type error in argument 1 of RetrievalRecord_errString_set. Expected _p_RetrievalRecord");
1625             }
1626         }
1627         if (!SvOK((SV*) ST(1))) arg2 = 0;
1628         else arg2 = (char *) SvPV(ST(1), PL_na);
1629         {
1630             if (arg1->errString) free((char*)arg1->errString);
1631             arg1->errString = (char *) malloc(strlen(arg2)+1);
1632             strcpy((char*)arg1->errString,arg2);
1633         }
1634
1635         XSRETURN(argvi);
1636         fail:
1637         (void) _swigerr;
1638     }
1639     croak(_swigerr);
1640 }
1641
1642
1643 XS(_wrap_RetrievalRecord_errString_get) {
1644     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1645     const char *_swigerr = _swigmsg;
1646     {
1647         RetrievalRecord *arg1 ;
1648         char *result;
1649         int argvi = 0;
1650         dXSARGS;
1651
1652         if ((items < 1) || (items > 1)) {
1653             SWIG_croak("Usage: RetrievalRecord_errString_get(self);");
1654         }
1655         {
1656             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1657                 SWIG_croak("Type error in argument 1 of RetrievalRecord_errString_get. Expected _p_RetrievalRecord");
1658             }
1659         }
1660         result = (char *) ((arg1)->errString);
1661
1662         ST(argvi) = sv_newmortal();
1663         if (result) {
1664             sv_setpv((SV*)ST(argvi++), (char *) result);
1665         }else {
1666             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
1667         }
1668         XSRETURN(argvi);
1669         fail:
1670         (void) _swigerr;
1671     }
1672     croak(_swigerr);
1673 }
1674
1675
1676 XS(_wrap_RetrievalRecord_position_set) {
1677     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1678     const char *_swigerr = _swigmsg;
1679     {
1680         RetrievalRecord *arg1 ;
1681         int arg2 ;
1682         int argvi = 0;
1683         dXSARGS;
1684
1685         if ((items < 2) || (items > 2)) {
1686             SWIG_croak("Usage: RetrievalRecord_position_set(self,position);");
1687         }
1688         {
1689             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1690                 SWIG_croak("Type error in argument 1 of RetrievalRecord_position_set. Expected _p_RetrievalRecord");
1691             }
1692         }
1693         arg2 = (int) SvIV(ST(1));
1694         if (arg1) (arg1)->position = arg2;
1695
1696
1697         XSRETURN(argvi);
1698         fail:
1699         (void) _swigerr;
1700     }
1701     croak(_swigerr);
1702 }
1703
1704
1705 XS(_wrap_RetrievalRecord_position_get) {
1706     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1707     const char *_swigerr = _swigmsg;
1708     {
1709         RetrievalRecord *arg1 ;
1710         int result;
1711         int argvi = 0;
1712         dXSARGS;
1713
1714         if ((items < 1) || (items > 1)) {
1715             SWIG_croak("Usage: RetrievalRecord_position_get(self);");
1716         }
1717         {
1718             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1719                 SWIG_croak("Type error in argument 1 of RetrievalRecord_position_get. Expected _p_RetrievalRecord");
1720             }
1721         }
1722         result = (int) ((arg1)->position);
1723
1724         ST(argvi) = sv_newmortal();
1725         sv_setiv(ST(argvi++), (IV) result);
1726         XSRETURN(argvi);
1727         fail:
1728         (void) _swigerr;
1729     }
1730     croak(_swigerr);
1731 }
1732
1733
1734 XS(_wrap_RetrievalRecord_base_set) {
1735     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1736     const char *_swigerr = _swigmsg;
1737     {
1738         RetrievalRecord *arg1 ;
1739         char *arg2 ;
1740         int argvi = 0;
1741         dXSARGS;
1742
1743         if ((items < 2) || (items > 2)) {
1744             SWIG_croak("Usage: RetrievalRecord_base_set(self,base);");
1745         }
1746         {
1747             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1748                 SWIG_croak("Type error in argument 1 of RetrievalRecord_base_set. Expected _p_RetrievalRecord");
1749             }
1750         }
1751         if (!SvOK((SV*) ST(1))) arg2 = 0;
1752         else arg2 = (char *) SvPV(ST(1), PL_na);
1753         {
1754             if (arg1->base) free((char*)arg1->base);
1755             arg1->base = (char *) malloc(strlen(arg2)+1);
1756             strcpy((char*)arg1->base,arg2);
1757         }
1758
1759         XSRETURN(argvi);
1760         fail:
1761         (void) _swigerr;
1762     }
1763     croak(_swigerr);
1764 }
1765
1766
1767 XS(_wrap_RetrievalRecord_base_get) {
1768     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1769     const char *_swigerr = _swigmsg;
1770     {
1771         RetrievalRecord *arg1 ;
1772         char *result;
1773         int argvi = 0;
1774         dXSARGS;
1775
1776         if ((items < 1) || (items > 1)) {
1777             SWIG_croak("Usage: RetrievalRecord_base_get(self);");
1778         }
1779         {
1780             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1781                 SWIG_croak("Type error in argument 1 of RetrievalRecord_base_get. Expected _p_RetrievalRecord");
1782             }
1783         }
1784         result = (char *) ((arg1)->base);
1785
1786         ST(argvi) = sv_newmortal();
1787         if (result) {
1788             sv_setpv((SV*)ST(argvi++), (char *) result);
1789         }else {
1790             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
1791         }
1792         XSRETURN(argvi);
1793         fail:
1794         (void) _swigerr;
1795     }
1796     croak(_swigerr);
1797 }
1798
1799
1800 XS(_wrap_RetrievalRecord_sysno_set) {
1801     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1802     const char *_swigerr = _swigmsg;
1803     {
1804         RetrievalRecord *arg1 ;
1805         int arg2 ;
1806         int argvi = 0;
1807         dXSARGS;
1808
1809         if ((items < 2) || (items > 2)) {
1810             SWIG_croak("Usage: RetrievalRecord_sysno_set(self,sysno);");
1811         }
1812         {
1813             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1814                 SWIG_croak("Type error in argument 1 of RetrievalRecord_sysno_set. Expected _p_RetrievalRecord");
1815             }
1816         }
1817         arg2 = (int) SvIV(ST(1));
1818         if (arg1) (arg1)->sysno = arg2;
1819
1820
1821         XSRETURN(argvi);
1822         fail:
1823         (void) _swigerr;
1824     }
1825     croak(_swigerr);
1826 }
1827
1828
1829 XS(_wrap_RetrievalRecord_sysno_get) {
1830     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1831     const char *_swigerr = _swigmsg;
1832     {
1833         RetrievalRecord *arg1 ;
1834         int result;
1835         int argvi = 0;
1836         dXSARGS;
1837
1838         if ((items < 1) || (items > 1)) {
1839             SWIG_croak("Usage: RetrievalRecord_sysno_get(self);");
1840         }
1841         {
1842             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1843                 SWIG_croak("Type error in argument 1 of RetrievalRecord_sysno_get. Expected _p_RetrievalRecord");
1844             }
1845         }
1846         result = (int) ((arg1)->sysno);
1847
1848         ST(argvi) = sv_newmortal();
1849         sv_setiv(ST(argvi++), (IV) result);
1850         XSRETURN(argvi);
1851         fail:
1852         (void) _swigerr;
1853     }
1854     croak(_swigerr);
1855 }
1856
1857
1858 XS(_wrap_RetrievalRecord_score_set) {
1859     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1860     const char *_swigerr = _swigmsg;
1861     {
1862         RetrievalRecord *arg1 ;
1863         int arg2 ;
1864         int argvi = 0;
1865         dXSARGS;
1866
1867         if ((items < 2) || (items > 2)) {
1868             SWIG_croak("Usage: RetrievalRecord_score_set(self,score);");
1869         }
1870         {
1871             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1872                 SWIG_croak("Type error in argument 1 of RetrievalRecord_score_set. Expected _p_RetrievalRecord");
1873             }
1874         }
1875         arg2 = (int) SvIV(ST(1));
1876         if (arg1) (arg1)->score = arg2;
1877
1878
1879         XSRETURN(argvi);
1880         fail:
1881         (void) _swigerr;
1882     }
1883     croak(_swigerr);
1884 }
1885
1886
1887 XS(_wrap_RetrievalRecord_score_get) {
1888     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1889     const char *_swigerr = _swigmsg;
1890     {
1891         RetrievalRecord *arg1 ;
1892         int result;
1893         int argvi = 0;
1894         dXSARGS;
1895
1896         if ((items < 1) || (items > 1)) {
1897             SWIG_croak("Usage: RetrievalRecord_score_get(self);");
1898         }
1899         {
1900             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1901                 SWIG_croak("Type error in argument 1 of RetrievalRecord_score_get. Expected _p_RetrievalRecord");
1902             }
1903         }
1904         result = (int) ((arg1)->score);
1905
1906         ST(argvi) = sv_newmortal();
1907         sv_setiv(ST(argvi++), (IV) result);
1908         XSRETURN(argvi);
1909         fail:
1910         (void) _swigerr;
1911     }
1912     croak(_swigerr);
1913 }
1914
1915
1916 XS(_wrap_RetrievalRecord_format_set) {
1917     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1918     const char *_swigerr = _swigmsg;
1919     {
1920         RetrievalRecord *arg1 ;
1921         char *arg2 ;
1922         int argvi = 0;
1923         dXSARGS;
1924
1925         if ((items < 2) || (items > 2)) {
1926             SWIG_croak("Usage: RetrievalRecord_format_set(self,format);");
1927         }
1928         {
1929             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1930                 SWIG_croak("Type error in argument 1 of RetrievalRecord_format_set. Expected _p_RetrievalRecord");
1931             }
1932         }
1933         if (!SvOK((SV*) ST(1))) arg2 = 0;
1934         else arg2 = (char *) SvPV(ST(1), PL_na);
1935         {
1936             if (arg1->format) free((char*)arg1->format);
1937             arg1->format = (char *) malloc(strlen(arg2)+1);
1938             strcpy((char*)arg1->format,arg2);
1939         }
1940
1941         XSRETURN(argvi);
1942         fail:
1943         (void) _swigerr;
1944     }
1945     croak(_swigerr);
1946 }
1947
1948
1949 XS(_wrap_RetrievalRecord_format_get) {
1950     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1951     const char *_swigerr = _swigmsg;
1952     {
1953         RetrievalRecord *arg1 ;
1954         char *result;
1955         int argvi = 0;
1956         dXSARGS;
1957
1958         if ((items < 1) || (items > 1)) {
1959             SWIG_croak("Usage: RetrievalRecord_format_get(self);");
1960         }
1961         {
1962             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1963                 SWIG_croak("Type error in argument 1 of RetrievalRecord_format_get. Expected _p_RetrievalRecord");
1964             }
1965         }
1966         result = (char *) ((arg1)->format);
1967
1968         ST(argvi) = sv_newmortal();
1969         if (result) {
1970             sv_setpv((SV*)ST(argvi++), (char *) result);
1971         }else {
1972             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
1973         }
1974         XSRETURN(argvi);
1975         fail:
1976         (void) _swigerr;
1977     }
1978     croak(_swigerr);
1979 }
1980
1981
1982 XS(_wrap_RetrievalRecord_buf_set) {
1983     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1984     const char *_swigerr = _swigmsg;
1985     {
1986         RetrievalRecord *arg1 ;
1987         RetrievalRecordBuf *arg2 ;
1988         int argvi = 0;
1989         dXSARGS;
1990
1991         if ((items < 2) || (items > 2)) {
1992             SWIG_croak("Usage: RetrievalRecord_buf_set(self,buf);");
1993         }
1994         {
1995             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1996                 SWIG_croak("Type error in argument 1 of RetrievalRecord_buf_set. Expected _p_RetrievalRecord");
1997             }
1998         }
1999         {
2000             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_RetrievalRecordBuf,0) < 0) {
2001                 SWIG_croak("Type error in argument 2 of RetrievalRecord_buf_set. Expected _p_RetrievalRecordBuf");
2002             }
2003         }
2004         if (arg1) (arg1)->buf = arg2;
2005
2006
2007         XSRETURN(argvi);
2008         fail:
2009         (void) _swigerr;
2010     }
2011     croak(_swigerr);
2012 }
2013
2014
2015 XS(_wrap_RetrievalRecord_buf_get) {
2016     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2017     const char *_swigerr = _swigmsg;
2018     {
2019         RetrievalRecord *arg1 ;
2020         RetrievalRecordBuf *result;
2021         int argvi = 0;
2022         dXSARGS;
2023
2024         if ((items < 1) || (items > 1)) {
2025             SWIG_croak("Usage: RetrievalRecord_buf_get(self);");
2026         }
2027         {
2028             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
2029                 SWIG_croak("Type error in argument 1 of RetrievalRecord_buf_get. Expected _p_RetrievalRecord");
2030             }
2031         }
2032         result = (RetrievalRecordBuf *) ((arg1)->buf);
2033
2034         {
2035             if (result->len) {
2036                 ST(argvi) = newSVpv(result->buf,result->len);
2037             }else {
2038                 ST(argvi) = newSVpv("",0);
2039             }
2040             sv_2mortal(ST(argvi));
2041             argvi++;
2042         }
2043         XSRETURN(argvi);
2044         fail:
2045         (void) _swigerr;
2046     }
2047     croak(_swigerr);
2048 }
2049
2050
2051 XS(_wrap_new_RetrievalRecord) {
2052     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2053     const char *_swigerr = _swigmsg;
2054     {
2055         RetrievalRecord *result;
2056         int argvi = 0;
2057         dXSARGS;
2058
2059         if ((items < 0) || (items > 0)) {
2060             SWIG_croak("Usage: new_RetrievalRecord();");
2061         }
2062         result = (RetrievalRecord *)(RetrievalRecord *) calloc(1, sizeof(RetrievalRecord));
2063
2064         ST(argvi) = sv_newmortal();
2065         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_RetrievalRecord,0);
2066         XSRETURN(argvi);
2067         fail:
2068         (void) _swigerr;
2069     }
2070     croak(_swigerr);
2071 }
2072
2073
2074 XS(_wrap_delete_RetrievalRecord) {
2075     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2076     const char *_swigerr = _swigmsg;
2077     {
2078         RetrievalRecord *arg1 ;
2079         int argvi = 0;
2080         dXSARGS;
2081
2082         if ((items < 1) || (items > 1)) {
2083             SWIG_croak("Usage: delete_RetrievalRecord(self);");
2084         }
2085         {
2086             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
2087                 SWIG_croak("Type error in argument 1 of delete_RetrievalRecord. Expected _p_RetrievalRecord");
2088             }
2089         }
2090         free((char *) arg1);
2091
2092
2093         XSRETURN(argvi);
2094         fail:
2095         (void) _swigerr;
2096     }
2097     croak(_swigerr);
2098 }
2099
2100
2101 XS(_wrap_scanEntry_occurrences_set) {
2102     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2103     const char *_swigerr = _swigmsg;
2104     {
2105         scanEntry *arg1 ;
2106         int arg2 ;
2107         int argvi = 0;
2108         dXSARGS;
2109
2110         if ((items < 2) || (items > 2)) {
2111             SWIG_croak("Usage: scanEntry_occurrences_set(self,occurrences);");
2112         }
2113         {
2114             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) {
2115                 SWIG_croak("Type error in argument 1 of scanEntry_occurrences_set. Expected _p_scanEntry");
2116             }
2117         }
2118         arg2 = (int) SvIV(ST(1));
2119         if (arg1) (arg1)->occurrences = arg2;
2120
2121
2122         XSRETURN(argvi);
2123         fail:
2124         (void) _swigerr;
2125     }
2126     croak(_swigerr);
2127 }
2128
2129
2130 XS(_wrap_scanEntry_occurrences_get) {
2131     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2132     const char *_swigerr = _swigmsg;
2133     {
2134         scanEntry *arg1 ;
2135         int result;
2136         int argvi = 0;
2137         dXSARGS;
2138
2139         if ((items < 1) || (items > 1)) {
2140             SWIG_croak("Usage: scanEntry_occurrences_get(self);");
2141         }
2142         {
2143             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) {
2144                 SWIG_croak("Type error in argument 1 of scanEntry_occurrences_get. Expected _p_scanEntry");
2145             }
2146         }
2147         result = (int) ((arg1)->occurrences);
2148
2149         ST(argvi) = sv_newmortal();
2150         sv_setiv(ST(argvi++), (IV) result);
2151         XSRETURN(argvi);
2152         fail:
2153         (void) _swigerr;
2154     }
2155     croak(_swigerr);
2156 }
2157
2158
2159 XS(_wrap_scanEntry_term_set) {
2160     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2161     const char *_swigerr = _swigmsg;
2162     {
2163         scanEntry *arg1 ;
2164         char *arg2 ;
2165         int argvi = 0;
2166         dXSARGS;
2167
2168         if ((items < 2) || (items > 2)) {
2169             SWIG_croak("Usage: scanEntry_term_set(self,term);");
2170         }
2171         {
2172             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) {
2173                 SWIG_croak("Type error in argument 1 of scanEntry_term_set. Expected _p_scanEntry");
2174             }
2175         }
2176         if (!SvOK((SV*) ST(1))) arg2 = 0;
2177         else arg2 = (char *) SvPV(ST(1), PL_na);
2178         {
2179             if (arg1->term) free((char*)arg1->term);
2180             arg1->term = (char *) malloc(strlen(arg2)+1);
2181             strcpy((char*)arg1->term,arg2);
2182         }
2183
2184         XSRETURN(argvi);
2185         fail:
2186         (void) _swigerr;
2187     }
2188     croak(_swigerr);
2189 }
2190
2191
2192 XS(_wrap_scanEntry_term_get) {
2193     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2194     const char *_swigerr = _swigmsg;
2195     {
2196         scanEntry *arg1 ;
2197         char *result;
2198         int argvi = 0;
2199         dXSARGS;
2200
2201         if ((items < 1) || (items > 1)) {
2202             SWIG_croak("Usage: scanEntry_term_get(self);");
2203         }
2204         {
2205             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) {
2206                 SWIG_croak("Type error in argument 1 of scanEntry_term_get. Expected _p_scanEntry");
2207             }
2208         }
2209         result = (char *) ((arg1)->term);
2210
2211         ST(argvi) = sv_newmortal();
2212         if (result) {
2213             sv_setpv((SV*)ST(argvi++), (char *) result);
2214         }else {
2215             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
2216         }
2217         XSRETURN(argvi);
2218         fail:
2219         (void) _swigerr;
2220     }
2221     croak(_swigerr);
2222 }
2223
2224
2225 XS(_wrap_new_scanEntry) {
2226     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2227     const char *_swigerr = _swigmsg;
2228     {
2229         scanEntry *result;
2230         int argvi = 0;
2231         dXSARGS;
2232
2233         if ((items < 0) || (items > 0)) {
2234             SWIG_croak("Usage: new_scanEntry();");
2235         }
2236         result = (scanEntry *)(scanEntry *) calloc(1, sizeof(scanEntry));
2237
2238         ST(argvi) = sv_newmortal();
2239         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_scanEntry,0);
2240         XSRETURN(argvi);
2241         fail:
2242         (void) _swigerr;
2243     }
2244     croak(_swigerr);
2245 }
2246
2247
2248 XS(_wrap_delete_scanEntry) {
2249     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2250     const char *_swigerr = _swigmsg;
2251     {
2252         scanEntry *arg1 ;
2253         int argvi = 0;
2254         dXSARGS;
2255
2256         if ((items < 1) || (items > 1)) {
2257             SWIG_croak("Usage: delete_scanEntry(self);");
2258         }
2259         {
2260             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) {
2261                 SWIG_croak("Type error in argument 1 of delete_scanEntry. Expected _p_scanEntry");
2262             }
2263         }
2264         free((char *) arg1);
2265
2266
2267         XSRETURN(argvi);
2268         fail:
2269         (void) _swigerr;
2270     }
2271     croak(_swigerr);
2272 }
2273
2274
2275 XS(_wrap_ScanObj_num_entries_set) {
2276     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2277     const char *_swigerr = _swigmsg;
2278     {
2279         ScanObj *arg1 ;
2280         int arg2 ;
2281         int argvi = 0;
2282         dXSARGS;
2283
2284         if ((items < 2) || (items > 2)) {
2285             SWIG_croak("Usage: ScanObj_num_entries_set(self,num_entries);");
2286         }
2287         {
2288             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2289                 SWIG_croak("Type error in argument 1 of ScanObj_num_entries_set. Expected _p_ScanObj");
2290             }
2291         }
2292         arg2 = (int) SvIV(ST(1));
2293         if (arg1) (arg1)->num_entries = arg2;
2294
2295
2296         XSRETURN(argvi);
2297         fail:
2298         (void) _swigerr;
2299     }
2300     croak(_swigerr);
2301 }
2302
2303
2304 XS(_wrap_ScanObj_num_entries_get) {
2305     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2306     const char *_swigerr = _swigmsg;
2307     {
2308         ScanObj *arg1 ;
2309         int result;
2310         int argvi = 0;
2311         dXSARGS;
2312
2313         if ((items < 1) || (items > 1)) {
2314             SWIG_croak("Usage: ScanObj_num_entries_get(self);");
2315         }
2316         {
2317             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2318                 SWIG_croak("Type error in argument 1 of ScanObj_num_entries_get. Expected _p_ScanObj");
2319             }
2320         }
2321         result = (int) ((arg1)->num_entries);
2322
2323         ST(argvi) = sv_newmortal();
2324         sv_setiv(ST(argvi++), (IV) result);
2325         XSRETURN(argvi);
2326         fail:
2327         (void) _swigerr;
2328     }
2329     croak(_swigerr);
2330 }
2331
2332
2333 XS(_wrap_ScanObj_position_set) {
2334     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2335     const char *_swigerr = _swigmsg;
2336     {
2337         ScanObj *arg1 ;
2338         int arg2 ;
2339         int argvi = 0;
2340         dXSARGS;
2341
2342         if ((items < 2) || (items > 2)) {
2343             SWIG_croak("Usage: ScanObj_position_set(self,position);");
2344         }
2345         {
2346             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2347                 SWIG_croak("Type error in argument 1 of ScanObj_position_set. Expected _p_ScanObj");
2348             }
2349         }
2350         arg2 = (int) SvIV(ST(1));
2351         if (arg1) (arg1)->position = arg2;
2352
2353
2354         XSRETURN(argvi);
2355         fail:
2356         (void) _swigerr;
2357     }
2358     croak(_swigerr);
2359 }
2360
2361
2362 XS(_wrap_ScanObj_position_get) {
2363     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2364     const char *_swigerr = _swigmsg;
2365     {
2366         ScanObj *arg1 ;
2367         int result;
2368         int argvi = 0;
2369         dXSARGS;
2370
2371         if ((items < 1) || (items > 1)) {
2372             SWIG_croak("Usage: ScanObj_position_get(self);");
2373         }
2374         {
2375             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2376                 SWIG_croak("Type error in argument 1 of ScanObj_position_get. Expected _p_ScanObj");
2377             }
2378         }
2379         result = (int) ((arg1)->position);
2380
2381         ST(argvi) = sv_newmortal();
2382         sv_setiv(ST(argvi++), (IV) result);
2383         XSRETURN(argvi);
2384         fail:
2385         (void) _swigerr;
2386     }
2387     croak(_swigerr);
2388 }
2389
2390
2391 XS(_wrap_ScanObj_is_partial_set) {
2392     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2393     const char *_swigerr = _swigmsg;
2394     {
2395         ScanObj *arg1 ;
2396         int arg2 ;
2397         int argvi = 0;
2398         dXSARGS;
2399
2400         if ((items < 2) || (items > 2)) {
2401             SWIG_croak("Usage: ScanObj_is_partial_set(self,is_partial);");
2402         }
2403         {
2404             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2405                 SWIG_croak("Type error in argument 1 of ScanObj_is_partial_set. Expected _p_ScanObj");
2406             }
2407         }
2408         arg2 = (int) SvIV(ST(1));
2409         if (arg1) (arg1)->is_partial = arg2;
2410
2411
2412         XSRETURN(argvi);
2413         fail:
2414         (void) _swigerr;
2415     }
2416     croak(_swigerr);
2417 }
2418
2419
2420 XS(_wrap_ScanObj_is_partial_get) {
2421     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2422     const char *_swigerr = _swigmsg;
2423     {
2424         ScanObj *arg1 ;
2425         int result;
2426         int argvi = 0;
2427         dXSARGS;
2428
2429         if ((items < 1) || (items > 1)) {
2430             SWIG_croak("Usage: ScanObj_is_partial_get(self);");
2431         }
2432         {
2433             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2434                 SWIG_croak("Type error in argument 1 of ScanObj_is_partial_get. Expected _p_ScanObj");
2435             }
2436         }
2437         result = (int) ((arg1)->is_partial);
2438
2439         ST(argvi) = sv_newmortal();
2440         sv_setiv(ST(argvi++), (IV) result);
2441         XSRETURN(argvi);
2442         fail:
2443         (void) _swigerr;
2444     }
2445     croak(_swigerr);
2446 }
2447
2448
2449 XS(_wrap_ScanObj_entries_set) {
2450     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2451     const char *_swigerr = _swigmsg;
2452     {
2453         ScanObj *arg1 ;
2454         scanEntry *arg2 ;
2455         int argvi = 0;
2456         dXSARGS;
2457
2458         if ((items < 2) || (items > 2)) {
2459             SWIG_croak("Usage: ScanObj_entries_set(self,entries);");
2460         }
2461         {
2462             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2463                 SWIG_croak("Type error in argument 1 of ScanObj_entries_set. Expected _p_ScanObj");
2464             }
2465         }
2466         {
2467             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_scanEntry,0) < 0) {
2468                 SWIG_croak("Type error in argument 2 of ScanObj_entries_set. Expected _p_scanEntry");
2469             }
2470         }
2471         if (arg1) (arg1)->entries = arg2;
2472
2473
2474         XSRETURN(argvi);
2475         fail:
2476         (void) _swigerr;
2477     }
2478     croak(_swigerr);
2479 }
2480
2481
2482 XS(_wrap_ScanObj_entries_get) {
2483     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2484     const char *_swigerr = _swigmsg;
2485     {
2486         ScanObj *arg1 ;
2487         scanEntry *result;
2488         int argvi = 0;
2489         dXSARGS;
2490
2491         if ((items < 1) || (items > 1)) {
2492             SWIG_croak("Usage: ScanObj_entries_get(self);");
2493         }
2494         {
2495             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2496                 SWIG_croak("Type error in argument 1 of ScanObj_entries_get. Expected _p_ScanObj");
2497             }
2498         }
2499         result = (scanEntry *) ((arg1)->entries);
2500
2501         ST(argvi) = sv_newmortal();
2502         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_scanEntry,0);
2503         XSRETURN(argvi);
2504         fail:
2505         (void) _swigerr;
2506     }
2507     croak(_swigerr);
2508 }
2509
2510
2511 XS(_wrap_new_ScanObj) {
2512     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2513     const char *_swigerr = _swigmsg;
2514     {
2515         ScanObj *result;
2516         int argvi = 0;
2517         dXSARGS;
2518
2519         if ((items < 0) || (items > 0)) {
2520             SWIG_croak("Usage: new_ScanObj();");
2521         }
2522         result = (ScanObj *)(ScanObj *) calloc(1, sizeof(ScanObj));
2523
2524         ST(argvi) = sv_newmortal();
2525         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ScanObj,0);
2526         XSRETURN(argvi);
2527         fail:
2528         (void) _swigerr;
2529     }
2530     croak(_swigerr);
2531 }
2532
2533
2534 XS(_wrap_delete_ScanObj) {
2535     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2536     const char *_swigerr = _swigmsg;
2537     {
2538         ScanObj *arg1 ;
2539         int argvi = 0;
2540         dXSARGS;
2541
2542         if ((items < 1) || (items > 1)) {
2543             SWIG_croak("Usage: delete_ScanObj(self);");
2544         }
2545         {
2546             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2547                 SWIG_croak("Type error in argument 1 of delete_ScanObj. Expected _p_ScanObj");
2548             }
2549         }
2550         free((char *) arg1);
2551
2552
2553         XSRETURN(argvi);
2554         fail:
2555         (void) _swigerr;
2556     }
2557     croak(_swigerr);
2558 }
2559
2560
2561 XS(_wrap_ZebraTransactionStatus_processed_set) {
2562     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2563     const char *_swigerr = _swigmsg;
2564     {
2565         ZebraTransactionStatus *arg1 ;
2566         int arg2 ;
2567         int argvi = 0;
2568         dXSARGS;
2569
2570         if ((items < 2) || (items > 2)) {
2571             SWIG_croak("Usage: ZebraTransactionStatus_processed_set(self,processed);");
2572         }
2573         {
2574             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2575                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_processed_set. Expected _p_ZebraTransactionStatus");
2576             }
2577         }
2578         arg2 = (int) SvIV(ST(1));
2579         if (arg1) (arg1)->processed = arg2;
2580
2581
2582         XSRETURN(argvi);
2583         fail:
2584         (void) _swigerr;
2585     }
2586     croak(_swigerr);
2587 }
2588
2589
2590 XS(_wrap_ZebraTransactionStatus_processed_get) {
2591     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2592     const char *_swigerr = _swigmsg;
2593     {
2594         ZebraTransactionStatus *arg1 ;
2595         int result;
2596         int argvi = 0;
2597         dXSARGS;
2598
2599         if ((items < 1) || (items > 1)) {
2600             SWIG_croak("Usage: ZebraTransactionStatus_processed_get(self);");
2601         }
2602         {
2603             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2604                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_processed_get. Expected _p_ZebraTransactionStatus");
2605             }
2606         }
2607         result = (int) ((arg1)->processed);
2608
2609         ST(argvi) = sv_newmortal();
2610         sv_setiv(ST(argvi++), (IV) result);
2611         XSRETURN(argvi);
2612         fail:
2613         (void) _swigerr;
2614     }
2615     croak(_swigerr);
2616 }
2617
2618
2619 XS(_wrap_ZebraTransactionStatus_inserted_set) {
2620     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2621     const char *_swigerr = _swigmsg;
2622     {
2623         ZebraTransactionStatus *arg1 ;
2624         int arg2 ;
2625         int argvi = 0;
2626         dXSARGS;
2627
2628         if ((items < 2) || (items > 2)) {
2629             SWIG_croak("Usage: ZebraTransactionStatus_inserted_set(self,inserted);");
2630         }
2631         {
2632             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2633                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_inserted_set. Expected _p_ZebraTransactionStatus");
2634             }
2635         }
2636         arg2 = (int) SvIV(ST(1));
2637         if (arg1) (arg1)->inserted = arg2;
2638
2639
2640         XSRETURN(argvi);
2641         fail:
2642         (void) _swigerr;
2643     }
2644     croak(_swigerr);
2645 }
2646
2647
2648 XS(_wrap_ZebraTransactionStatus_inserted_get) {
2649     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2650     const char *_swigerr = _swigmsg;
2651     {
2652         ZebraTransactionStatus *arg1 ;
2653         int result;
2654         int argvi = 0;
2655         dXSARGS;
2656
2657         if ((items < 1) || (items > 1)) {
2658             SWIG_croak("Usage: ZebraTransactionStatus_inserted_get(self);");
2659         }
2660         {
2661             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2662                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_inserted_get. Expected _p_ZebraTransactionStatus");
2663             }
2664         }
2665         result = (int) ((arg1)->inserted);
2666
2667         ST(argvi) = sv_newmortal();
2668         sv_setiv(ST(argvi++), (IV) result);
2669         XSRETURN(argvi);
2670         fail:
2671         (void) _swigerr;
2672     }
2673     croak(_swigerr);
2674 }
2675
2676
2677 XS(_wrap_ZebraTransactionStatus_updated_set) {
2678     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2679     const char *_swigerr = _swigmsg;
2680     {
2681         ZebraTransactionStatus *arg1 ;
2682         int arg2 ;
2683         int argvi = 0;
2684         dXSARGS;
2685
2686         if ((items < 2) || (items > 2)) {
2687             SWIG_croak("Usage: ZebraTransactionStatus_updated_set(self,updated);");
2688         }
2689         {
2690             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2691                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_updated_set. Expected _p_ZebraTransactionStatus");
2692             }
2693         }
2694         arg2 = (int) SvIV(ST(1));
2695         if (arg1) (arg1)->updated = arg2;
2696
2697
2698         XSRETURN(argvi);
2699         fail:
2700         (void) _swigerr;
2701     }
2702     croak(_swigerr);
2703 }
2704
2705
2706 XS(_wrap_ZebraTransactionStatus_updated_get) {
2707     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2708     const char *_swigerr = _swigmsg;
2709     {
2710         ZebraTransactionStatus *arg1 ;
2711         int result;
2712         int argvi = 0;
2713         dXSARGS;
2714
2715         if ((items < 1) || (items > 1)) {
2716             SWIG_croak("Usage: ZebraTransactionStatus_updated_get(self);");
2717         }
2718         {
2719             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2720                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_updated_get. Expected _p_ZebraTransactionStatus");
2721             }
2722         }
2723         result = (int) ((arg1)->updated);
2724
2725         ST(argvi) = sv_newmortal();
2726         sv_setiv(ST(argvi++), (IV) result);
2727         XSRETURN(argvi);
2728         fail:
2729         (void) _swigerr;
2730     }
2731     croak(_swigerr);
2732 }
2733
2734
2735 XS(_wrap_ZebraTransactionStatus_deleted_set) {
2736     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2737     const char *_swigerr = _swigmsg;
2738     {
2739         ZebraTransactionStatus *arg1 ;
2740         int arg2 ;
2741         int argvi = 0;
2742         dXSARGS;
2743
2744         if ((items < 2) || (items > 2)) {
2745             SWIG_croak("Usage: ZebraTransactionStatus_deleted_set(self,deleted);");
2746         }
2747         {
2748             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2749                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_deleted_set. Expected _p_ZebraTransactionStatus");
2750             }
2751         }
2752         arg2 = (int) SvIV(ST(1));
2753         if (arg1) (arg1)->deleted = arg2;
2754
2755
2756         XSRETURN(argvi);
2757         fail:
2758         (void) _swigerr;
2759     }
2760     croak(_swigerr);
2761 }
2762
2763
2764 XS(_wrap_ZebraTransactionStatus_deleted_get) {
2765     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2766     const char *_swigerr = _swigmsg;
2767     {
2768         ZebraTransactionStatus *arg1 ;
2769         int result;
2770         int argvi = 0;
2771         dXSARGS;
2772
2773         if ((items < 1) || (items > 1)) {
2774             SWIG_croak("Usage: ZebraTransactionStatus_deleted_get(self);");
2775         }
2776         {
2777             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2778                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_deleted_get. Expected _p_ZebraTransactionStatus");
2779             }
2780         }
2781         result = (int) ((arg1)->deleted);
2782
2783         ST(argvi) = sv_newmortal();
2784         sv_setiv(ST(argvi++), (IV) result);
2785         XSRETURN(argvi);
2786         fail:
2787         (void) _swigerr;
2788     }
2789     croak(_swigerr);
2790 }
2791
2792
2793 XS(_wrap_ZebraTransactionStatus_utime_set) {
2794     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2795     const char *_swigerr = _swigmsg;
2796     {
2797         ZebraTransactionStatus *arg1 ;
2798         long arg2 ;
2799         int argvi = 0;
2800         dXSARGS;
2801
2802         if ((items < 2) || (items > 2)) {
2803             SWIG_croak("Usage: ZebraTransactionStatus_utime_set(self,utime);");
2804         }
2805         {
2806             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2807                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_utime_set. Expected _p_ZebraTransactionStatus");
2808             }
2809         }
2810         arg2 = (long) SvIV(ST(1));
2811         if (arg1) (arg1)->utime = arg2;
2812
2813
2814         XSRETURN(argvi);
2815         fail:
2816         (void) _swigerr;
2817     }
2818     croak(_swigerr);
2819 }
2820
2821
2822 XS(_wrap_ZebraTransactionStatus_utime_get) {
2823     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2824     const char *_swigerr = _swigmsg;
2825     {
2826         ZebraTransactionStatus *arg1 ;
2827         long result;
2828         int argvi = 0;
2829         dXSARGS;
2830
2831         if ((items < 1) || (items > 1)) {
2832             SWIG_croak("Usage: ZebraTransactionStatus_utime_get(self);");
2833         }
2834         {
2835             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2836                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_utime_get. Expected _p_ZebraTransactionStatus");
2837             }
2838         }
2839         result = (long) ((arg1)->utime);
2840
2841         ST(argvi) = sv_newmortal();
2842         sv_setiv(ST(argvi++), (IV) result);
2843         XSRETURN(argvi);
2844         fail:
2845         (void) _swigerr;
2846     }
2847     croak(_swigerr);
2848 }
2849
2850
2851 XS(_wrap_ZebraTransactionStatus_stime_set) {
2852     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2853     const char *_swigerr = _swigmsg;
2854     {
2855         ZebraTransactionStatus *arg1 ;
2856         long arg2 ;
2857         int argvi = 0;
2858         dXSARGS;
2859
2860         if ((items < 2) || (items > 2)) {
2861             SWIG_croak("Usage: ZebraTransactionStatus_stime_set(self,stime);");
2862         }
2863         {
2864             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2865                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_stime_set. Expected _p_ZebraTransactionStatus");
2866             }
2867         }
2868         arg2 = (long) SvIV(ST(1));
2869         if (arg1) (arg1)->stime = arg2;
2870
2871
2872         XSRETURN(argvi);
2873         fail:
2874         (void) _swigerr;
2875     }
2876     croak(_swigerr);
2877 }
2878
2879
2880 XS(_wrap_ZebraTransactionStatus_stime_get) {
2881     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2882     const char *_swigerr = _swigmsg;
2883     {
2884         ZebraTransactionStatus *arg1 ;
2885         long result;
2886         int argvi = 0;
2887         dXSARGS;
2888
2889         if ((items < 1) || (items > 1)) {
2890             SWIG_croak("Usage: ZebraTransactionStatus_stime_get(self);");
2891         }
2892         {
2893             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2894                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_stime_get. Expected _p_ZebraTransactionStatus");
2895             }
2896         }
2897         result = (long) ((arg1)->stime);
2898
2899         ST(argvi) = sv_newmortal();
2900         sv_setiv(ST(argvi++), (IV) result);
2901         XSRETURN(argvi);
2902         fail:
2903         (void) _swigerr;
2904     }
2905     croak(_swigerr);
2906 }
2907
2908
2909 XS(_wrap_new_ZebraTransactionStatus) {
2910     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2911     const char *_swigerr = _swigmsg;
2912     {
2913         ZebraTransactionStatus *result;
2914         int argvi = 0;
2915         dXSARGS;
2916
2917         if ((items < 0) || (items > 0)) {
2918             SWIG_croak("Usage: new_ZebraTransactionStatus();");
2919         }
2920         result = (ZebraTransactionStatus *)(ZebraTransactionStatus *) calloc(1, sizeof(ZebraTransactionStatus));
2921
2922         ST(argvi) = sv_newmortal();
2923         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ZebraTransactionStatus,0);
2924         XSRETURN(argvi);
2925         fail:
2926         (void) _swigerr;
2927     }
2928     croak(_swigerr);
2929 }
2930
2931
2932 XS(_wrap_delete_ZebraTransactionStatus) {
2933     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2934     const char *_swigerr = _swigmsg;
2935     {
2936         ZebraTransactionStatus *arg1 ;
2937         int argvi = 0;
2938         dXSARGS;
2939
2940         if ((items < 1) || (items > 1)) {
2941             SWIG_croak("Usage: delete_ZebraTransactionStatus(self);");
2942         }
2943         {
2944             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2945                 SWIG_croak("Type error in argument 1 of delete_ZebraTransactionStatus. Expected _p_ZebraTransactionStatus");
2946             }
2947         }
2948         free((char *) arg1);
2949
2950
2951         XSRETURN(argvi);
2952         fail:
2953         (void) _swigerr;
2954     }
2955     croak(_swigerr);
2956 }
2957
2958
2959 XS(_wrap_init__SWIG_0) {
2960     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2961     const char *_swigerr = _swigmsg;
2962     {
2963         int argvi = 0;
2964         dXSARGS;
2965
2966         if ((items < 0) || (items > 0)) {
2967             SWIG_croak("Usage: init();");
2968         }
2969         init();
2970
2971
2972         XSRETURN(argvi);
2973         fail:
2974         (void) _swigerr;
2975     }
2976     croak(_swigerr);
2977 }
2978
2979
2980 XS(_wrap_DESTROY) {
2981     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2982     const char *_swigerr = _swigmsg;
2983     {
2984         int argvi = 0;
2985         dXSARGS;
2986
2987         if ((items < 0) || (items > 0)) {
2988             SWIG_croak("Usage: DESTROY();");
2989         }
2990         DESTROY();
2991
2992
2993         XSRETURN(argvi);
2994         fail:
2995         (void) _swigerr;
2996     }
2997     croak(_swigerr);
2998 }
2999
3000
3001 XS(_wrap_logLevel) {
3002     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3003     const char *_swigerr = _swigmsg;
3004     {
3005         int arg1 ;
3006         int argvi = 0;
3007         dXSARGS;
3008
3009         if ((items < 1) || (items > 1)) {
3010             SWIG_croak("Usage: logLevel(level);");
3011         }
3012         arg1 = (int) SvIV(ST(0));
3013         logLevel(arg1);
3014
3015
3016         XSRETURN(argvi);
3017         fail:
3018         (void) _swigerr;
3019     }
3020     croak(_swigerr);
3021 }
3022
3023
3024 XS(_wrap_logFile) {
3025     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3026     const char *_swigerr = _swigmsg;
3027     {
3028         char *arg1 ;
3029         int argvi = 0;
3030         dXSARGS;
3031
3032         if ((items < 1) || (items > 1)) {
3033             SWIG_croak("Usage: logFile(fname);");
3034         }
3035         if (!SvOK((SV*) ST(0))) arg1 = 0;
3036         else arg1 = (char *) SvPV(ST(0), PL_na);
3037         logFile((char const *)arg1);
3038
3039
3040         XSRETURN(argvi);
3041         fail:
3042         (void) _swigerr;
3043     }
3044     croak(_swigerr);
3045 }
3046
3047
3048 XS(_wrap_logMsg) {
3049     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3050     const char *_swigerr = _swigmsg;
3051     {
3052         int arg1 ;
3053         char *arg2 ;
3054         int argvi = 0;
3055         dXSARGS;
3056
3057         if ((items < 2) || (items > 2)) {
3058             SWIG_croak("Usage: logMsg(level,message);");
3059         }
3060         arg1 = (int) SvIV(ST(0));
3061         if (!SvOK((SV*) ST(1))) arg2 = 0;
3062         else arg2 = (char *) SvPV(ST(1), PL_na);
3063         logMsg(arg1,(char const *)arg2);
3064
3065
3066         XSRETURN(argvi);
3067         fail:
3068         (void) _swigerr;
3069     }
3070     croak(_swigerr);
3071 }
3072
3073
3074 XS(_wrap_odr_createmem) {
3075     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3076     const char *_swigerr = _swigmsg;
3077     {
3078         int arg1 ;
3079         ODR result;
3080         int argvi = 0;
3081         dXSARGS;
3082
3083         if ((items < 1) || (items > 1)) {
3084             SWIG_croak("Usage: odr_createmem(direction);");
3085         }
3086         arg1 = (int) SvIV(ST(0));
3087         result = odr_createmem(arg1);
3088
3089         {
3090             ODR * resultobj = (ODR *) malloc(sizeof(ODR));
3091             memmove(resultobj, &result, sizeof(ODR));
3092             ST(argvi) = sv_newmortal();
3093             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ODR,0);
3094         }
3095         XSRETURN(argvi);
3096         fail:
3097         (void) _swigerr;
3098     }
3099     croak(_swigerr);
3100 }
3101
3102
3103 XS(_wrap_odr_reset) {
3104     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3105     const char *_swigerr = _swigmsg;
3106     {
3107         ODR arg1 ;
3108         int argvi = 0;
3109         dXSARGS;
3110
3111         if ((items < 1) || (items > 1)) {
3112             SWIG_croak("Usage: odr_reset(o);");
3113         }
3114         {
3115             ODR * argp;
3116             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
3117                 SWIG_croak("Type error in argument 1 of odr_reset. Expected _p_ODR");
3118             }
3119             arg1 = *argp;
3120         }
3121         odr_reset(arg1);
3122
3123
3124         XSRETURN(argvi);
3125         fail:
3126         (void) _swigerr;
3127     }
3128     croak(_swigerr);
3129 }
3130
3131
3132 XS(_wrap_odr_destroy) {
3133     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3134     const char *_swigerr = _swigmsg;
3135     {
3136         ODR arg1 ;
3137         int argvi = 0;
3138         dXSARGS;
3139
3140         if ((items < 1) || (items > 1)) {
3141             SWIG_croak("Usage: odr_destroy(o);");
3142         }
3143         {
3144             ODR * argp;
3145             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
3146                 SWIG_croak("Type error in argument 1 of odr_destroy. Expected _p_ODR");
3147             }
3148             arg1 = *argp;
3149         }
3150         odr_destroy(arg1);
3151
3152
3153         XSRETURN(argvi);
3154         fail:
3155         (void) _swigerr;
3156     }
3157     croak(_swigerr);
3158 }
3159
3160
3161 XS(_wrap_odr_malloc) {
3162     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3163     const char *_swigerr = _swigmsg;
3164     {
3165         ODR arg1 ;
3166         int arg2 ;
3167         void *result;
3168         int argvi = 0;
3169         dXSARGS;
3170
3171         if ((items < 2) || (items > 2)) {
3172             SWIG_croak("Usage: odr_malloc(o,size);");
3173         }
3174         {
3175             ODR * argp;
3176             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
3177                 SWIG_croak("Type error in argument 1 of odr_malloc. Expected _p_ODR");
3178             }
3179             arg1 = *argp;
3180         }
3181         arg2 = (int) SvIV(ST(1));
3182         result = (void *)odr_malloc(arg1,arg2);
3183
3184         ST(argvi) = sv_newmortal();
3185         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_void,0);
3186         XSRETURN(argvi);
3187         fail:
3188         (void) _swigerr;
3189     }
3190     croak(_swigerr);
3191 }
3192
3193
3194 XS(_wrap_start) {
3195     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3196     const char *_swigerr = _swigmsg;
3197     {
3198         char *arg1 ;
3199         ZebraService result;
3200         int argvi = 0;
3201         dXSARGS;
3202
3203         if ((items < 1) || (items > 1)) {
3204             SWIG_croak("Usage: start(configName);");
3205         }
3206         if (!SvOK((SV*) ST(0))) arg1 = 0;
3207         else arg1 = (char *) SvPV(ST(0), PL_na);
3208         result = zebra_start((char const *)arg1);
3209
3210         {
3211             ZebraService * resultobj = (ZebraService *) malloc(sizeof(ZebraService));
3212             memmove(resultobj, &result, sizeof(ZebraService));
3213             ST(argvi) = sv_newmortal();
3214             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ZebraService,0);
3215         }
3216         XSRETURN(argvi);
3217         fail:
3218         (void) _swigerr;
3219     }
3220     croak(_swigerr);
3221 }
3222
3223
3224 XS(_wrap_open) {
3225     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3226     const char *_swigerr = _swigmsg;
3227     {
3228         ZebraService arg1 ;
3229         ZebraHandle result;
3230         int argvi = 0;
3231         dXSARGS;
3232
3233         if ((items < 1) || (items > 1)) {
3234             SWIG_croak("Usage: open(zs);");
3235         }
3236         {
3237             ZebraService * argp;
3238             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraService,0) < 0) {
3239                 SWIG_croak("Type error in argument 1 of open. Expected _p_ZebraService");
3240             }
3241             arg1 = *argp;
3242         }
3243         result = zebra_open(arg1);
3244
3245         {
3246             ZebraHandle * resultobj = (ZebraHandle *) malloc(sizeof(ZebraHandle));
3247             memmove(resultobj, &result, sizeof(ZebraHandle));
3248             ST(argvi) = sv_newmortal();
3249             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ZebraHandle,0);
3250         }
3251         XSRETURN(argvi);
3252         fail:
3253         (void) _swigerr;
3254     }
3255     croak(_swigerr);
3256 }
3257
3258
3259 XS(_wrap_close) {
3260     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3261     const char *_swigerr = _swigmsg;
3262     {
3263         ZebraHandle arg1 ;
3264         int argvi = 0;
3265         dXSARGS;
3266
3267         if ((items < 1) || (items > 1)) {
3268             SWIG_croak("Usage: close(zh);");
3269         }
3270         {
3271             ZebraHandle * argp;
3272             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3273                 SWIG_croak("Type error in argument 1 of close. Expected _p_ZebraHandle");
3274             }
3275             arg1 = *argp;
3276         }
3277         zebra_close(arg1);
3278
3279
3280         XSRETURN(argvi);
3281         fail:
3282         (void) _swigerr;
3283     }
3284     croak(_swigerr);
3285 }
3286
3287
3288 XS(_wrap_stop) {
3289     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3290     const char *_swigerr = _swigmsg;
3291     {
3292         ZebraService arg1 ;
3293         int argvi = 0;
3294         dXSARGS;
3295
3296         if ((items < 1) || (items > 1)) {
3297             SWIG_croak("Usage: stop(zs);");
3298         }
3299         {
3300             ZebraService * argp;
3301             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraService,0) < 0) {
3302                 SWIG_croak("Type error in argument 1 of stop. Expected _p_ZebraService");
3303             }
3304             arg1 = *argp;
3305         }
3306         zebra_stop(arg1);
3307
3308
3309         XSRETURN(argvi);
3310         fail:
3311         (void) _swigerr;
3312     }
3313     croak(_swigerr);
3314 }
3315
3316
3317 XS(_wrap_errCode) {
3318     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3319     const char *_swigerr = _swigmsg;
3320     {
3321         ZebraHandle arg1 ;
3322         int result;
3323         int argvi = 0;
3324         dXSARGS;
3325
3326         if ((items < 1) || (items > 1)) {
3327             SWIG_croak("Usage: errCode(zh);");
3328         }
3329         {
3330             ZebraHandle * argp;
3331             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3332                 SWIG_croak("Type error in argument 1 of errCode. Expected _p_ZebraHandle");
3333             }
3334             arg1 = *argp;
3335         }
3336         result = (int)zebra_errCode(arg1);
3337
3338         ST(argvi) = sv_newmortal();
3339         sv_setiv(ST(argvi++), (IV) result);
3340         XSRETURN(argvi);
3341         fail:
3342         (void) _swigerr;
3343     }
3344     croak(_swigerr);
3345 }
3346
3347
3348 XS(_wrap_errString) {
3349     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3350     const char *_swigerr = _swigmsg;
3351     {
3352         ZebraHandle arg1 ;
3353         char *result;
3354         int argvi = 0;
3355         dXSARGS;
3356
3357         if ((items < 1) || (items > 1)) {
3358             SWIG_croak("Usage: errString(zh);");
3359         }
3360         {
3361             ZebraHandle * argp;
3362             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3363                 SWIG_croak("Type error in argument 1 of errString. Expected _p_ZebraHandle");
3364             }
3365             arg1 = *argp;
3366         }
3367         result = (char *)zebra_errString(arg1);
3368
3369         ST(argvi) = sv_newmortal();
3370         if (result) {
3371             sv_setpv((SV*)ST(argvi++), (char *) result);
3372         }else {
3373             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
3374         }
3375         XSRETURN(argvi);
3376         fail:
3377         (void) _swigerr;
3378     }
3379     croak(_swigerr);
3380 }
3381
3382
3383 XS(_wrap_errAdd) {
3384     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3385     const char *_swigerr = _swigmsg;
3386     {
3387         ZebraHandle arg1 ;
3388         char *result;
3389         int argvi = 0;
3390         dXSARGS;
3391
3392         if ((items < 1) || (items > 1)) {
3393             SWIG_croak("Usage: errAdd(zh);");
3394         }
3395         {
3396             ZebraHandle * argp;
3397             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3398                 SWIG_croak("Type error in argument 1 of errAdd. Expected _p_ZebraHandle");
3399             }
3400             arg1 = *argp;
3401         }
3402         result = (char *)zebra_errAdd(arg1);
3403
3404         ST(argvi) = sv_newmortal();
3405         if (result) {
3406             sv_setpv((SV*)ST(argvi++), (char *) result);
3407         }else {
3408             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
3409         }
3410         XSRETURN(argvi);
3411         fail:
3412         (void) _swigerr;
3413     }
3414     croak(_swigerr);
3415 }
3416
3417
3418 XS(_wrap_init_recordGroup) {
3419     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3420     const char *_swigerr = _swigmsg;
3421     {
3422         recordGroup *arg1 ;
3423         int argvi = 0;
3424         dXSARGS;
3425
3426         if ((items < 1) || (items > 1)) {
3427             SWIG_croak("Usage: init_recordGroup(rg);");
3428         }
3429         {
3430             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
3431                 SWIG_croak("Type error in argument 1 of init_recordGroup. Expected _p_recordGroup");
3432             }
3433         }
3434         init_recordGroup(arg1);
3435
3436
3437         XSRETURN(argvi);
3438         fail:
3439         (void) _swigerr;
3440     }
3441     croak(_swigerr);
3442 }
3443
3444
3445 XS(_wrap_res_get_recordGroup) {
3446     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3447     const char *_swigerr = _swigmsg;
3448     {
3449         ZebraHandle arg1 ;
3450         recordGroup *arg2 ;
3451         char *arg3 ;
3452         int argvi = 0;
3453         dXSARGS;
3454
3455         if ((items < 3) || (items > 3)) {
3456             SWIG_croak("Usage: res_get_recordGroup(zh,rg,ext);");
3457         }
3458         {
3459             ZebraHandle * argp;
3460             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3461                 SWIG_croak("Type error in argument 1 of res_get_recordGroup. Expected _p_ZebraHandle");
3462             }
3463             arg1 = *argp;
3464         }
3465         {
3466             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) {
3467                 SWIG_croak("Type error in argument 2 of res_get_recordGroup. Expected _p_recordGroup");
3468             }
3469         }
3470         if (!SvOK((SV*) ST(2))) arg3 = 0;
3471         else arg3 = (char *) SvPV(ST(2), PL_na);
3472         res_get_recordGroup(arg1,arg2,(char const *)arg3);
3473
3474
3475         XSRETURN(argvi);
3476         fail:
3477         (void) _swigerr;
3478     }
3479     croak(_swigerr);
3480 }
3481
3482
3483 XS(_wrap_set_group) {
3484     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3485     const char *_swigerr = _swigmsg;
3486     {
3487         ZebraHandle arg1 ;
3488         struct recordGroup *arg2 ;
3489         int argvi = 0;
3490         dXSARGS;
3491
3492         if ((items < 2) || (items > 2)) {
3493             SWIG_croak("Usage: set_group(zh,rg);");
3494         }
3495         {
3496             ZebraHandle * argp;
3497             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3498                 SWIG_croak("Type error in argument 1 of set_group. Expected _p_ZebraHandle");
3499             }
3500             arg1 = *argp;
3501         }
3502         {
3503             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) {
3504                 SWIG_croak("Type error in argument 2 of set_group. Expected _p_recordGroup");
3505             }
3506         }
3507         zebra_set_group(arg1,arg2);
3508
3509
3510         XSRETURN(argvi);
3511         fail:
3512         (void) _swigerr;
3513     }
3514     croak(_swigerr);
3515 }
3516
3517
3518 XS(_wrap_select_database) {
3519     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3520     const char *_swigerr = _swigmsg;
3521     {
3522         ZebraHandle arg1 ;
3523         char *arg2 ;
3524         int result;
3525         int argvi = 0;
3526         dXSARGS;
3527
3528         if ((items < 2) || (items > 2)) {
3529             SWIG_croak("Usage: select_database(zh,basename);");
3530         }
3531         {
3532             ZebraHandle * argp;
3533             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3534                 SWIG_croak("Type error in argument 1 of select_database. Expected _p_ZebraHandle");
3535             }
3536             arg1 = *argp;
3537         }
3538         if (!SvOK((SV*) ST(1))) arg2 = 0;
3539         else arg2 = (char *) SvPV(ST(1), PL_na);
3540         result = (int)zebra_select_database(arg1,(char const *)arg2);
3541
3542         ST(argvi) = sv_newmortal();
3543         sv_setiv(ST(argvi++), (IV) result);
3544         XSRETURN(argvi);
3545         fail:
3546         (void) _swigerr;
3547     }
3548     croak(_swigerr);
3549 }
3550
3551
3552 XS(_wrap_select_databases) {
3553     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3554     const char *_swigerr = _swigmsg;
3555     {
3556         ZebraHandle arg1 ;
3557         int arg2 ;
3558         char **arg3 ;
3559         int result;
3560         int argvi = 0;
3561         dXSARGS;
3562
3563         if ((items < 3) || (items > 3)) {
3564             SWIG_croak("Usage: select_databases(zh,num_bases,basenames);");
3565         }
3566         {
3567             ZebraHandle * argp;
3568             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3569                 SWIG_croak("Type error in argument 1 of select_databases. Expected _p_ZebraHandle");
3570             }
3571             arg1 = *argp;
3572         }
3573         arg2 = (int) SvIV(ST(1));
3574         {
3575             AV *tempav;
3576             I32 len;
3577             int i;
3578             SV  **tv;
3579             STRLEN na;
3580             if (!SvROK(ST(2)))
3581             croak("Argument 3 is not a reference.");
3582             if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
3583             croak("Argument 3 is not an array.");
3584             tempav = (AV*)SvRV(ST(2));
3585             len = av_len(tempav);
3586             arg3 = (char **) malloc((len+2)*sizeof(char *));
3587             for (i = 0; i <= len; i++) {
3588                 tv = av_fetch(tempav, i, 0);
3589                 arg3[i] = (char *) SvPV(*tv,na);
3590             }
3591             arg3[i] = NULL;
3592         }
3593         result = (int)zebra_select_databases(arg1,arg2,(char const **)arg3);
3594
3595         ST(argvi) = sv_newmortal();
3596         sv_setiv(ST(argvi++), (IV) result);
3597         {
3598             free(arg3);
3599         }
3600         XSRETURN(argvi);
3601         fail:
3602         {
3603             free(arg3);
3604         }
3605         (void) _swigerr;
3606     }
3607     croak(_swigerr);
3608 }
3609
3610
3611 XS(_wrap_begin_trans) {
3612     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3613     const char *_swigerr = _swigmsg;
3614     {
3615         ZebraHandle arg1 ;
3616         int argvi = 0;
3617         dXSARGS;
3618
3619         if ((items < 1) || (items > 1)) {
3620             SWIG_croak("Usage: begin_trans(zh);");
3621         }
3622         {
3623             ZebraHandle * argp;
3624             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3625                 SWIG_croak("Type error in argument 1 of begin_trans. Expected _p_ZebraHandle");
3626             }
3627             arg1 = *argp;
3628         }
3629         zebra_begin_trans(arg1);
3630
3631
3632         XSRETURN(argvi);
3633         fail:
3634         (void) _swigerr;
3635     }
3636     croak(_swigerr);
3637 }
3638
3639
3640 XS(_wrap_end_trans) {
3641     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3642     const char *_swigerr = _swigmsg;
3643     {
3644         ZebraHandle arg1 ;
3645         ZebraTransactionStatus *arg2 ;
3646         int argvi = 0;
3647         dXSARGS;
3648
3649         if ((items < 2) || (items > 2)) {
3650             SWIG_croak("Usage: end_trans(zh,stat);");
3651         }
3652         {
3653             ZebraHandle * argp;
3654             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3655                 SWIG_croak("Type error in argument 1 of end_trans. Expected _p_ZebraHandle");
3656             }
3657             arg1 = *argp;
3658         }
3659         {
3660             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
3661                 SWIG_croak("Type error in argument 2 of end_trans. Expected _p_ZebraTransactionStatus");
3662             }
3663         }
3664         zebra_end_transaction(arg1,arg2);
3665
3666
3667         XSRETURN(argvi);
3668         fail:
3669         (void) _swigerr;
3670     }
3671     croak(_swigerr);
3672 }
3673
3674
3675 XS(_wrap_trans_no) {
3676     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3677     const char *_swigerr = _swigmsg;
3678     {
3679         ZebraHandle arg1 ;
3680         int result;
3681         int argvi = 0;
3682         dXSARGS;
3683
3684         if ((items < 1) || (items > 1)) {
3685             SWIG_croak("Usage: trans_no(zh);");
3686         }
3687         {
3688             ZebraHandle * argp;
3689             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3690                 SWIG_croak("Type error in argument 1 of trans_no. Expected _p_ZebraHandle");
3691             }
3692             arg1 = *argp;
3693         }
3694         result = (int)zebra_trans_no(arg1);
3695
3696         ST(argvi) = sv_newmortal();
3697         sv_setiv(ST(argvi++), (IV) result);
3698         XSRETURN(argvi);
3699         fail:
3700         (void) _swigerr;
3701     }
3702     croak(_swigerr);
3703 }
3704
3705
3706 XS(_wrap_begin_read) {
3707     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3708     const char *_swigerr = _swigmsg;
3709     {
3710         ZebraHandle arg1 ;
3711         int result;
3712         int argvi = 0;
3713         dXSARGS;
3714
3715         if ((items < 1) || (items > 1)) {
3716             SWIG_croak("Usage: begin_read(zh);");
3717         }
3718         {
3719             ZebraHandle * argp;
3720             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3721                 SWIG_croak("Type error in argument 1 of begin_read. Expected _p_ZebraHandle");
3722             }
3723             arg1 = *argp;
3724         }
3725         result = (int)zebra_begin_read(arg1);
3726
3727         ST(argvi) = sv_newmortal();
3728         sv_setiv(ST(argvi++), (IV) result);
3729         XSRETURN(argvi);
3730         fail:
3731         (void) _swigerr;
3732     }
3733     croak(_swigerr);
3734 }
3735
3736
3737 XS(_wrap_end_read) {
3738     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3739     const char *_swigerr = _swigmsg;
3740     {
3741         ZebraHandle arg1 ;
3742         int argvi = 0;
3743         dXSARGS;
3744
3745         if ((items < 1) || (items > 1)) {
3746             SWIG_croak("Usage: end_read(zh);");
3747         }
3748         {
3749             ZebraHandle * argp;
3750             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3751                 SWIG_croak("Type error in argument 1 of end_read. Expected _p_ZebraHandle");
3752             }
3753             arg1 = *argp;
3754         }
3755         zebra_end_read(arg1);
3756
3757
3758         XSRETURN(argvi);
3759         fail:
3760         (void) _swigerr;
3761     }
3762     croak(_swigerr);
3763 }
3764
3765
3766 XS(_wrap_commit) {
3767     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3768     const char *_swigerr = _swigmsg;
3769     {
3770         ZebraHandle arg1 ;
3771         int result;
3772         int argvi = 0;
3773         dXSARGS;
3774
3775         if ((items < 1) || (items > 1)) {
3776             SWIG_croak("Usage: commit(zh);");
3777         }
3778         {
3779             ZebraHandle * argp;
3780             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3781                 SWIG_croak("Type error in argument 1 of commit. Expected _p_ZebraHandle");
3782             }
3783             arg1 = *argp;
3784         }
3785         result = (int)zebra_commit(arg1);
3786
3787         ST(argvi) = sv_newmortal();
3788         sv_setiv(ST(argvi++), (IV) result);
3789         XSRETURN(argvi);
3790         fail:
3791         (void) _swigerr;
3792     }
3793     croak(_swigerr);
3794 }
3795
3796
3797 XS(_wrap_get_shadow_enable) {
3798     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3799     const char *_swigerr = _swigmsg;
3800     {
3801         ZebraHandle arg1 ;
3802         int result;
3803         int argvi = 0;
3804         dXSARGS;
3805
3806         if ((items < 1) || (items > 1)) {
3807             SWIG_croak("Usage: get_shadow_enable(zh);");
3808         }
3809         {
3810             ZebraHandle * argp;
3811             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3812                 SWIG_croak("Type error in argument 1 of get_shadow_enable. Expected _p_ZebraHandle");
3813             }
3814             arg1 = *argp;
3815         }
3816         result = (int)zebra_get_shadow_enable(arg1);
3817
3818         ST(argvi) = sv_newmortal();
3819         sv_setiv(ST(argvi++), (IV) result);
3820         XSRETURN(argvi);
3821         fail:
3822         (void) _swigerr;
3823     }
3824     croak(_swigerr);
3825 }
3826
3827
3828 XS(_wrap_set_shadow_enable) {
3829     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3830     const char *_swigerr = _swigmsg;
3831     {
3832         ZebraHandle arg1 ;
3833         int arg2 ;
3834         int argvi = 0;
3835         dXSARGS;
3836
3837         if ((items < 2) || (items > 2)) {
3838             SWIG_croak("Usage: set_shadow_enable(zh,value);");
3839         }
3840         {
3841             ZebraHandle * argp;
3842             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3843                 SWIG_croak("Type error in argument 1 of set_shadow_enable. Expected _p_ZebraHandle");
3844             }
3845             arg1 = *argp;
3846         }
3847         arg2 = (int) SvIV(ST(1));
3848         zebra_set_shadow_enable(arg1,arg2);
3849
3850
3851         XSRETURN(argvi);
3852         fail:
3853         (void) _swigerr;
3854     }
3855     croak(_swigerr);
3856 }
3857
3858
3859 XS(_wrap_init__SWIG_1) {
3860     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3861     const char *_swigerr = _swigmsg;
3862     {
3863         ZebraHandle arg1 ;
3864         int result;
3865         int argvi = 0;
3866         dXSARGS;
3867
3868         if ((items < 1) || (items > 1)) {
3869             SWIG_croak("Usage: init(zh);");
3870         }
3871         {
3872             ZebraHandle * argp;
3873             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3874                 SWIG_croak("Type error in argument 1 of init. Expected _p_ZebraHandle");
3875             }
3876             arg1 = *argp;
3877         }
3878         result = (int)zebra_init(arg1);
3879
3880         ST(argvi) = sv_newmortal();
3881         sv_setiv(ST(argvi++), (IV) result);
3882         XSRETURN(argvi);
3883         fail:
3884         (void) _swigerr;
3885     }
3886     croak(_swigerr);
3887 }
3888
3889
3890 XS(_wrap_init) {
3891     dXSARGS;
3892
3893     if (items == 0) {
3894         int _v;
3895         (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_init__SWIG_0); return;
3896     }
3897     if (items == 1) {
3898         int _v;
3899         {
3900             void *tmp;
3901             if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_ZebraHandle, 0) == -1) {
3902                 _v = 0;
3903             }else {
3904                 _v = 1;
3905             }
3906         }
3907         if (_v) {
3908             (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_init__SWIG_1); return;
3909         }
3910     }
3911
3912     croak("No matching function for overloaded 'init'");
3913     XSRETURN(0);
3914 }
3915
3916
3917 XS(_wrap_compact) {
3918     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3919     const char *_swigerr = _swigmsg;
3920     {
3921         ZebraHandle arg1 ;
3922         int result;
3923         int argvi = 0;
3924         dXSARGS;
3925
3926         if ((items < 1) || (items > 1)) {
3927             SWIG_croak("Usage: compact(zh);");
3928         }
3929         {
3930             ZebraHandle * argp;
3931             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3932                 SWIG_croak("Type error in argument 1 of compact. Expected _p_ZebraHandle");
3933             }
3934             arg1 = *argp;
3935         }
3936         result = (int)zebra_compact(arg1);
3937
3938         ST(argvi) = sv_newmortal();
3939         sv_setiv(ST(argvi++), (IV) result);
3940         XSRETURN(argvi);
3941         fail:
3942         (void) _swigerr;
3943     }
3944     croak(_swigerr);
3945 }
3946
3947
3948 XS(_wrap_repository_update) {
3949     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3950     const char *_swigerr = _swigmsg;
3951     {
3952         ZebraHandle arg1 ;
3953         int argvi = 0;
3954         dXSARGS;
3955
3956         if ((items < 1) || (items > 1)) {
3957             SWIG_croak("Usage: repository_update(zh);");
3958         }
3959         {
3960             ZebraHandle * argp;
3961             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3962                 SWIG_croak("Type error in argument 1 of repository_update. Expected _p_ZebraHandle");
3963             }
3964             arg1 = *argp;
3965         }
3966         zebra_repository_update(arg1);
3967
3968
3969         XSRETURN(argvi);
3970         fail:
3971         (void) _swigerr;
3972     }
3973     croak(_swigerr);
3974 }
3975
3976
3977 XS(_wrap_repository_delete) {
3978     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3979     const char *_swigerr = _swigmsg;
3980     {
3981         ZebraHandle arg1 ;
3982         int argvi = 0;
3983         dXSARGS;
3984
3985         if ((items < 1) || (items > 1)) {
3986             SWIG_croak("Usage: repository_delete(zh);");
3987         }
3988         {
3989             ZebraHandle * argp;
3990             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3991                 SWIG_croak("Type error in argument 1 of repository_delete. Expected _p_ZebraHandle");
3992             }
3993             arg1 = *argp;
3994         }
3995         zebra_repository_delete(arg1);
3996
3997
3998         XSRETURN(argvi);
3999         fail:
4000         (void) _swigerr;
4001     }
4002     croak(_swigerr);
4003 }
4004
4005
4006 XS(_wrap_repository_show) {
4007     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4008     const char *_swigerr = _swigmsg;
4009     {
4010         ZebraHandle arg1 ;
4011         int argvi = 0;
4012         dXSARGS;
4013
4014         if ((items < 1) || (items > 1)) {
4015             SWIG_croak("Usage: repository_show(zh);");
4016         }
4017         {
4018             ZebraHandle * argp;
4019             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4020                 SWIG_croak("Type error in argument 1 of repository_show. Expected _p_ZebraHandle");
4021             }
4022             arg1 = *argp;
4023         }
4024         zebra_repository_show(arg1);
4025
4026
4027         XSRETURN(argvi);
4028         fail:
4029         (void) _swigerr;
4030     }
4031     croak(_swigerr);
4032 }
4033
4034
4035 XS(_wrap_update_record) {
4036     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4037     const char *_swigerr = _swigmsg;
4038     {
4039         ZebraHandle arg1 ;
4040         recordGroup *arg2 ;
4041         char *arg3 ;
4042         int arg4 ;
4043         char *arg5 ;
4044         char *arg6 ;
4045         char *arg7 ;
4046         int arg8 ;
4047         int result;
4048         int argvi = 0;
4049         dXSARGS;
4050
4051         if ((items < 8) || (items > 8)) {
4052             SWIG_croak("Usage: update_record(zh,rGroup,recordType,sysno,match,fname,buf,buf_size);");
4053         }
4054         {
4055             ZebraHandle * argp;
4056             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4057                 SWIG_croak("Type error in argument 1 of update_record. Expected _p_ZebraHandle");
4058             }
4059             arg1 = *argp;
4060         }
4061         {
4062             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) {
4063                 SWIG_croak("Type error in argument 2 of update_record. Expected _p_recordGroup");
4064             }
4065         }
4066         if (!SvOK((SV*) ST(2))) arg3 = 0;
4067         else arg3 = (char *) SvPV(ST(2), PL_na);
4068         arg4 = (int) SvIV(ST(3));
4069         if (!SvOK((SV*) ST(4))) arg5 = 0;
4070         else arg5 = (char *) SvPV(ST(4), PL_na);
4071         if (!SvOK((SV*) ST(5))) arg6 = 0;
4072         else arg6 = (char *) SvPV(ST(5), PL_na);
4073         if (!SvOK((SV*) ST(6))) arg7 = 0;
4074         else arg7 = (char *) SvPV(ST(6), PL_na);
4075         arg8 = (int) SvIV(ST(7));
4076         result = (int)zebra_update_record(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8);
4077
4078         ST(argvi) = sv_newmortal();
4079         sv_setiv(ST(argvi++), (IV) result);
4080         XSRETURN(argvi);
4081         fail:
4082         (void) _swigerr;
4083     }
4084     croak(_swigerr);
4085 }
4086
4087
4088 XS(_wrap_delete_record) {
4089     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4090     const char *_swigerr = _swigmsg;
4091     {
4092         ZebraHandle arg1 ;
4093         recordGroup *arg2 ;
4094         char *arg3 ;
4095         int arg4 ;
4096         char *arg5 ;
4097         char *arg6 ;
4098         char *arg7 ;
4099         int arg8 ;
4100         int result;
4101         int argvi = 0;
4102         dXSARGS;
4103
4104         if ((items < 8) || (items > 8)) {
4105             SWIG_croak("Usage: delete_record(zh,rGroup,recordType,sysno,match,fname,buf,buf_size);");
4106         }
4107         {
4108             ZebraHandle * argp;
4109             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4110                 SWIG_croak("Type error in argument 1 of delete_record. Expected _p_ZebraHandle");
4111             }
4112             arg1 = *argp;
4113         }
4114         {
4115             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) {
4116                 SWIG_croak("Type error in argument 2 of delete_record. Expected _p_recordGroup");
4117             }
4118         }
4119         if (!SvOK((SV*) ST(2))) arg3 = 0;
4120         else arg3 = (char *) SvPV(ST(2), PL_na);
4121         arg4 = (int) SvIV(ST(3));
4122         if (!SvOK((SV*) ST(4))) arg5 = 0;
4123         else arg5 = (char *) SvPV(ST(4), PL_na);
4124         if (!SvOK((SV*) ST(5))) arg6 = 0;
4125         else arg6 = (char *) SvPV(ST(5), PL_na);
4126         if (!SvOK((SV*) ST(6))) arg7 = 0;
4127         else arg7 = (char *) SvPV(ST(6), PL_na);
4128         arg8 = (int) SvIV(ST(7));
4129         result = (int)zebra_delete_record(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8);
4130
4131         ST(argvi) = sv_newmortal();
4132         sv_setiv(ST(argvi++), (IV) result);
4133         XSRETURN(argvi);
4134         fail:
4135         (void) _swigerr;
4136     }
4137     croak(_swigerr);
4138 }
4139
4140
4141 XS(_wrap_search_PQF) {
4142     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4143     const char *_swigerr = _swigmsg;
4144     {
4145         ZebraHandle arg1 ;
4146         ODR arg2 ;
4147         ODR arg3 ;
4148         char *arg4 ;
4149         char *arg5 ;
4150         int result;
4151         int argvi = 0;
4152         dXSARGS;
4153
4154         if ((items < 5) || (items > 5)) {
4155             SWIG_croak("Usage: search_PQF(zh,odr_input,odr_output,pqf_query,setname);");
4156         }
4157         {
4158             ZebraHandle * argp;
4159             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4160                 SWIG_croak("Type error in argument 1 of search_PQF. Expected _p_ZebraHandle");
4161             }
4162             arg1 = *argp;
4163         }
4164         {
4165             ODR * argp;
4166             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4167                 SWIG_croak("Type error in argument 2 of search_PQF. Expected _p_ODR");
4168             }
4169             arg2 = *argp;
4170         }
4171         {
4172             ODR * argp;
4173             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4174                 SWIG_croak("Type error in argument 3 of search_PQF. Expected _p_ODR");
4175             }
4176             arg3 = *argp;
4177         }
4178         if (!SvOK((SV*) ST(3))) arg4 = 0;
4179         else arg4 = (char *) SvPV(ST(3), PL_na);
4180         if (!SvOK((SV*) ST(4))) arg5 = 0;
4181         else arg5 = (char *) SvPV(ST(4), PL_na);
4182         result = (int)zebra_search_PQF(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5);
4183
4184         ST(argvi) = sv_newmortal();
4185         sv_setiv(ST(argvi++), (IV) result);
4186         XSRETURN(argvi);
4187         fail:
4188         (void) _swigerr;
4189     }
4190     croak(_swigerr);
4191 }
4192
4193
4194 XS(_wrap_cql_transform_open_fname) {
4195     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4196     const char *_swigerr = _swigmsg;
4197     {
4198         char *arg1 ;
4199         cql_transform_t result;
4200         int argvi = 0;
4201         dXSARGS;
4202
4203         if ((items < 1) || (items > 1)) {
4204             SWIG_croak("Usage: cql_transform_open_fname(fname);");
4205         }
4206         if (!SvOK((SV*) ST(0))) arg1 = 0;
4207         else arg1 = (char *) SvPV(ST(0), PL_na);
4208         result = cql_transform_open_fname((char const *)arg1);
4209
4210         {
4211             cql_transform_t * resultobj = (cql_transform_t *) malloc(sizeof(cql_transform_t));
4212             memmove(resultobj, &result, sizeof(cql_transform_t));
4213             ST(argvi) = sv_newmortal();
4214             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_cql_transform_t,0);
4215         }
4216         XSRETURN(argvi);
4217         fail:
4218         (void) _swigerr;
4219     }
4220     croak(_swigerr);
4221 }
4222
4223
4224 XS(_wrap_cql_transform_close) {
4225     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4226     const char *_swigerr = _swigmsg;
4227     {
4228         cql_transform_t arg1 ;
4229         int argvi = 0;
4230         dXSARGS;
4231
4232         if ((items < 1) || (items > 1)) {
4233             SWIG_croak("Usage: cql_transform_close(ct);");
4234         }
4235         {
4236             cql_transform_t * argp;
4237             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_cql_transform_t,0) < 0) {
4238                 SWIG_croak("Type error in argument 1 of cql_transform_close. Expected _p_cql_transform_t");
4239             }
4240             arg1 = *argp;
4241         }
4242         cql_transform_close(arg1);
4243
4244
4245         XSRETURN(argvi);
4246         fail:
4247         (void) _swigerr;
4248     }
4249     croak(_swigerr);
4250 }
4251
4252
4253 XS(_wrap_cql_transform_error) {
4254     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4255     const char *_swigerr = _swigmsg;
4256     {
4257         cql_transform_t arg1 ;
4258         char **arg2 ;
4259         int result;
4260         int argvi = 0;
4261         dXSARGS;
4262
4263         if ((items < 2) || (items > 2)) {
4264             SWIG_croak("Usage: cql_transform_error(ct,addinfo);");
4265         }
4266         {
4267             cql_transform_t * argp;
4268             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_cql_transform_t,0) < 0) {
4269                 SWIG_croak("Type error in argument 1 of cql_transform_error. Expected _p_cql_transform_t");
4270             }
4271             arg1 = *argp;
4272         }
4273         {
4274             AV *tempav;
4275             I32 len;
4276             int i;
4277             SV  **tv;
4278             STRLEN na;
4279             if (!SvROK(ST(1)))
4280             croak("Argument 2 is not a reference.");
4281             if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
4282             croak("Argument 2 is not an array.");
4283             tempav = (AV*)SvRV(ST(1));
4284             len = av_len(tempav);
4285             arg2 = (char **) malloc((len+2)*sizeof(char *));
4286             for (i = 0; i <= len; i++) {
4287                 tv = av_fetch(tempav, i, 0);
4288                 arg2[i] = (char *) SvPV(*tv,na);
4289             }
4290             arg2[i] = NULL;
4291         }
4292         result = (int)cql_transform_error(arg1,(char const **)arg2);
4293
4294         ST(argvi) = sv_newmortal();
4295         sv_setiv(ST(argvi++), (IV) result);
4296         {
4297             free(arg2);
4298         }
4299         XSRETURN(argvi);
4300         fail:
4301         {
4302             free(arg2);
4303         }
4304         (void) _swigerr;
4305     }
4306     croak(_swigerr);
4307 }
4308
4309
4310 XS(_wrap_cql2pqf) {
4311     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4312     const char *_swigerr = _swigmsg;
4313     {
4314         cql_transform_t arg1 ;
4315         char *arg2 ;
4316         char *arg3 ;
4317         int arg4 ;
4318         int result;
4319         int argvi = 0;
4320         dXSARGS;
4321
4322         if ((items < 4) || (items > 4)) {
4323             SWIG_croak("Usage: cql2pqf(ct,query,res,len);");
4324         }
4325         {
4326             cql_transform_t * argp;
4327             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_cql_transform_t,0) < 0) {
4328                 SWIG_croak("Type error in argument 1 of cql2pqf. Expected _p_cql_transform_t");
4329             }
4330             arg1 = *argp;
4331         }
4332         if (!SvOK((SV*) ST(1))) arg2 = 0;
4333         else arg2 = (char *) SvPV(ST(1), PL_na);
4334         if (!SvOK((SV*) ST(2))) arg3 = 0;
4335         else arg3 = (char *) SvPV(ST(2), PL_na);
4336         arg4 = (int) SvIV(ST(3));
4337         result = (int)zebra_cql2pqf(arg1,(char const *)arg2,arg3,arg4);
4338
4339         ST(argvi) = sv_newmortal();
4340         sv_setiv(ST(argvi++), (IV) result);
4341         XSRETURN(argvi);
4342         fail:
4343         (void) _swigerr;
4344     }
4345     croak(_swigerr);
4346 }
4347
4348
4349 XS(_wrap_records_retrieve) {
4350     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4351     const char *_swigerr = _swigmsg;
4352     {
4353         ZebraHandle arg1 ;
4354         ODR arg2 ;
4355         char *arg3 ;
4356         char *arg4 ;
4357         char *arg5 ;
4358         char *arg6 ;
4359         int arg7 ;
4360         int arg8 ;
4361         RetrievalObj *arg9 ;
4362         int argvi = 0;
4363         dXSARGS;
4364
4365         if ((items < 9) || (items > 9)) {
4366             SWIG_croak("Usage: records_retrieve(zh,stream,setname,a_eset,a_schema,a_format,from,to,res);");
4367         }
4368         {
4369             ZebraHandle * argp;
4370             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4371                 SWIG_croak("Type error in argument 1 of records_retrieve. Expected _p_ZebraHandle");
4372             }
4373             arg1 = *argp;
4374         }
4375         {
4376             ODR * argp;
4377             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4378                 SWIG_croak("Type error in argument 2 of records_retrieve. Expected _p_ODR");
4379             }
4380             arg2 = *argp;
4381         }
4382         if (!SvOK((SV*) ST(2))) arg3 = 0;
4383         else arg3 = (char *) SvPV(ST(2), PL_na);
4384         if (!SvOK((SV*) ST(3))) arg4 = 0;
4385         else arg4 = (char *) SvPV(ST(3), PL_na);
4386         if (!SvOK((SV*) ST(4))) arg5 = 0;
4387         else arg5 = (char *) SvPV(ST(4), PL_na);
4388         if (!SvOK((SV*) ST(5))) arg6 = 0;
4389         else arg6 = (char *) SvPV(ST(5), PL_na);
4390         arg7 = (int) SvIV(ST(6));
4391         arg8 = (int) SvIV(ST(7));
4392         {
4393             if (SWIG_ConvertPtr(ST(8), (void **) &arg9, SWIGTYPE_p_RetrievalObj,0) < 0) {
4394                 SWIG_croak("Type error in argument 9 of records_retrieve. Expected _p_RetrievalObj");
4395             }
4396         }
4397         records_retrieve(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,arg9);
4398
4399
4400         XSRETURN(argvi);
4401         fail:
4402         (void) _swigerr;
4403     }
4404     croak(_swigerr);
4405 }
4406
4407
4408 XS(_wrap_record_retrieve) {
4409     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4410     const char *_swigerr = _swigmsg;
4411     {
4412         RetrievalObj *arg1 ;
4413         ODR arg2 ;
4414         RetrievalRecord *arg3 ;
4415         int arg4 ;
4416         int argvi = 0;
4417         dXSARGS;
4418
4419         if ((items < 4) || (items > 4)) {
4420             SWIG_croak("Usage: record_retrieve(ro,stream,res,pos);");
4421         }
4422         {
4423             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalObj,0) < 0) {
4424                 SWIG_croak("Type error in argument 1 of record_retrieve. Expected _p_RetrievalObj");
4425             }
4426         }
4427         {
4428             ODR * argp;
4429             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4430                 SWIG_croak("Type error in argument 2 of record_retrieve. Expected _p_ODR");
4431             }
4432             arg2 = *argp;
4433         }
4434         {
4435             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_RetrievalRecord,0) < 0) {
4436                 SWIG_croak("Type error in argument 3 of record_retrieve. Expected _p_RetrievalRecord");
4437             }
4438         }
4439         arg4 = (int) SvIV(ST(3));
4440         record_retrieve(arg1,arg2,arg3,arg4);
4441
4442
4443         XSRETURN(argvi);
4444         fail:
4445         (void) _swigerr;
4446     }
4447     croak(_swigerr);
4448 }
4449
4450
4451 XS(_wrap_deleteResultSet) {
4452     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4453     const char *_swigerr = _swigmsg;
4454     {
4455         ZebraHandle arg1 ;
4456         int arg2 ;
4457         int arg3 ;
4458         char **arg4 ;
4459         int *arg5 ;
4460         int result;
4461         int argvi = 0;
4462         dXSARGS;
4463
4464         if ((items < 5) || (items > 5)) {
4465             SWIG_croak("Usage: deleteResultSet(zh,function,num_setnames,setnames,statuses);");
4466         }
4467         {
4468             ZebraHandle * argp;
4469             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4470                 SWIG_croak("Type error in argument 1 of deleteResultSet. Expected _p_ZebraHandle");
4471             }
4472             arg1 = *argp;
4473         }
4474         arg2 = (int) SvIV(ST(1));
4475         arg3 = (int) SvIV(ST(2));
4476         {
4477             AV *tempav;
4478             I32 len;
4479             int i;
4480             SV  **tv;
4481             STRLEN na;
4482             if (!SvROK(ST(3)))
4483             croak("Argument 4 is not a reference.");
4484             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
4485             croak("Argument 4 is not an array.");
4486             tempav = (AV*)SvRV(ST(3));
4487             len = av_len(tempav);
4488             arg4 = (char **) malloc((len+2)*sizeof(char *));
4489             for (i = 0; i <= len; i++) {
4490                 tv = av_fetch(tempav, i, 0);
4491                 arg4[i] = (char *) SvPV(*tv,na);
4492             }
4493             arg4[i] = NULL;
4494         }
4495         {
4496             int i;
4497             if (!SvIOK(ST(4)))
4498             croak("Argument 5 is not an integer.");
4499             i = SvIV(ST(4));
4500             arg5 = &i;
4501         }
4502         result = (int)zebra_deleleResultSet(arg1,arg2,arg3,arg4,arg5);
4503
4504         ST(argvi) = sv_newmortal();
4505         sv_setiv(ST(argvi++), (IV) result);
4506         {
4507             free(arg4);
4508         }
4509         XSRETURN(argvi);
4510         fail:
4511         {
4512             free(arg4);
4513         }
4514         (void) _swigerr;
4515     }
4516     croak(_swigerr);
4517 }
4518
4519
4520 XS(_wrap_sort) {
4521     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4522     const char *_swigerr = _swigmsg;
4523     {
4524         ZebraHandle arg1 ;
4525         ODR arg2 ;
4526         char *arg3 ;
4527         char *arg4 ;
4528         char **arg5 ;
4529         int result;
4530         int argvi = 0;
4531         dXSARGS;
4532
4533         if ((items < 5) || (items > 5)) {
4534             SWIG_croak("Usage: sort(zh,stream,sort_spec,output_setname,input_setnames);");
4535         }
4536         {
4537             ZebraHandle * argp;
4538             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4539                 SWIG_croak("Type error in argument 1 of sort. Expected _p_ZebraHandle");
4540             }
4541             arg1 = *argp;
4542         }
4543         {
4544             ODR * argp;
4545             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4546                 SWIG_croak("Type error in argument 2 of sort. Expected _p_ODR");
4547             }
4548             arg2 = *argp;
4549         }
4550         if (!SvOK((SV*) ST(2))) arg3 = 0;
4551         else arg3 = (char *) SvPV(ST(2), PL_na);
4552         if (!SvOK((SV*) ST(3))) arg4 = 0;
4553         else arg4 = (char *) SvPV(ST(3), PL_na);
4554         {
4555             AV *tempav;
4556             I32 len;
4557             int i;
4558             SV  **tv;
4559             STRLEN na;
4560             if (!SvROK(ST(4)))
4561             croak("Argument 5 is not a reference.");
4562             if (SvTYPE(SvRV(ST(4))) != SVt_PVAV)
4563             croak("Argument 5 is not an array.");
4564             tempav = (AV*)SvRV(ST(4));
4565             len = av_len(tempav);
4566             arg5 = (char **) malloc((len+2)*sizeof(char *));
4567             for (i = 0; i <= len; i++) {
4568                 tv = av_fetch(tempav, i, 0);
4569                 arg5[i] = (char *) SvPV(*tv,na);
4570             }
4571             arg5[i] = NULL;
4572         }
4573         result = (int)sort(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const **)arg5);
4574
4575         ST(argvi) = sv_newmortal();
4576         sv_setiv(ST(argvi++), (IV) result);
4577         {
4578             free(arg5);
4579         }
4580         XSRETURN(argvi);
4581         fail:
4582         {
4583             free(arg5);
4584         }
4585         (void) _swigerr;
4586     }
4587     croak(_swigerr);
4588 }
4589
4590
4591 XS(_wrap_scan_PQF) {
4592     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4593     const char *_swigerr = _swigmsg;
4594     {
4595         ZebraHandle arg1 ;
4596         ScanObj *arg2 ;
4597         ODR arg3 ;
4598         char *arg4 ;
4599         int argvi = 0;
4600         dXSARGS;
4601
4602         if ((items < 4) || (items > 4)) {
4603             SWIG_croak("Usage: scan_PQF(zh,so,stream,pqf_query);");
4604         }
4605         {
4606             ZebraHandle * argp;
4607             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4608                 SWIG_croak("Type error in argument 1 of scan_PQF. Expected _p_ZebraHandle");
4609             }
4610             arg1 = *argp;
4611         }
4612         {
4613             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ScanObj,0) < 0) {
4614                 SWIG_croak("Type error in argument 2 of scan_PQF. Expected _p_ScanObj");
4615             }
4616         }
4617         {
4618             ODR * argp;
4619             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4620                 SWIG_croak("Type error in argument 3 of scan_PQF. Expected _p_ODR");
4621             }
4622             arg3 = *argp;
4623         }
4624         if (!SvOK((SV*) ST(3))) arg4 = 0;
4625         else arg4 = (char *) SvPV(ST(3), PL_na);
4626         zebra_scan_PQF(arg1,arg2,arg3,(char const *)arg4);
4627
4628
4629         XSRETURN(argvi);
4630         fail:
4631         (void) _swigerr;
4632     }
4633     croak(_swigerr);
4634 }
4635
4636
4637 XS(_wrap_getScanEntry) {
4638     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4639     const char *_swigerr = _swigmsg;
4640     {
4641         ScanObj *arg1 ;
4642         int arg2 ;
4643         scanEntry *result;
4644         int argvi = 0;
4645         dXSARGS;
4646
4647         if ((items < 2) || (items > 2)) {
4648             SWIG_croak("Usage: getScanEntry(so,pos);");
4649         }
4650         {
4651             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
4652                 SWIG_croak("Type error in argument 1 of getScanEntry. Expected _p_ScanObj");
4653             }
4654         }
4655         arg2 = (int) SvIV(ST(1));
4656         result = (scanEntry *)getScanEntry(arg1,arg2);
4657
4658         ST(argvi) = sv_newmortal();
4659         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_scanEntry,0);
4660         XSRETURN(argvi);
4661         fail:
4662         (void) _swigerr;
4663     }
4664     croak(_swigerr);
4665 }
4666
4667
4668 XS(_wrap_nmem_create) {
4669     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4670     const char *_swigerr = _swigmsg;
4671     {
4672         NMEM result;
4673         int argvi = 0;
4674         dXSARGS;
4675
4676         if ((items < 0) || (items > 0)) {
4677             SWIG_croak("Usage: nmem_create();");
4678         }
4679         result = nmem_create();
4680
4681         {
4682             NMEM * resultobj = (NMEM *) malloc(sizeof(NMEM));
4683             memmove(resultobj, &result, sizeof(NMEM));
4684             ST(argvi) = sv_newmortal();
4685             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_NMEM,0);
4686         }
4687         XSRETURN(argvi);
4688         fail:
4689         (void) _swigerr;
4690     }
4691     croak(_swigerr);
4692 }
4693
4694
4695 XS(_wrap_nmem_destroy) {
4696     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4697     const char *_swigerr = _swigmsg;
4698     {
4699         NMEM arg1 ;
4700         int argvi = 0;
4701         dXSARGS;
4702
4703         if ((items < 1) || (items > 1)) {
4704             SWIG_croak("Usage: nmem_destroy(handle);");
4705         }
4706         {
4707             NMEM * argp;
4708             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
4709                 SWIG_croak("Type error in argument 1 of nmem_destroy. Expected _p_NMEM");
4710             }
4711             arg1 = *argp;
4712         }
4713         nmem_destroy(arg1);
4714
4715
4716         XSRETURN(argvi);
4717         fail:
4718         (void) _swigerr;
4719     }
4720     croak(_swigerr);
4721 }
4722
4723
4724 XS(_wrap_data1_create) {
4725     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4726     const char *_swigerr = _swigmsg;
4727     {
4728         data1_handle result;
4729         int argvi = 0;
4730         dXSARGS;
4731
4732         if ((items < 0) || (items > 0)) {
4733             SWIG_croak("Usage: data1_create();");
4734         }
4735         result = data1_create();
4736
4737         {
4738             data1_handle * resultobj = (data1_handle *) malloc(sizeof(data1_handle));
4739             memmove(resultobj, &result, sizeof(data1_handle));
4740             ST(argvi) = sv_newmortal();
4741             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_data1_handle,0);
4742         }
4743         XSRETURN(argvi);
4744         fail:
4745         (void) _swigerr;
4746     }
4747     croak(_swigerr);
4748 }
4749
4750
4751 XS(_wrap_data1_createx) {
4752     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4753     const char *_swigerr = _swigmsg;
4754     {
4755         int arg1 ;
4756         data1_handle result;
4757         int argvi = 0;
4758         dXSARGS;
4759
4760         if ((items < 1) || (items > 1)) {
4761             SWIG_croak("Usage: data1_createx(flags);");
4762         }
4763         arg1 = (int) SvIV(ST(0));
4764         result = data1_createx(arg1);
4765
4766         {
4767             data1_handle * resultobj = (data1_handle *) malloc(sizeof(data1_handle));
4768             memmove(resultobj, &result, sizeof(data1_handle));
4769             ST(argvi) = sv_newmortal();
4770             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_data1_handle,0);
4771         }
4772         XSRETURN(argvi);
4773         fail:
4774         (void) _swigerr;
4775     }
4776     croak(_swigerr);
4777 }
4778
4779
4780 XS(_wrap_data1_destroy) {
4781     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4782     const char *_swigerr = _swigmsg;
4783     {
4784         data1_handle arg1 ;
4785         int argvi = 0;
4786         dXSARGS;
4787
4788         if ((items < 1) || (items > 1)) {
4789             SWIG_croak("Usage: data1_destroy(dh);");
4790         }
4791         {
4792             data1_handle * argp;
4793             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4794                 SWIG_croak("Type error in argument 1 of data1_destroy. Expected _p_data1_handle");
4795             }
4796             arg1 = *argp;
4797         }
4798         data1_destroy(arg1);
4799
4800
4801         XSRETURN(argvi);
4802         fail:
4803         (void) _swigerr;
4804     }
4805     croak(_swigerr);
4806 }
4807
4808
4809 XS(_wrap_get_parent_tag) {
4810     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4811     const char *_swigerr = _swigmsg;
4812     {
4813         data1_handle arg1 ;
4814         data1_node *arg2 ;
4815         data1_node *result;
4816         int argvi = 0;
4817         dXSARGS;
4818
4819         if ((items < 2) || (items > 2)) {
4820             SWIG_croak("Usage: get_parent_tag(dh,n);");
4821         }
4822         {
4823             data1_handle * argp;
4824             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4825                 SWIG_croak("Type error in argument 1 of get_parent_tag. Expected _p_data1_handle");
4826             }
4827             arg1 = *argp;
4828         }
4829         {
4830             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
4831                 SWIG_croak("Type error in argument 2 of get_parent_tag. Expected _p_data1_node");
4832             }
4833         }
4834         result = (data1_node *)get_parent_tag(arg1,arg2);
4835
4836         ST(argvi) = sv_newmortal();
4837         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
4838         XSRETURN(argvi);
4839         fail:
4840         (void) _swigerr;
4841     }
4842     croak(_swigerr);
4843 }
4844
4845
4846 XS(_wrap_data1_read_node) {
4847     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4848     const char *_swigerr = _swigmsg;
4849     {
4850         data1_handle arg1 ;
4851         char **arg2 ;
4852         NMEM arg3 ;
4853         data1_node *result;
4854         int argvi = 0;
4855         dXSARGS;
4856
4857         if ((items < 3) || (items > 3)) {
4858             SWIG_croak("Usage: data1_read_node(dh,buf,m);");
4859         }
4860         {
4861             data1_handle * argp;
4862             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4863                 SWIG_croak("Type error in argument 1 of data1_read_node. Expected _p_data1_handle");
4864             }
4865             arg1 = *argp;
4866         }
4867         {
4868             AV *tempav;
4869             I32 len;
4870             int i;
4871             SV  **tv;
4872             STRLEN na;
4873             if (!SvROK(ST(1)))
4874             croak("Argument 2 is not a reference.");
4875             if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
4876             croak("Argument 2 is not an array.");
4877             tempav = (AV*)SvRV(ST(1));
4878             len = av_len(tempav);
4879             arg2 = (char **) malloc((len+2)*sizeof(char *));
4880             for (i = 0; i <= len; i++) {
4881                 tv = av_fetch(tempav, i, 0);
4882                 arg2[i] = (char *) SvPV(*tv,na);
4883             }
4884             arg2[i] = NULL;
4885         }
4886         {
4887             NMEM * argp;
4888             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
4889                 SWIG_croak("Type error in argument 3 of data1_read_node. Expected _p_NMEM");
4890             }
4891             arg3 = *argp;
4892         }
4893         result = (data1_node *)data1_read_node(arg1,(char const **)arg2,arg3);
4894
4895         ST(argvi) = sv_newmortal();
4896         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
4897         {
4898             free(arg2);
4899         }
4900         XSRETURN(argvi);
4901         fail:
4902         {
4903             free(arg2);
4904         }
4905         (void) _swigerr;
4906     }
4907     croak(_swigerr);
4908 }
4909
4910
4911 XS(_wrap_data1_read_nodex) {
4912     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4913     const char *_swigerr = _swigmsg;
4914     {
4915         data1_handle arg1 ;
4916         NMEM arg2 ;
4917         int (*arg3)(void *) ;
4918         void *arg4 ;
4919         WRBUF arg5 ;
4920         data1_node *result;
4921         int argvi = 0;
4922         dXSARGS;
4923
4924         if ((items < 5) || (items > 5)) {
4925             SWIG_croak("Usage: data1_read_nodex(dh,m,get_byte,fh,wrbuf);");
4926         }
4927         {
4928             data1_handle * argp;
4929             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4930                 SWIG_croak("Type error in argument 1 of data1_read_nodex. Expected _p_data1_handle");
4931             }
4932             arg1 = *argp;
4933         }
4934         {
4935             NMEM * argp;
4936             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
4937                 SWIG_croak("Type error in argument 2 of data1_read_nodex. Expected _p_NMEM");
4938             }
4939             arg2 = *argp;
4940         }
4941         {
4942             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_f_p_void__int,0) < 0) {
4943                 SWIG_croak("Type error in argument 3 of data1_read_nodex. Expected _p_f_p_void__int");
4944             }
4945         }
4946         {
4947             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, 0,0) < 0) {
4948                 SWIG_croak("Type error in argument 4 of data1_read_nodex. Expected _p_void");
4949             }
4950         }
4951         {
4952             WRBUF * argp;
4953             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_WRBUF,0) < 0) {
4954                 SWIG_croak("Type error in argument 5 of data1_read_nodex. Expected _p_WRBUF");
4955             }
4956             arg5 = *argp;
4957         }
4958         result = (data1_node *)data1_read_nodex(arg1,arg2,arg3,arg4,arg5);
4959
4960         ST(argvi) = sv_newmortal();
4961         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
4962         XSRETURN(argvi);
4963         fail:
4964         (void) _swigerr;
4965     }
4966     croak(_swigerr);
4967 }
4968
4969
4970 XS(_wrap_data1_read_record) {
4971     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4972     const char *_swigerr = _swigmsg;
4973     {
4974         data1_handle arg1 ;
4975         int (*arg2)(void *,char *,size_t) ;
4976         void *arg3 ;
4977         NMEM arg4 ;
4978         data1_node *result;
4979         int argvi = 0;
4980         dXSARGS;
4981
4982         if ((items < 4) || (items > 4)) {
4983             SWIG_croak("Usage: data1_read_record(dh,rf,fh,m);");
4984         }
4985         {
4986             data1_handle * argp;
4987             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4988                 SWIG_croak("Type error in argument 1 of data1_read_record. Expected _p_data1_handle");
4989             }
4990             arg1 = *argp;
4991         }
4992         {
4993             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_f_p_void_p_char_size_t__int,0) < 0) {
4994                 SWIG_croak("Type error in argument 2 of data1_read_record. Expected _p_f_p_void_p_char_size_t__int");
4995             }
4996         }
4997         {
4998             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, 0,0) < 0) {
4999                 SWIG_croak("Type error in argument 3 of data1_read_record. Expected _p_void");
5000             }
5001         }
5002         {
5003             NMEM * argp;
5004             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5005                 SWIG_croak("Type error in argument 4 of data1_read_record. Expected _p_NMEM");
5006             }
5007             arg4 = *argp;
5008         }
5009         result = (data1_node *)data1_read_record(arg1,arg2,arg3,arg4);
5010
5011         ST(argvi) = sv_newmortal();
5012         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5013         XSRETURN(argvi);
5014         fail:
5015         (void) _swigerr;
5016     }
5017     croak(_swigerr);
5018 }
5019
5020
5021 XS(_wrap_data1_read_absyn) {
5022     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5023     const char *_swigerr = _swigmsg;
5024     {
5025         data1_handle arg1 ;
5026         char *arg2 ;
5027         int arg3 ;
5028         data1_absyn *result;
5029         int argvi = 0;
5030         dXSARGS;
5031
5032         if ((items < 3) || (items > 3)) {
5033             SWIG_croak("Usage: data1_read_absyn(dh,file,file_must_exist);");
5034         }
5035         {
5036             data1_handle * argp;
5037             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5038                 SWIG_croak("Type error in argument 1 of data1_read_absyn. Expected _p_data1_handle");
5039             }
5040             arg1 = *argp;
5041         }
5042         if (!SvOK((SV*) ST(1))) arg2 = 0;
5043         else arg2 = (char *) SvPV(ST(1), PL_na);
5044         arg3 = (int) SvIV(ST(2));
5045         result = (data1_absyn *)data1_read_absyn(arg1,(char const *)arg2,arg3);
5046
5047         ST(argvi) = sv_newmortal();
5048         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_absyn,0);
5049         XSRETURN(argvi);
5050         fail:
5051         (void) _swigerr;
5052     }
5053     croak(_swigerr);
5054 }
5055
5056
5057 XS(_wrap_data1_gettagbynum) {
5058     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5059     const char *_swigerr = _swigmsg;
5060     {
5061         data1_handle arg1 ;
5062         data1_tagset *arg2 ;
5063         int arg3 ;
5064         int arg4 ;
5065         data1_tag *result;
5066         int argvi = 0;
5067         dXSARGS;
5068
5069         if ((items < 4) || (items > 4)) {
5070             SWIG_croak("Usage: data1_gettagbynum(dh,s,type,value);");
5071         }
5072         {
5073             data1_handle * argp;
5074             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5075                 SWIG_croak("Type error in argument 1 of data1_gettagbynum. Expected _p_data1_handle");
5076             }
5077             arg1 = *argp;
5078         }
5079         {
5080             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_tagset,0) < 0) {
5081                 SWIG_croak("Type error in argument 2 of data1_gettagbynum. Expected _p_data1_tagset");
5082             }
5083         }
5084         arg3 = (int) SvIV(ST(2));
5085         arg4 = (int) SvIV(ST(3));
5086         result = (data1_tag *)data1_gettagbynum(arg1,arg2,arg3,arg4);
5087
5088         ST(argvi) = sv_newmortal();
5089         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tag,0);
5090         XSRETURN(argvi);
5091         fail:
5092         (void) _swigerr;
5093     }
5094     croak(_swigerr);
5095 }
5096
5097
5098 XS(_wrap_data1_empty_tagset) {
5099     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5100     const char *_swigerr = _swigmsg;
5101     {
5102         data1_handle arg1 ;
5103         data1_tagset *result;
5104         int argvi = 0;
5105         dXSARGS;
5106
5107         if ((items < 1) || (items > 1)) {
5108             SWIG_croak("Usage: data1_empty_tagset(dh);");
5109         }
5110         {
5111             data1_handle * argp;
5112             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5113                 SWIG_croak("Type error in argument 1 of data1_empty_tagset. Expected _p_data1_handle");
5114             }
5115             arg1 = *argp;
5116         }
5117         result = (data1_tagset *)data1_empty_tagset(arg1);
5118
5119         ST(argvi) = sv_newmortal();
5120         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tagset,0);
5121         XSRETURN(argvi);
5122         fail:
5123         (void) _swigerr;
5124     }
5125     croak(_swigerr);
5126 }
5127
5128
5129 XS(_wrap_data1_read_tagset) {
5130     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5131     const char *_swigerr = _swigmsg;
5132     {
5133         data1_handle arg1 ;
5134         char *arg2 ;
5135         int arg3 ;
5136         data1_tagset *result;
5137         int argvi = 0;
5138         dXSARGS;
5139
5140         if ((items < 3) || (items > 3)) {
5141             SWIG_croak("Usage: data1_read_tagset(dh,file,type);");
5142         }
5143         {
5144             data1_handle * argp;
5145             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5146                 SWIG_croak("Type error in argument 1 of data1_read_tagset. Expected _p_data1_handle");
5147             }
5148             arg1 = *argp;
5149         }
5150         if (!SvOK((SV*) ST(1))) arg2 = 0;
5151         else arg2 = (char *) SvPV(ST(1), PL_na);
5152         arg3 = (int) SvIV(ST(2));
5153         result = (data1_tagset *)data1_read_tagset(arg1,(char const *)arg2,arg3);
5154
5155         ST(argvi) = sv_newmortal();
5156         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tagset,0);
5157         XSRETURN(argvi);
5158         fail:
5159         (void) _swigerr;
5160     }
5161     croak(_swigerr);
5162 }
5163
5164
5165 XS(_wrap_data1_getelementbytagname) {
5166     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5167     const char *_swigerr = _swigmsg;
5168     {
5169         data1_handle arg1 ;
5170         data1_absyn *arg2 ;
5171         data1_element *arg3 ;
5172         char *arg4 ;
5173         data1_element *result;
5174         int argvi = 0;
5175         dXSARGS;
5176
5177         if ((items < 4) || (items > 4)) {
5178             SWIG_croak("Usage: data1_getelementbytagname(dh,abs,parent,tagname);");
5179         }
5180         {
5181             data1_handle * argp;
5182             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5183                 SWIG_croak("Type error in argument 1 of data1_getelementbytagname. Expected _p_data1_handle");
5184             }
5185             arg1 = *argp;
5186         }
5187         {
5188             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_absyn,0) < 0) {
5189                 SWIG_croak("Type error in argument 2 of data1_getelementbytagname. Expected _p_data1_absyn");
5190             }
5191         }
5192         {
5193             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_element,0) < 0) {
5194                 SWIG_croak("Type error in argument 3 of data1_getelementbytagname. Expected _p_data1_element");
5195             }
5196         }
5197         if (!SvOK((SV*) ST(3))) arg4 = 0;
5198         else arg4 = (char *) SvPV(ST(3), PL_na);
5199         result = (data1_element *)data1_getelementbytagname(arg1,arg2,arg3,(char const *)arg4);
5200
5201         ST(argvi) = sv_newmortal();
5202         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_element,0);
5203         XSRETURN(argvi);
5204         fail:
5205         (void) _swigerr;
5206     }
5207     croak(_swigerr);
5208 }
5209
5210
5211 XS(_wrap_data1_nodetogr) {
5212     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5213     const char *_swigerr = _swigmsg;
5214     {
5215         data1_handle arg1 ;
5216         data1_node *arg2 ;
5217         int arg3 ;
5218         ODR arg4 ;
5219         int *arg5 ;
5220         Z_GenericRecord *result;
5221         int argvi = 0;
5222         dXSARGS;
5223
5224         if ((items < 5) || (items > 5)) {
5225             SWIG_croak("Usage: data1_nodetogr(dh,n,select,o,len);");
5226         }
5227         {
5228             data1_handle * argp;
5229             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5230                 SWIG_croak("Type error in argument 1 of data1_nodetogr. Expected _p_data1_handle");
5231             }
5232             arg1 = *argp;
5233         }
5234         {
5235             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5236                 SWIG_croak("Type error in argument 2 of data1_nodetogr. Expected _p_data1_node");
5237             }
5238         }
5239         arg3 = (int) SvIV(ST(2));
5240         {
5241             ODR * argp;
5242             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
5243                 SWIG_croak("Type error in argument 4 of data1_nodetogr. Expected _p_ODR");
5244             }
5245             arg4 = *argp;
5246         }
5247         {
5248             int i;
5249             if (!SvIOK(ST(4)))
5250             croak("Argument 5 is not an integer.");
5251             i = SvIV(ST(4));
5252             arg5 = &i;
5253         }
5254         result = (Z_GenericRecord *)data1_nodetogr(arg1,arg2,arg3,arg4,arg5);
5255
5256         ST(argvi) = sv_newmortal();
5257         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_GenericRecord,0);
5258         XSRETURN(argvi);
5259         fail:
5260         (void) _swigerr;
5261     }
5262     croak(_swigerr);
5263 }
5264
5265
5266 XS(_wrap_data1_gettagbyname) {
5267     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5268     const char *_swigerr = _swigmsg;
5269     {
5270         data1_handle arg1 ;
5271         data1_tagset *arg2 ;
5272         char *arg3 ;
5273         data1_tag *result;
5274         int argvi = 0;
5275         dXSARGS;
5276
5277         if ((items < 3) || (items > 3)) {
5278             SWIG_croak("Usage: data1_gettagbyname(dh,s,name);");
5279         }
5280         {
5281             data1_handle * argp;
5282             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5283                 SWIG_croak("Type error in argument 1 of data1_gettagbyname. Expected _p_data1_handle");
5284             }
5285             arg1 = *argp;
5286         }
5287         {
5288             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_tagset,0) < 0) {
5289                 SWIG_croak("Type error in argument 2 of data1_gettagbyname. Expected _p_data1_tagset");
5290             }
5291         }
5292         if (!SvOK((SV*) ST(2))) arg3 = 0;
5293         else arg3 = (char *) SvPV(ST(2), PL_na);
5294         result = (data1_tag *)data1_gettagbyname(arg1,arg2,(char const *)arg3);
5295
5296         ST(argvi) = sv_newmortal();
5297         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tag,0);
5298         XSRETURN(argvi);
5299         fail:
5300         (void) _swigerr;
5301     }
5302     croak(_swigerr);
5303 }
5304
5305
5306 XS(_wrap_data1_free_tree) {
5307     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5308     const char *_swigerr = _swigmsg;
5309     {
5310         data1_handle arg1 ;
5311         data1_node *arg2 ;
5312         int argvi = 0;
5313         dXSARGS;
5314
5315         if ((items < 2) || (items > 2)) {
5316             SWIG_croak("Usage: data1_free_tree(dh,t);");
5317         }
5318         {
5319             data1_handle * argp;
5320             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5321                 SWIG_croak("Type error in argument 1 of data1_free_tree. Expected _p_data1_handle");
5322             }
5323             arg1 = *argp;
5324         }
5325         {
5326             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5327                 SWIG_croak("Type error in argument 2 of data1_free_tree. Expected _p_data1_node");
5328             }
5329         }
5330         data1_free_tree(arg1,arg2);
5331
5332
5333         XSRETURN(argvi);
5334         fail:
5335         (void) _swigerr;
5336     }
5337     croak(_swigerr);
5338 }
5339
5340
5341 XS(_wrap_data1_nodetobuf) {
5342     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5343     const char *_swigerr = _swigmsg;
5344     {
5345         data1_handle arg1 ;
5346         data1_node *arg2 ;
5347         int arg3 ;
5348         int *arg4 ;
5349         char *result;
5350         int argvi = 0;
5351         dXSARGS;
5352
5353         if ((items < 4) || (items > 4)) {
5354             SWIG_croak("Usage: data1_nodetobuf(dh,n,select,len);");
5355         }
5356         {
5357             data1_handle * argp;
5358             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5359                 SWIG_croak("Type error in argument 1 of data1_nodetobuf. Expected _p_data1_handle");
5360             }
5361             arg1 = *argp;
5362         }
5363         {
5364             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5365                 SWIG_croak("Type error in argument 2 of data1_nodetobuf. Expected _p_data1_node");
5366             }
5367         }
5368         arg3 = (int) SvIV(ST(2));
5369         {
5370             int i;
5371             if (!SvIOK(ST(3)))
5372             croak("Argument 4 is not an integer.");
5373             i = SvIV(ST(3));
5374             arg4 = &i;
5375         }
5376         result = (char *)data1_nodetobuf(arg1,arg2,arg3,arg4);
5377
5378         ST(argvi) = sv_newmortal();
5379         if (result) {
5380             sv_setpv((SV*)ST(argvi++), (char *) result);
5381         }else {
5382             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
5383         }
5384         XSRETURN(argvi);
5385         fail:
5386         (void) _swigerr;
5387     }
5388     croak(_swigerr);
5389 }
5390
5391
5392 XS(_wrap_data1_mk_tag_data_wd) {
5393     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5394     const char *_swigerr = _swigmsg;
5395     {
5396         data1_handle arg1 ;
5397         data1_node *arg2 ;
5398         char *arg3 ;
5399         NMEM arg4 ;
5400         data1_node *result;
5401         int argvi = 0;
5402         dXSARGS;
5403
5404         if ((items < 4) || (items > 4)) {
5405             SWIG_croak("Usage: data1_mk_tag_data_wd(dh,at,tagname,m);");
5406         }
5407         {
5408             data1_handle * argp;
5409             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5410                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_wd. Expected _p_data1_handle");
5411             }
5412             arg1 = *argp;
5413         }
5414         {
5415             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5416                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_wd. Expected _p_data1_node");
5417             }
5418         }
5419         if (!SvOK((SV*) ST(2))) arg3 = 0;
5420         else arg3 = (char *) SvPV(ST(2), PL_na);
5421         {
5422             NMEM * argp;
5423             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5424                 SWIG_croak("Type error in argument 4 of data1_mk_tag_data_wd. Expected _p_NMEM");
5425             }
5426             arg4 = *argp;
5427         }
5428         result = (data1_node *)data1_mk_tag_data_wd(arg1,arg2,(char const *)arg3,arg4);
5429
5430         ST(argvi) = sv_newmortal();
5431         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5432         XSRETURN(argvi);
5433         fail:
5434         (void) _swigerr;
5435     }
5436     croak(_swigerr);
5437 }
5438
5439
5440 XS(_wrap_data1_mk_tag_data) {
5441     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5442     const char *_swigerr = _swigmsg;
5443     {
5444         data1_handle arg1 ;
5445         data1_node *arg2 ;
5446         char *arg3 ;
5447         NMEM arg4 ;
5448         data1_node *result;
5449         int argvi = 0;
5450         dXSARGS;
5451
5452         if ((items < 4) || (items > 4)) {
5453             SWIG_croak("Usage: data1_mk_tag_data(dh,at,tagname,m);");
5454         }
5455         {
5456             data1_handle * argp;
5457             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5458                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data. Expected _p_data1_handle");
5459             }
5460             arg1 = *argp;
5461         }
5462         {
5463             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5464                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data. Expected _p_data1_node");
5465             }
5466         }
5467         if (!SvOK((SV*) ST(2))) arg3 = 0;
5468         else arg3 = (char *) SvPV(ST(2), PL_na);
5469         {
5470             NMEM * argp;
5471             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5472                 SWIG_croak("Type error in argument 4 of data1_mk_tag_data. Expected _p_NMEM");
5473             }
5474             arg4 = *argp;
5475         }
5476         result = (data1_node *)data1_mk_tag_data(arg1,arg2,(char const *)arg3,arg4);
5477
5478         ST(argvi) = sv_newmortal();
5479         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5480         XSRETURN(argvi);
5481         fail:
5482         (void) _swigerr;
5483     }
5484     croak(_swigerr);
5485 }
5486
5487
5488 XS(_wrap_data1_maptype) {
5489     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5490     const char *_swigerr = _swigmsg;
5491     {
5492         data1_handle arg1 ;
5493         char *arg2 ;
5494         int result;
5495         int argvi = 0;
5496         dXSARGS;
5497
5498         if ((items < 2) || (items > 2)) {
5499             SWIG_croak("Usage: data1_maptype(dh,t);");
5500         }
5501         {
5502             data1_handle * argp;
5503             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5504                 SWIG_croak("Type error in argument 1 of data1_maptype. Expected _p_data1_handle");
5505             }
5506             arg1 = *argp;
5507         }
5508         if (!SvOK((SV*) ST(1))) arg2 = 0;
5509         else arg2 = (char *) SvPV(ST(1), PL_na);
5510         result = (int)data1_maptype(arg1,arg2);
5511
5512         ST(argvi) = sv_newmortal();
5513         sv_setiv(ST(argvi++), (IV) result);
5514         XSRETURN(argvi);
5515         fail:
5516         (void) _swigerr;
5517     }
5518     croak(_swigerr);
5519 }
5520
5521
5522 XS(_wrap_data1_read_varset) {
5523     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5524     const char *_swigerr = _swigmsg;
5525     {
5526         data1_handle arg1 ;
5527         char *arg2 ;
5528         data1_varset *result;
5529         int argvi = 0;
5530         dXSARGS;
5531
5532         if ((items < 2) || (items > 2)) {
5533             SWIG_croak("Usage: data1_read_varset(dh,file);");
5534         }
5535         {
5536             data1_handle * argp;
5537             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5538                 SWIG_croak("Type error in argument 1 of data1_read_varset. Expected _p_data1_handle");
5539             }
5540             arg1 = *argp;
5541         }
5542         if (!SvOK((SV*) ST(1))) arg2 = 0;
5543         else arg2 = (char *) SvPV(ST(1), PL_na);
5544         result = (data1_varset *)data1_read_varset(arg1,(char const *)arg2);
5545
5546         ST(argvi) = sv_newmortal();
5547         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_varset,0);
5548         XSRETURN(argvi);
5549         fail:
5550         (void) _swigerr;
5551     }
5552     croak(_swigerr);
5553 }
5554
5555
5556 XS(_wrap_data1_getvartypebyct) {
5557     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5558     const char *_swigerr = _swigmsg;
5559     {
5560         data1_handle arg1 ;
5561         data1_varset *arg2 ;
5562         char *arg3 ;
5563         char *arg4 ;
5564         data1_vartype *result;
5565         int argvi = 0;
5566         dXSARGS;
5567
5568         if ((items < 4) || (items > 4)) {
5569             SWIG_croak("Usage: data1_getvartypebyct(dh,set,zclass,type);");
5570         }
5571         {
5572             data1_handle * argp;
5573             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5574                 SWIG_croak("Type error in argument 1 of data1_getvartypebyct. Expected _p_data1_handle");
5575             }
5576             arg1 = *argp;
5577         }
5578         {
5579             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_varset,0) < 0) {
5580                 SWIG_croak("Type error in argument 2 of data1_getvartypebyct. Expected _p_data1_varset");
5581             }
5582         }
5583         if (!SvOK((SV*) ST(2))) arg3 = 0;
5584         else arg3 = (char *) SvPV(ST(2), PL_na);
5585         if (!SvOK((SV*) ST(3))) arg4 = 0;
5586         else arg4 = (char *) SvPV(ST(3), PL_na);
5587         result = (data1_vartype *)data1_getvartypebyct(arg1,arg2,arg3,arg4);
5588
5589         ST(argvi) = sv_newmortal();
5590         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_vartype,0);
5591         XSRETURN(argvi);
5592         fail:
5593         (void) _swigerr;
5594     }
5595     croak(_swigerr);
5596 }
5597
5598
5599 XS(_wrap_data1_read_espec1) {
5600     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5601     const char *_swigerr = _swigmsg;
5602     {
5603         data1_handle arg1 ;
5604         char *arg2 ;
5605         Z_Espec1 *result;
5606         int argvi = 0;
5607         dXSARGS;
5608
5609         if ((items < 2) || (items > 2)) {
5610             SWIG_croak("Usage: data1_read_espec1(dh,file);");
5611         }
5612         {
5613             data1_handle * argp;
5614             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5615                 SWIG_croak("Type error in argument 1 of data1_read_espec1. Expected _p_data1_handle");
5616             }
5617             arg1 = *argp;
5618         }
5619         if (!SvOK((SV*) ST(1))) arg2 = 0;
5620         else arg2 = (char *) SvPV(ST(1), PL_na);
5621         result = (Z_Espec1 *)data1_read_espec1(arg1,(char const *)arg2);
5622
5623         ST(argvi) = sv_newmortal();
5624         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_Espec1,0);
5625         XSRETURN(argvi);
5626         fail:
5627         (void) _swigerr;
5628     }
5629     croak(_swigerr);
5630 }
5631
5632
5633 XS(_wrap_data1_doespec1) {
5634     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5635     const char *_swigerr = _swigmsg;
5636     {
5637         data1_handle arg1 ;
5638         data1_node *arg2 ;
5639         Z_Espec1 *arg3 ;
5640         int result;
5641         int argvi = 0;
5642         dXSARGS;
5643
5644         if ((items < 3) || (items > 3)) {
5645             SWIG_croak("Usage: data1_doespec1(dh,n,e);");
5646         }
5647         {
5648             data1_handle * argp;
5649             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5650                 SWIG_croak("Type error in argument 1 of data1_doespec1. Expected _p_data1_handle");
5651             }
5652             arg1 = *argp;
5653         }
5654         {
5655             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5656                 SWIG_croak("Type error in argument 2 of data1_doespec1. Expected _p_data1_node");
5657             }
5658         }
5659         {
5660             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_Z_Espec1,0) < 0) {
5661                 SWIG_croak("Type error in argument 3 of data1_doespec1. Expected _p_Z_Espec1");
5662             }
5663         }
5664         result = (int)data1_doespec1(arg1,arg2,arg3);
5665
5666         ST(argvi) = sv_newmortal();
5667         sv_setiv(ST(argvi++), (IV) result);
5668         XSRETURN(argvi);
5669         fail:
5670         (void) _swigerr;
5671     }
5672     croak(_swigerr);
5673 }
5674
5675
5676 XS(_wrap_data1_getesetbyname) {
5677     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5678     const char *_swigerr = _swigmsg;
5679     {
5680         data1_handle arg1 ;
5681         data1_absyn *arg2 ;
5682         char *arg3 ;
5683         data1_esetname *result;
5684         int argvi = 0;
5685         dXSARGS;
5686
5687         if ((items < 3) || (items > 3)) {
5688             SWIG_croak("Usage: data1_getesetbyname(dh,a,name);");
5689         }
5690         {
5691             data1_handle * argp;
5692             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5693                 SWIG_croak("Type error in argument 1 of data1_getesetbyname. Expected _p_data1_handle");
5694             }
5695             arg1 = *argp;
5696         }
5697         {
5698             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_absyn,0) < 0) {
5699                 SWIG_croak("Type error in argument 2 of data1_getesetbyname. Expected _p_data1_absyn");
5700             }
5701         }
5702         if (!SvOK((SV*) ST(2))) arg3 = 0;
5703         else arg3 = (char *) SvPV(ST(2), PL_na);
5704         result = (data1_esetname *)data1_getesetbyname(arg1,arg2,(char const *)arg3);
5705
5706         ST(argvi) = sv_newmortal();
5707         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_esetname,0);
5708         XSRETURN(argvi);
5709         fail:
5710         (void) _swigerr;
5711     }
5712     croak(_swigerr);
5713 }
5714
5715
5716 XS(_wrap_data1_getelementbyname) {
5717     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5718     const char *_swigerr = _swigmsg;
5719     {
5720         data1_handle arg1 ;
5721         data1_absyn *arg2 ;
5722         char *arg3 ;
5723         data1_element *result;
5724         int argvi = 0;
5725         dXSARGS;
5726
5727         if ((items < 3) || (items > 3)) {
5728             SWIG_croak("Usage: data1_getelementbyname(dh,absyn,name);");
5729         }
5730         {
5731             data1_handle * argp;
5732             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5733                 SWIG_croak("Type error in argument 1 of data1_getelementbyname. Expected _p_data1_handle");
5734             }
5735             arg1 = *argp;
5736         }
5737         {
5738             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_absyn,0) < 0) {
5739                 SWIG_croak("Type error in argument 2 of data1_getelementbyname. Expected _p_data1_absyn");
5740             }
5741         }
5742         if (!SvOK((SV*) ST(2))) arg3 = 0;
5743         else arg3 = (char *) SvPV(ST(2), PL_na);
5744         result = (data1_element *)data1_getelementbyname(arg1,arg2,(char const *)arg3);
5745
5746         ST(argvi) = sv_newmortal();
5747         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_element,0);
5748         XSRETURN(argvi);
5749         fail:
5750         (void) _swigerr;
5751     }
5752     croak(_swigerr);
5753 }
5754
5755
5756 XS(_wrap_data1_mk_node2) {
5757     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5758     const char *_swigerr = _swigmsg;
5759     {
5760         data1_handle arg1 ;
5761         NMEM arg2 ;
5762         int arg3 ;
5763         data1_node *arg4 ;
5764         data1_node *result;
5765         int argvi = 0;
5766         dXSARGS;
5767
5768         if ((items < 4) || (items > 4)) {
5769             SWIG_croak("Usage: data1_mk_node2(dh,m,type,parent);");
5770         }
5771         {
5772             data1_handle * argp;
5773             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5774                 SWIG_croak("Type error in argument 1 of data1_mk_node2. Expected _p_data1_handle");
5775             }
5776             arg1 = *argp;
5777         }
5778         {
5779             NMEM * argp;
5780             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5781                 SWIG_croak("Type error in argument 2 of data1_mk_node2. Expected _p_NMEM");
5782             }
5783             arg2 = *argp;
5784         }
5785         arg3 = (int) SvIV(ST(2));
5786         {
5787             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
5788                 SWIG_croak("Type error in argument 4 of data1_mk_node2. Expected _p_data1_node");
5789             }
5790         }
5791         result = (data1_node *)data1_mk_node2(arg1,arg2,arg3,arg4);
5792
5793         ST(argvi) = sv_newmortal();
5794         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5795         XSRETURN(argvi);
5796         fail:
5797         (void) _swigerr;
5798     }
5799     croak(_swigerr);
5800 }
5801
5802
5803 XS(_wrap_data1_mk_tag) {
5804     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5805     const char *_swigerr = _swigmsg;
5806     {
5807         data1_handle arg1 ;
5808         NMEM arg2 ;
5809         char *arg3 ;
5810         char **arg4 ;
5811         data1_node *arg5 ;
5812         data1_node *result;
5813         int argvi = 0;
5814         dXSARGS;
5815
5816         if ((items < 5) || (items > 5)) {
5817             SWIG_croak("Usage: data1_mk_tag(dh,nmem,tag,attr,at);");
5818         }
5819         {
5820             data1_handle * argp;
5821             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5822                 SWIG_croak("Type error in argument 1 of data1_mk_tag. Expected _p_data1_handle");
5823             }
5824             arg1 = *argp;
5825         }
5826         {
5827             NMEM * argp;
5828             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5829                 SWIG_croak("Type error in argument 2 of data1_mk_tag. Expected _p_NMEM");
5830             }
5831             arg2 = *argp;
5832         }
5833         if (!SvOK((SV*) ST(2))) arg3 = 0;
5834         else arg3 = (char *) SvPV(ST(2), PL_na);
5835         {
5836             AV *tempav;
5837             I32 len;
5838             int i;
5839             SV  **tv;
5840             STRLEN na;
5841             if (!SvROK(ST(3)))
5842             croak("Argument 4 is not a reference.");
5843             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
5844             croak("Argument 4 is not an array.");
5845             tempav = (AV*)SvRV(ST(3));
5846             len = av_len(tempav);
5847             arg4 = (char **) malloc((len+2)*sizeof(char *));
5848             for (i = 0; i <= len; i++) {
5849                 tv = av_fetch(tempav, i, 0);
5850                 arg4[i] = (char *) SvPV(*tv,na);
5851             }
5852             arg4[i] = NULL;
5853         }
5854         {
5855             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
5856                 SWIG_croak("Type error in argument 5 of data1_mk_tag. Expected _p_data1_node");
5857             }
5858         }
5859         result = (data1_node *)data1_mk_tag(arg1,arg2,(char const *)arg3,(char const **)arg4,arg5);
5860
5861         ST(argvi) = sv_newmortal();
5862         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5863         {
5864             free(arg4);
5865         }
5866         XSRETURN(argvi);
5867         fail:
5868         {
5869             free(arg4);
5870         }
5871         (void) _swigerr;
5872     }
5873     croak(_swigerr);
5874 }
5875
5876
5877 XS(_wrap_data1_mk_tag_n) {
5878     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5879     const char *_swigerr = _swigmsg;
5880     {
5881         data1_handle arg1 ;
5882         NMEM arg2 ;
5883         char *arg3 ;
5884         size_t arg4 ;
5885         char **arg5 ;
5886         data1_node *arg6 ;
5887         data1_node *result;
5888         int argvi = 0;
5889         dXSARGS;
5890
5891         if ((items < 6) || (items > 6)) {
5892             SWIG_croak("Usage: data1_mk_tag_n(dh,nmem,tag,len,attr,at);");
5893         }
5894         {
5895             data1_handle * argp;
5896             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5897                 SWIG_croak("Type error in argument 1 of data1_mk_tag_n. Expected _p_data1_handle");
5898             }
5899             arg1 = *argp;
5900         }
5901         {
5902             NMEM * argp;
5903             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5904                 SWIG_croak("Type error in argument 2 of data1_mk_tag_n. Expected _p_NMEM");
5905             }
5906             arg2 = *argp;
5907         }
5908         if (!SvOK((SV*) ST(2))) arg3 = 0;
5909         else arg3 = (char *) SvPV(ST(2), PL_na);
5910         arg4 = (size_t) SvUV(ST(3));
5911         {
5912             AV *tempav;
5913             I32 len;
5914             int i;
5915             SV  **tv;
5916             STRLEN na;
5917             if (!SvROK(ST(4)))
5918             croak("Argument 5 is not a reference.");
5919             if (SvTYPE(SvRV(ST(4))) != SVt_PVAV)
5920             croak("Argument 5 is not an array.");
5921             tempav = (AV*)SvRV(ST(4));
5922             len = av_len(tempav);
5923             arg5 = (char **) malloc((len+2)*sizeof(char *));
5924             for (i = 0; i <= len; i++) {
5925                 tv = av_fetch(tempav, i, 0);
5926                 arg5[i] = (char *) SvPV(*tv,na);
5927             }
5928             arg5[i] = NULL;
5929         }
5930         {
5931             if (SWIG_ConvertPtr(ST(5), (void **) &arg6, SWIGTYPE_p_data1_node,0) < 0) {
5932                 SWIG_croak("Type error in argument 6 of data1_mk_tag_n. Expected _p_data1_node");
5933             }
5934         }
5935         result = (data1_node *)data1_mk_tag_n(arg1,arg2,(char const *)arg3,arg4,(char const **)arg5,arg6);
5936
5937         ST(argvi) = sv_newmortal();
5938         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5939         {
5940             free(arg5);
5941         }
5942         XSRETURN(argvi);
5943         fail:
5944         {
5945             free(arg5);
5946         }
5947         (void) _swigerr;
5948     }
5949     croak(_swigerr);
5950 }
5951
5952
5953 XS(_wrap_data1_tag_add_attr) {
5954     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5955     const char *_swigerr = _swigmsg;
5956     {
5957         data1_handle arg1 ;
5958         NMEM arg2 ;
5959         data1_node *arg3 ;
5960         char **arg4 ;
5961         int argvi = 0;
5962         dXSARGS;
5963
5964         if ((items < 4) || (items > 4)) {
5965             SWIG_croak("Usage: data1_tag_add_attr(dh,nmem,res,attr);");
5966         }
5967         {
5968             data1_handle * argp;
5969             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5970                 SWIG_croak("Type error in argument 1 of data1_tag_add_attr. Expected _p_data1_handle");
5971             }
5972             arg1 = *argp;
5973         }
5974         {
5975             NMEM * argp;
5976             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5977                 SWIG_croak("Type error in argument 2 of data1_tag_add_attr. Expected _p_NMEM");
5978             }
5979             arg2 = *argp;
5980         }
5981         {
5982             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_node,0) < 0) {
5983                 SWIG_croak("Type error in argument 3 of data1_tag_add_attr. Expected _p_data1_node");
5984             }
5985         }
5986         {
5987             AV *tempav;
5988             I32 len;
5989             int i;
5990             SV  **tv;
5991             STRLEN na;
5992             if (!SvROK(ST(3)))
5993             croak("Argument 4 is not a reference.");
5994             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
5995             croak("Argument 4 is not an array.");
5996             tempav = (AV*)SvRV(ST(3));
5997             len = av_len(tempav);
5998             arg4 = (char **) malloc((len+2)*sizeof(char *));
5999             for (i = 0; i <= len; i++) {
6000                 tv = av_fetch(tempav, i, 0);
6001                 arg4[i] = (char *) SvPV(*tv,na);
6002             }
6003             arg4[i] = NULL;
6004         }
6005         data1_tag_add_attr(arg1,arg2,arg3,(char const **)arg4);
6006
6007
6008         {
6009             free(arg4);
6010         }
6011         XSRETURN(argvi);
6012         fail:
6013         {
6014             free(arg4);
6015         }
6016         (void) _swigerr;
6017     }
6018     croak(_swigerr);
6019 }
6020
6021
6022 XS(_wrap_data1_mk_text_n) {
6023     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6024     const char *_swigerr = _swigmsg;
6025     {
6026         data1_handle arg1 ;
6027         NMEM arg2 ;
6028         char *arg3 ;
6029         size_t arg4 ;
6030         data1_node *arg5 ;
6031         data1_node *result;
6032         int argvi = 0;
6033         dXSARGS;
6034
6035         if ((items < 5) || (items > 5)) {
6036             SWIG_croak("Usage: data1_mk_text_n(dh,mem,buf,len,parent);");
6037         }
6038         {
6039             data1_handle * argp;
6040             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6041                 SWIG_croak("Type error in argument 1 of data1_mk_text_n. Expected _p_data1_handle");
6042             }
6043             arg1 = *argp;
6044         }
6045         {
6046             NMEM * argp;
6047             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6048                 SWIG_croak("Type error in argument 2 of data1_mk_text_n. Expected _p_NMEM");
6049             }
6050             arg2 = *argp;
6051         }
6052         if (!SvOK((SV*) ST(2))) arg3 = 0;
6053         else arg3 = (char *) SvPV(ST(2), PL_na);
6054         arg4 = (size_t) SvUV(ST(3));
6055         {
6056             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6057                 SWIG_croak("Type error in argument 5 of data1_mk_text_n. Expected _p_data1_node");
6058             }
6059         }
6060         result = (data1_node *)data1_mk_text_n(arg1,arg2,(char const *)arg3,arg4,arg5);
6061
6062         ST(argvi) = sv_newmortal();
6063         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6064         XSRETURN(argvi);
6065         fail:
6066         (void) _swigerr;
6067     }
6068     croak(_swigerr);
6069 }
6070
6071
6072 XS(_wrap_data1_mk_text_nf) {
6073     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6074     const char *_swigerr = _swigmsg;
6075     {
6076         data1_handle arg1 ;
6077         NMEM arg2 ;
6078         char *arg3 ;
6079         size_t arg4 ;
6080         data1_node *arg5 ;
6081         data1_node *result;
6082         int argvi = 0;
6083         dXSARGS;
6084
6085         if ((items < 5) || (items > 5)) {
6086             SWIG_croak("Usage: data1_mk_text_nf(dh,mem,buf,len,parent);");
6087         }
6088         {
6089             data1_handle * argp;
6090             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6091                 SWIG_croak("Type error in argument 1 of data1_mk_text_nf. Expected _p_data1_handle");
6092             }
6093             arg1 = *argp;
6094         }
6095         {
6096             NMEM * argp;
6097             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6098                 SWIG_croak("Type error in argument 2 of data1_mk_text_nf. Expected _p_NMEM");
6099             }
6100             arg2 = *argp;
6101         }
6102         if (!SvOK((SV*) ST(2))) arg3 = 0;
6103         else arg3 = (char *) SvPV(ST(2), PL_na);
6104         arg4 = (size_t) SvUV(ST(3));
6105         {
6106             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6107                 SWIG_croak("Type error in argument 5 of data1_mk_text_nf. Expected _p_data1_node");
6108             }
6109         }
6110         result = (data1_node *)data1_mk_text_nf(arg1,arg2,(char const *)arg3,arg4,arg5);
6111
6112         ST(argvi) = sv_newmortal();
6113         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6114         XSRETURN(argvi);
6115         fail:
6116         (void) _swigerr;
6117     }
6118     croak(_swigerr);
6119 }
6120
6121
6122 XS(_wrap_data1_mk_text) {
6123     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6124     const char *_swigerr = _swigmsg;
6125     {
6126         data1_handle arg1 ;
6127         NMEM arg2 ;
6128         char *arg3 ;
6129         data1_node *arg4 ;
6130         data1_node *result;
6131         int argvi = 0;
6132         dXSARGS;
6133
6134         if ((items < 4) || (items > 4)) {
6135             SWIG_croak("Usage: data1_mk_text(dh,mem,buf,parent);");
6136         }
6137         {
6138             data1_handle * argp;
6139             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6140                 SWIG_croak("Type error in argument 1 of data1_mk_text. Expected _p_data1_handle");
6141             }
6142             arg1 = *argp;
6143         }
6144         {
6145             NMEM * argp;
6146             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6147                 SWIG_croak("Type error in argument 2 of data1_mk_text. Expected _p_NMEM");
6148             }
6149             arg2 = *argp;
6150         }
6151         if (!SvOK((SV*) ST(2))) arg3 = 0;
6152         else arg3 = (char *) SvPV(ST(2), PL_na);
6153         {
6154             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
6155                 SWIG_croak("Type error in argument 4 of data1_mk_text. Expected _p_data1_node");
6156             }
6157         }
6158         result = (data1_node *)data1_mk_text(arg1,arg2,(char const *)arg3,arg4);
6159
6160         ST(argvi) = sv_newmortal();
6161         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6162         XSRETURN(argvi);
6163         fail:
6164         (void) _swigerr;
6165     }
6166     croak(_swigerr);
6167 }
6168
6169
6170 XS(_wrap_data1_mk_comment_n) {
6171     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6172     const char *_swigerr = _swigmsg;
6173     {
6174         data1_handle arg1 ;
6175         NMEM arg2 ;
6176         char *arg3 ;
6177         size_t arg4 ;
6178         data1_node *arg5 ;
6179         data1_node *result;
6180         int argvi = 0;
6181         dXSARGS;
6182
6183         if ((items < 5) || (items > 5)) {
6184             SWIG_croak("Usage: data1_mk_comment_n(dh,mem,buf,len,parent);");
6185         }
6186         {
6187             data1_handle * argp;
6188             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6189                 SWIG_croak("Type error in argument 1 of data1_mk_comment_n. Expected _p_data1_handle");
6190             }
6191             arg1 = *argp;
6192         }
6193         {
6194             NMEM * argp;
6195             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6196                 SWIG_croak("Type error in argument 2 of data1_mk_comment_n. Expected _p_NMEM");
6197             }
6198             arg2 = *argp;
6199         }
6200         if (!SvOK((SV*) ST(2))) arg3 = 0;
6201         else arg3 = (char *) SvPV(ST(2), PL_na);
6202         arg4 = (size_t) SvUV(ST(3));
6203         {
6204             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6205                 SWIG_croak("Type error in argument 5 of data1_mk_comment_n. Expected _p_data1_node");
6206             }
6207         }
6208         result = (data1_node *)data1_mk_comment_n(arg1,arg2,(char const *)arg3,arg4,arg5);
6209
6210         ST(argvi) = sv_newmortal();
6211         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6212         XSRETURN(argvi);
6213         fail:
6214         (void) _swigerr;
6215     }
6216     croak(_swigerr);
6217 }
6218
6219
6220 XS(_wrap_data1_mk_comment) {
6221     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6222     const char *_swigerr = _swigmsg;
6223     {
6224         data1_handle arg1 ;
6225         NMEM arg2 ;
6226         char *arg3 ;
6227         data1_node *arg4 ;
6228         data1_node *result;
6229         int argvi = 0;
6230         dXSARGS;
6231
6232         if ((items < 4) || (items > 4)) {
6233             SWIG_croak("Usage: data1_mk_comment(dh,mem,buf,parent);");
6234         }
6235         {
6236             data1_handle * argp;
6237             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6238                 SWIG_croak("Type error in argument 1 of data1_mk_comment. Expected _p_data1_handle");
6239             }
6240             arg1 = *argp;
6241         }
6242         {
6243             NMEM * argp;
6244             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6245                 SWIG_croak("Type error in argument 2 of data1_mk_comment. Expected _p_NMEM");
6246             }
6247             arg2 = *argp;
6248         }
6249         if (!SvOK((SV*) ST(2))) arg3 = 0;
6250         else arg3 = (char *) SvPV(ST(2), PL_na);
6251         {
6252             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
6253                 SWIG_croak("Type error in argument 4 of data1_mk_comment. Expected _p_data1_node");
6254             }
6255         }
6256         result = (data1_node *)data1_mk_comment(arg1,arg2,(char const *)arg3,arg4);
6257
6258         ST(argvi) = sv_newmortal();
6259         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6260         XSRETURN(argvi);
6261         fail:
6262         (void) _swigerr;
6263     }
6264     croak(_swigerr);
6265 }
6266
6267
6268 XS(_wrap_data1_mk_preprocess) {
6269     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6270     const char *_swigerr = _swigmsg;
6271     {
6272         data1_handle arg1 ;
6273         NMEM arg2 ;
6274         char *arg3 ;
6275         char **arg4 ;
6276         data1_node *arg5 ;
6277         data1_node *result;
6278         int argvi = 0;
6279         dXSARGS;
6280
6281         if ((items < 5) || (items > 5)) {
6282             SWIG_croak("Usage: data1_mk_preprocess(dh,nmem,target,attr,at);");
6283         }
6284         {
6285             data1_handle * argp;
6286             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6287                 SWIG_croak("Type error in argument 1 of data1_mk_preprocess. Expected _p_data1_handle");
6288             }
6289             arg1 = *argp;
6290         }
6291         {
6292             NMEM * argp;
6293             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6294                 SWIG_croak("Type error in argument 2 of data1_mk_preprocess. Expected _p_NMEM");
6295             }
6296             arg2 = *argp;
6297         }
6298         if (!SvOK((SV*) ST(2))) arg3 = 0;
6299         else arg3 = (char *) SvPV(ST(2), PL_na);
6300         {
6301             AV *tempav;
6302             I32 len;
6303             int i;
6304             SV  **tv;
6305             STRLEN na;
6306             if (!SvROK(ST(3)))
6307             croak("Argument 4 is not a reference.");
6308             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
6309             croak("Argument 4 is not an array.");
6310             tempav = (AV*)SvRV(ST(3));
6311             len = av_len(tempav);
6312             arg4 = (char **) malloc((len+2)*sizeof(char *));
6313             for (i = 0; i <= len; i++) {
6314                 tv = av_fetch(tempav, i, 0);
6315                 arg4[i] = (char *) SvPV(*tv,na);
6316             }
6317             arg4[i] = NULL;
6318         }
6319         {
6320             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6321                 SWIG_croak("Type error in argument 5 of data1_mk_preprocess. Expected _p_data1_node");
6322             }
6323         }
6324         result = (data1_node *)data1_mk_preprocess(arg1,arg2,(char const *)arg3,(char const **)arg4,arg5);
6325
6326         ST(argvi) = sv_newmortal();
6327         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6328         {
6329             free(arg4);
6330         }
6331         XSRETURN(argvi);
6332         fail:
6333         {
6334             free(arg4);
6335         }
6336         (void) _swigerr;
6337     }
6338     croak(_swigerr);
6339 }
6340
6341
6342 XS(_wrap_data1_mk_root) {
6343     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6344     const char *_swigerr = _swigmsg;
6345     {
6346         data1_handle arg1 ;
6347         NMEM arg2 ;
6348         char *arg3 ;
6349         data1_node *result;
6350         int argvi = 0;
6351         dXSARGS;
6352
6353         if ((items < 3) || (items > 3)) {
6354             SWIG_croak("Usage: data1_mk_root(dh,nmem,name);");
6355         }
6356         {
6357             data1_handle * argp;
6358             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6359                 SWIG_croak("Type error in argument 1 of data1_mk_root. Expected _p_data1_handle");
6360             }
6361             arg1 = *argp;
6362         }
6363         {
6364             NMEM * argp;
6365             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6366                 SWIG_croak("Type error in argument 2 of data1_mk_root. Expected _p_NMEM");
6367             }
6368             arg2 = *argp;
6369         }
6370         if (!SvOK((SV*) ST(2))) arg3 = 0;
6371         else arg3 = (char *) SvPV(ST(2), PL_na);
6372         result = (data1_node *)data1_mk_root(arg1,arg2,(char const *)arg3);
6373
6374         ST(argvi) = sv_newmortal();
6375         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6376         XSRETURN(argvi);
6377         fail:
6378         (void) _swigerr;
6379     }
6380     croak(_swigerr);
6381 }
6382
6383
6384 XS(_wrap_data1_set_root) {
6385     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6386     const char *_swigerr = _swigmsg;
6387     {
6388         data1_handle arg1 ;
6389         data1_node *arg2 ;
6390         NMEM arg3 ;
6391         char *arg4 ;
6392         int argvi = 0;
6393         dXSARGS;
6394
6395         if ((items < 4) || (items > 4)) {
6396             SWIG_croak("Usage: data1_set_root(dh,res,nmem,name);");
6397         }
6398         {
6399             data1_handle * argp;
6400             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6401                 SWIG_croak("Type error in argument 1 of data1_set_root. Expected _p_data1_handle");
6402             }
6403             arg1 = *argp;
6404         }
6405         {
6406             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6407                 SWIG_croak("Type error in argument 2 of data1_set_root. Expected _p_data1_node");
6408             }
6409         }
6410         {
6411             NMEM * argp;
6412             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6413                 SWIG_croak("Type error in argument 3 of data1_set_root. Expected _p_NMEM");
6414             }
6415             arg3 = *argp;
6416         }
6417         if (!SvOK((SV*) ST(3))) arg4 = 0;
6418         else arg4 = (char *) SvPV(ST(3), PL_na);
6419         data1_set_root(arg1,arg2,arg3,(char const *)arg4);
6420
6421
6422         XSRETURN(argvi);
6423         fail:
6424         (void) _swigerr;
6425     }
6426     croak(_swigerr);
6427 }
6428
6429
6430 XS(_wrap_data1_mk_tag_data_int) {
6431     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6432     const char *_swigerr = _swigmsg;
6433     {
6434         data1_handle arg1 ;
6435         data1_node *arg2 ;
6436         char *arg3 ;
6437         int arg4 ;
6438         NMEM arg5 ;
6439         data1_node *result;
6440         int argvi = 0;
6441         dXSARGS;
6442
6443         if ((items < 5) || (items > 5)) {
6444             SWIG_croak("Usage: data1_mk_tag_data_int(dh,at,tag,num,nmem);");
6445         }
6446         {
6447             data1_handle * argp;
6448             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6449                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_int. Expected _p_data1_handle");
6450             }
6451             arg1 = *argp;
6452         }
6453         {
6454             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6455                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_int. Expected _p_data1_node");
6456             }
6457         }
6458         if (!SvOK((SV*) ST(2))) arg3 = 0;
6459         else arg3 = (char *) SvPV(ST(2), PL_na);
6460         arg4 = (int) SvIV(ST(3));
6461         {
6462             NMEM * argp;
6463             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6464                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_int. Expected _p_NMEM");
6465             }
6466             arg5 = *argp;
6467         }
6468         result = (data1_node *)data1_mk_tag_data_int(arg1,arg2,(char const *)arg3,arg4,arg5);
6469
6470         ST(argvi) = sv_newmortal();
6471         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6472         XSRETURN(argvi);
6473         fail:
6474         (void) _swigerr;
6475     }
6476     croak(_swigerr);
6477 }
6478
6479
6480 XS(_wrap_data1_mk_tag_data_oid) {
6481     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6482     const char *_swigerr = _swigmsg;
6483     {
6484         data1_handle arg1 ;
6485         data1_node *arg2 ;
6486         char *arg3 ;
6487         Odr_oid *arg4 ;
6488         NMEM arg5 ;
6489         data1_node *result;
6490         int argvi = 0;
6491         dXSARGS;
6492
6493         if ((items < 5) || (items > 5)) {
6494             SWIG_croak("Usage: data1_mk_tag_data_oid(dh,at,tag,oid,nmem);");
6495         }
6496         {
6497             data1_handle * argp;
6498             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6499                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_oid. Expected _p_data1_handle");
6500             }
6501             arg1 = *argp;
6502         }
6503         {
6504             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6505                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_oid. Expected _p_data1_node");
6506             }
6507         }
6508         if (!SvOK((SV*) ST(2))) arg3 = 0;
6509         else arg3 = (char *) SvPV(ST(2), PL_na);
6510         {
6511             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_Odr_oid,0) < 0) {
6512                 SWIG_croak("Type error in argument 4 of data1_mk_tag_data_oid. Expected _p_Odr_oid");
6513             }
6514         }
6515         {
6516             NMEM * argp;
6517             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6518                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_oid. Expected _p_NMEM");
6519             }
6520             arg5 = *argp;
6521         }
6522         result = (data1_node *)data1_mk_tag_data_oid(arg1,arg2,(char const *)arg3,arg4,arg5);
6523
6524         ST(argvi) = sv_newmortal();
6525         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6526         XSRETURN(argvi);
6527         fail:
6528         (void) _swigerr;
6529     }
6530     croak(_swigerr);
6531 }
6532
6533
6534 XS(_wrap_data1_mk_tag_data_text) {
6535     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6536     const char *_swigerr = _swigmsg;
6537     {
6538         data1_handle arg1 ;
6539         data1_node *arg2 ;
6540         char *arg3 ;
6541         char *arg4 ;
6542         NMEM arg5 ;
6543         data1_node *result;
6544         int argvi = 0;
6545         dXSARGS;
6546
6547         if ((items < 5) || (items > 5)) {
6548             SWIG_croak("Usage: data1_mk_tag_data_text(dh,at,tag,str,nmem);");
6549         }
6550         {
6551             data1_handle * argp;
6552             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6553                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_text. Expected _p_data1_handle");
6554             }
6555             arg1 = *argp;
6556         }
6557         {
6558             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6559                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_text. Expected _p_data1_node");
6560             }
6561         }
6562         if (!SvOK((SV*) ST(2))) arg3 = 0;
6563         else arg3 = (char *) SvPV(ST(2), PL_na);
6564         if (!SvOK((SV*) ST(3))) arg4 = 0;
6565         else arg4 = (char *) SvPV(ST(3), PL_na);
6566         {
6567             NMEM * argp;
6568             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6569                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_text. Expected _p_NMEM");
6570             }
6571             arg5 = *argp;
6572         }
6573         result = (data1_node *)data1_mk_tag_data_text(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
6574
6575         ST(argvi) = sv_newmortal();
6576         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6577         XSRETURN(argvi);
6578         fail:
6579         (void) _swigerr;
6580     }
6581     croak(_swigerr);
6582 }
6583
6584
6585 XS(_wrap_data1_mk_tag_data_text_uni) {
6586     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6587     const char *_swigerr = _swigmsg;
6588     {
6589         data1_handle arg1 ;
6590         data1_node *arg2 ;
6591         char *arg3 ;
6592         char *arg4 ;
6593         NMEM arg5 ;
6594         data1_node *result;
6595         int argvi = 0;
6596         dXSARGS;
6597
6598         if ((items < 5) || (items > 5)) {
6599             SWIG_croak("Usage: data1_mk_tag_data_text_uni(dh,at,tag,str,nmem);");
6600         }
6601         {
6602             data1_handle * argp;
6603             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6604                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_text_uni. Expected _p_data1_handle");
6605             }
6606             arg1 = *argp;
6607         }
6608         {
6609             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6610                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_text_uni. Expected _p_data1_node");
6611             }
6612         }
6613         if (!SvOK((SV*) ST(2))) arg3 = 0;
6614         else arg3 = (char *) SvPV(ST(2), PL_na);
6615         if (!SvOK((SV*) ST(3))) arg4 = 0;
6616         else arg4 = (char *) SvPV(ST(3), PL_na);
6617         {
6618             NMEM * argp;
6619             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6620                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_text_uni. Expected _p_NMEM");
6621             }
6622             arg5 = *argp;
6623         }
6624         result = (data1_node *)data1_mk_tag_data_text_uni(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
6625
6626         ST(argvi) = sv_newmortal();
6627         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6628         XSRETURN(argvi);
6629         fail:
6630         (void) _swigerr;
6631     }
6632     croak(_swigerr);
6633 }
6634
6635
6636 XS(_wrap_data1_get_absyn) {
6637     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6638     const char *_swigerr = _swigmsg;
6639     {
6640         data1_handle arg1 ;
6641         char *arg2 ;
6642         data1_absyn *result;
6643         int argvi = 0;
6644         dXSARGS;
6645
6646         if ((items < 2) || (items > 2)) {
6647             SWIG_croak("Usage: data1_get_absyn(dh,name);");
6648         }
6649         {
6650             data1_handle * argp;
6651             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6652                 SWIG_croak("Type error in argument 1 of data1_get_absyn. Expected _p_data1_handle");
6653             }
6654             arg1 = *argp;
6655         }
6656         if (!SvOK((SV*) ST(1))) arg2 = 0;
6657         else arg2 = (char *) SvPV(ST(1), PL_na);
6658         result = (data1_absyn *)data1_get_absyn(arg1,(char const *)arg2);
6659
6660         ST(argvi) = sv_newmortal();
6661         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_absyn,0);
6662         XSRETURN(argvi);
6663         fail:
6664         (void) _swigerr;
6665     }
6666     croak(_swigerr);
6667 }
6668
6669
6670 XS(_wrap_data1_search_tag) {
6671     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6672     const char *_swigerr = _swigmsg;
6673     {
6674         data1_handle arg1 ;
6675         data1_node *arg2 ;
6676         char *arg3 ;
6677         data1_node *result;
6678         int argvi = 0;
6679         dXSARGS;
6680
6681         if ((items < 3) || (items > 3)) {
6682             SWIG_croak("Usage: data1_search_tag(dh,n,tag);");
6683         }
6684         {
6685             data1_handle * argp;
6686             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6687                 SWIG_croak("Type error in argument 1 of data1_search_tag. Expected _p_data1_handle");
6688             }
6689             arg1 = *argp;
6690         }
6691         {
6692             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6693                 SWIG_croak("Type error in argument 2 of data1_search_tag. Expected _p_data1_node");
6694             }
6695         }
6696         if (!SvOK((SV*) ST(2))) arg3 = 0;
6697         else arg3 = (char *) SvPV(ST(2), PL_na);
6698         result = (data1_node *)data1_search_tag(arg1,arg2,(char const *)arg3);
6699
6700         ST(argvi) = sv_newmortal();
6701         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6702         XSRETURN(argvi);
6703         fail:
6704         (void) _swigerr;
6705     }
6706     croak(_swigerr);
6707 }
6708
6709
6710 XS(_wrap_data1_mk_tag_uni) {
6711     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6712     const char *_swigerr = _swigmsg;
6713     {
6714         data1_handle arg1 ;
6715         NMEM arg2 ;
6716         char *arg3 ;
6717         data1_node *arg4 ;
6718         data1_node *result;
6719         int argvi = 0;
6720         dXSARGS;
6721
6722         if ((items < 4) || (items > 4)) {
6723             SWIG_croak("Usage: data1_mk_tag_uni(dh,nmem,tag,at);");
6724         }
6725         {
6726             data1_handle * argp;
6727             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6728                 SWIG_croak("Type error in argument 1 of data1_mk_tag_uni. Expected _p_data1_handle");
6729             }
6730             arg1 = *argp;
6731         }
6732         {
6733             NMEM * argp;
6734             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6735                 SWIG_croak("Type error in argument 2 of data1_mk_tag_uni. Expected _p_NMEM");
6736             }
6737             arg2 = *argp;
6738         }
6739         if (!SvOK((SV*) ST(2))) arg3 = 0;
6740         else arg3 = (char *) SvPV(ST(2), PL_na);
6741         {
6742             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
6743                 SWIG_croak("Type error in argument 4 of data1_mk_tag_uni. Expected _p_data1_node");
6744             }
6745         }
6746         result = (data1_node *)data1_mk_tag_uni(arg1,arg2,(char const *)arg3,arg4);
6747
6748         ST(argvi) = sv_newmortal();
6749         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6750         XSRETURN(argvi);
6751         fail:
6752         (void) _swigerr;
6753     }
6754     croak(_swigerr);
6755 }
6756
6757
6758 XS(_wrap_data1_get_attset) {
6759     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6760     const char *_swigerr = _swigmsg;
6761     {
6762         data1_handle arg1 ;
6763         char *arg2 ;
6764         data1_attset *result;
6765         int argvi = 0;
6766         dXSARGS;
6767
6768         if ((items < 2) || (items > 2)) {
6769             SWIG_croak("Usage: data1_get_attset(dh,name);");
6770         }
6771         {
6772             data1_handle * argp;
6773             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6774                 SWIG_croak("Type error in argument 1 of data1_get_attset. Expected _p_data1_handle");
6775             }
6776             arg1 = *argp;
6777         }
6778         if (!SvOK((SV*) ST(1))) arg2 = 0;
6779         else arg2 = (char *) SvPV(ST(1), PL_na);
6780         result = (data1_attset *)data1_get_attset(arg1,(char const *)arg2);
6781
6782         ST(argvi) = sv_newmortal();
6783         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_attset,0);
6784         XSRETURN(argvi);
6785         fail:
6786         (void) _swigerr;
6787     }
6788     croak(_swigerr);
6789 }
6790
6791
6792 XS(_wrap_data1_read_maptab) {
6793     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6794     const char *_swigerr = _swigmsg;
6795     {
6796         data1_handle arg1 ;
6797         char *arg2 ;
6798         data1_maptab *result;
6799         int argvi = 0;
6800         dXSARGS;
6801
6802         if ((items < 2) || (items > 2)) {
6803             SWIG_croak("Usage: data1_read_maptab(dh,file);");
6804         }
6805         {
6806             data1_handle * argp;
6807             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6808                 SWIG_croak("Type error in argument 1 of data1_read_maptab. Expected _p_data1_handle");
6809             }
6810             arg1 = *argp;
6811         }
6812         if (!SvOK((SV*) ST(1))) arg2 = 0;
6813         else arg2 = (char *) SvPV(ST(1), PL_na);
6814         result = (data1_maptab *)data1_read_maptab(arg1,(char const *)arg2);
6815
6816         ST(argvi) = sv_newmortal();
6817         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_maptab,0);
6818         XSRETURN(argvi);
6819         fail:
6820         (void) _swigerr;
6821     }
6822     croak(_swigerr);
6823 }
6824
6825
6826 XS(_wrap_data1_map_record) {
6827     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6828     const char *_swigerr = _swigmsg;
6829     {
6830         data1_handle arg1 ;
6831         data1_node *arg2 ;
6832         data1_maptab *arg3 ;
6833         NMEM arg4 ;
6834         data1_node *result;
6835         int argvi = 0;
6836         dXSARGS;
6837
6838         if ((items < 4) || (items > 4)) {
6839             SWIG_croak("Usage: data1_map_record(dh,n,map,m);");
6840         }
6841         {
6842             data1_handle * argp;
6843             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6844                 SWIG_croak("Type error in argument 1 of data1_map_record. Expected _p_data1_handle");
6845             }
6846             arg1 = *argp;
6847         }
6848         {
6849             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6850                 SWIG_croak("Type error in argument 2 of data1_map_record. Expected _p_data1_node");
6851             }
6852         }
6853         {
6854             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_maptab,0) < 0) {
6855                 SWIG_croak("Type error in argument 3 of data1_map_record. Expected _p_data1_maptab");
6856             }
6857         }
6858         {
6859             NMEM * argp;
6860             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6861                 SWIG_croak("Type error in argument 4 of data1_map_record. Expected _p_NMEM");
6862             }
6863             arg4 = *argp;
6864         }
6865         result = (data1_node *)data1_map_record(arg1,arg2,arg3,arg4);
6866
6867         ST(argvi) = sv_newmortal();
6868         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6869         XSRETURN(argvi);
6870         fail:
6871         (void) _swigerr;
6872     }
6873     croak(_swigerr);
6874 }
6875
6876
6877 XS(_wrap_data1_read_marctab) {
6878     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6879     const char *_swigerr = _swigmsg;
6880     {
6881         data1_handle arg1 ;
6882         char *arg2 ;
6883         data1_marctab *result;
6884         int argvi = 0;
6885         dXSARGS;
6886
6887         if ((items < 2) || (items > 2)) {
6888             SWIG_croak("Usage: data1_read_marctab(dh,file);");
6889         }
6890         {
6891             data1_handle * argp;
6892             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6893                 SWIG_croak("Type error in argument 1 of data1_read_marctab. Expected _p_data1_handle");
6894             }
6895             arg1 = *argp;
6896         }
6897         if (!SvOK((SV*) ST(1))) arg2 = 0;
6898         else arg2 = (char *) SvPV(ST(1), PL_na);
6899         result = (data1_marctab *)data1_read_marctab(arg1,(char const *)arg2);
6900
6901         ST(argvi) = sv_newmortal();
6902         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_marctab,0);
6903         XSRETURN(argvi);
6904         fail:
6905         (void) _swigerr;
6906     }
6907     croak(_swigerr);
6908 }
6909
6910
6911 XS(_wrap_data1_nodetomarc) {
6912     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6913     const char *_swigerr = _swigmsg;
6914     {
6915         data1_handle arg1 ;
6916         data1_marctab *arg2 ;
6917         data1_node *arg3 ;
6918         int arg4 ;
6919         int *arg5 ;
6920         char *result;
6921         int argvi = 0;
6922         dXSARGS;
6923
6924         if ((items < 5) || (items > 5)) {
6925             SWIG_croak("Usage: data1_nodetomarc(dh,p,n,selected,len);");
6926         }
6927         {
6928             data1_handle * argp;
6929             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6930                 SWIG_croak("Type error in argument 1 of data1_nodetomarc. Expected _p_data1_handle");
6931             }
6932             arg1 = *argp;
6933         }
6934         {
6935             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_marctab,0) < 0) {
6936                 SWIG_croak("Type error in argument 2 of data1_nodetomarc. Expected _p_data1_marctab");
6937             }
6938         }
6939         {
6940             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_node,0) < 0) {
6941                 SWIG_croak("Type error in argument 3 of data1_nodetomarc. Expected _p_data1_node");
6942             }
6943         }
6944         arg4 = (int) SvIV(ST(3));
6945         {
6946             int i;
6947             if (!SvIOK(ST(4)))
6948             croak("Argument 5 is not an integer.");
6949             i = SvIV(ST(4));
6950             arg5 = &i;
6951         }
6952         result = (char *)data1_nodetomarc(arg1,arg2,arg3,arg4,arg5);
6953
6954         ST(argvi) = sv_newmortal();
6955         if (result) {
6956             sv_setpv((SV*)ST(argvi++), (char *) result);
6957         }else {
6958             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
6959         }
6960         XSRETURN(argvi);
6961         fail:
6962         (void) _swigerr;
6963     }
6964     croak(_swigerr);
6965 }
6966
6967
6968 XS(_wrap_data1_nodetoidsgml) {
6969     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6970     const char *_swigerr = _swigmsg;
6971     {
6972         data1_handle arg1 ;
6973         data1_node *arg2 ;
6974         int arg3 ;
6975         int *arg4 ;
6976         char *result;
6977         int argvi = 0;
6978         dXSARGS;
6979
6980         if ((items < 4) || (items > 4)) {
6981             SWIG_croak("Usage: data1_nodetoidsgml(dh,n,select,len);");
6982         }
6983         {
6984             data1_handle * argp;
6985             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6986                 SWIG_croak("Type error in argument 1 of data1_nodetoidsgml. Expected _p_data1_handle");
6987             }
6988             arg1 = *argp;
6989         }
6990         {
6991             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6992                 SWIG_croak("Type error in argument 2 of data1_nodetoidsgml. Expected _p_data1_node");
6993             }
6994         }
6995         arg3 = (int) SvIV(ST(2));
6996         {
6997             int i;
6998             if (!SvIOK(ST(3)))
6999             croak("Argument 4 is not an integer.");
7000             i = SvIV(ST(3));
7001             arg4 = &i;
7002         }
7003         result = (char *)data1_nodetoidsgml(arg1,arg2,arg3,arg4);
7004
7005         ST(argvi) = sv_newmortal();
7006         if (result) {
7007             sv_setpv((SV*)ST(argvi++), (char *) result);
7008         }else {
7009             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7010         }
7011         XSRETURN(argvi);
7012         fail:
7013         (void) _swigerr;
7014     }
7015     croak(_swigerr);
7016 }
7017
7018
7019 XS(_wrap_data1_nodetoexplain) {
7020     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7021     const char *_swigerr = _swigmsg;
7022     {
7023         data1_handle arg1 ;
7024         data1_node *arg2 ;
7025         int arg3 ;
7026         ODR arg4 ;
7027         Z_ExplainRecord *result;
7028         int argvi = 0;
7029         dXSARGS;
7030
7031         if ((items < 4) || (items > 4)) {
7032             SWIG_croak("Usage: data1_nodetoexplain(dh,n,select,o);");
7033         }
7034         {
7035             data1_handle * argp;
7036             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7037                 SWIG_croak("Type error in argument 1 of data1_nodetoexplain. Expected _p_data1_handle");
7038             }
7039             arg1 = *argp;
7040         }
7041         {
7042             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7043                 SWIG_croak("Type error in argument 2 of data1_nodetoexplain. Expected _p_data1_node");
7044             }
7045         }
7046         arg3 = (int) SvIV(ST(2));
7047         {
7048             ODR * argp;
7049             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
7050                 SWIG_croak("Type error in argument 4 of data1_nodetoexplain. Expected _p_ODR");
7051             }
7052             arg4 = *argp;
7053         }
7054         result = (Z_ExplainRecord *)data1_nodetoexplain(arg1,arg2,arg3,arg4);
7055
7056         ST(argvi) = sv_newmortal();
7057         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_ExplainRecord,0);
7058         XSRETURN(argvi);
7059         fail:
7060         (void) _swigerr;
7061     }
7062     croak(_swigerr);
7063 }
7064
7065
7066 XS(_wrap_data1_nodetosummary) {
7067     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7068     const char *_swigerr = _swigmsg;
7069     {
7070         data1_handle arg1 ;
7071         data1_node *arg2 ;
7072         int arg3 ;
7073         ODR arg4 ;
7074         Z_BriefBib *result;
7075         int argvi = 0;
7076         dXSARGS;
7077
7078         if ((items < 4) || (items > 4)) {
7079             SWIG_croak("Usage: data1_nodetosummary(dh,n,select,o);");
7080         }
7081         {
7082             data1_handle * argp;
7083             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7084                 SWIG_croak("Type error in argument 1 of data1_nodetosummary. Expected _p_data1_handle");
7085             }
7086             arg1 = *argp;
7087         }
7088         {
7089             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7090                 SWIG_croak("Type error in argument 2 of data1_nodetosummary. Expected _p_data1_node");
7091             }
7092         }
7093         arg3 = (int) SvIV(ST(2));
7094         {
7095             ODR * argp;
7096             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
7097                 SWIG_croak("Type error in argument 4 of data1_nodetosummary. Expected _p_ODR");
7098             }
7099             arg4 = *argp;
7100         }
7101         result = (Z_BriefBib *)data1_nodetosummary(arg1,arg2,arg3,arg4);
7102
7103         ST(argvi) = sv_newmortal();
7104         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_BriefBib,0);
7105         XSRETURN(argvi);
7106         fail:
7107         (void) _swigerr;
7108     }
7109     croak(_swigerr);
7110 }
7111
7112
7113 XS(_wrap_data1_nodetosoif) {
7114     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7115     const char *_swigerr = _swigmsg;
7116     {
7117         data1_handle arg1 ;
7118         data1_node *arg2 ;
7119         int arg3 ;
7120         int *arg4 ;
7121         char *result;
7122         int argvi = 0;
7123         dXSARGS;
7124
7125         if ((items < 4) || (items > 4)) {
7126             SWIG_croak("Usage: data1_nodetosoif(dh,n,select,len);");
7127         }
7128         {
7129             data1_handle * argp;
7130             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7131                 SWIG_croak("Type error in argument 1 of data1_nodetosoif. Expected _p_data1_handle");
7132             }
7133             arg1 = *argp;
7134         }
7135         {
7136             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7137                 SWIG_croak("Type error in argument 2 of data1_nodetosoif. Expected _p_data1_node");
7138             }
7139         }
7140         arg3 = (int) SvIV(ST(2));
7141         {
7142             int i;
7143             if (!SvIOK(ST(3)))
7144             croak("Argument 4 is not an integer.");
7145             i = SvIV(ST(3));
7146             arg4 = &i;
7147         }
7148         result = (char *)data1_nodetosoif(arg1,arg2,arg3,arg4);
7149
7150         ST(argvi) = sv_newmortal();
7151         if (result) {
7152             sv_setpv((SV*)ST(argvi++), (char *) result);
7153         }else {
7154             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7155         }
7156         XSRETURN(argvi);
7157         fail:
7158         (void) _swigerr;
7159     }
7160     croak(_swigerr);
7161 }
7162
7163
7164 XS(_wrap_data1_get_wrbuf) {
7165     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7166     const char *_swigerr = _swigmsg;
7167     {
7168         data1_handle arg1 ;
7169         WRBUF result;
7170         int argvi = 0;
7171         dXSARGS;
7172
7173         if ((items < 1) || (items > 1)) {
7174             SWIG_croak("Usage: data1_get_wrbuf(dp);");
7175         }
7176         {
7177             data1_handle * argp;
7178             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7179                 SWIG_croak("Type error in argument 1 of data1_get_wrbuf. Expected _p_data1_handle");
7180             }
7181             arg1 = *argp;
7182         }
7183         result = data1_get_wrbuf(arg1);
7184
7185         {
7186             WRBUF * resultobj = (WRBUF *) malloc(sizeof(WRBUF));
7187             memmove(resultobj, &result, sizeof(WRBUF));
7188             ST(argvi) = sv_newmortal();
7189             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_WRBUF,0);
7190         }
7191         XSRETURN(argvi);
7192         fail:
7193         (void) _swigerr;
7194     }
7195     croak(_swigerr);
7196 }
7197
7198
7199 XS(_wrap_data1_get_read_buf) {
7200     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7201     const char *_swigerr = _swigmsg;
7202     {
7203         data1_handle arg1 ;
7204         int **arg2 ;
7205         char **result;
7206         int argvi = 0;
7207         dXSARGS;
7208
7209         if ((items < 2) || (items > 2)) {
7210             SWIG_croak("Usage: data1_get_read_buf(dp,lenp);");
7211         }
7212         {
7213             data1_handle * argp;
7214             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7215                 SWIG_croak("Type error in argument 1 of data1_get_read_buf. Expected _p_data1_handle");
7216             }
7217             arg1 = *argp;
7218         }
7219         {
7220             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_p_int,0) < 0) {
7221                 SWIG_croak("Type error in argument 2 of data1_get_read_buf. Expected _p_p_int");
7222             }
7223         }
7224         result = (char **)data1_get_read_buf(arg1,arg2);
7225
7226         {
7227             AV *myav;
7228             SV **svs;
7229             int i = 0,len = 0;
7230             /* Figure out how many elements we have */
7231             while (result[len])
7232             len++;
7233             svs = (SV **) malloc(len*sizeof(SV *));
7234             for (i = 0; i < len ; i++) {
7235                 svs[i] = sv_newmortal();
7236                 sv_setpv((SV*)svs[i],result[i]);
7237             };
7238             myav =  av_make(len,svs);
7239             free(svs);
7240             ST(argvi) = newRV((SV*)myav);
7241             sv_2mortal(ST(argvi));
7242             argvi++;
7243         }
7244         XSRETURN(argvi);
7245         fail:
7246         (void) _swigerr;
7247     }
7248     croak(_swigerr);
7249 }
7250
7251
7252 XS(_wrap_data1_get_map_buf) {
7253     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7254     const char *_swigerr = _swigmsg;
7255     {
7256         data1_handle arg1 ;
7257         int **arg2 ;
7258         char **result;
7259         int argvi = 0;
7260         dXSARGS;
7261
7262         if ((items < 2) || (items > 2)) {
7263             SWIG_croak("Usage: data1_get_map_buf(dp,lenp);");
7264         }
7265         {
7266             data1_handle * argp;
7267             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7268                 SWIG_croak("Type error in argument 1 of data1_get_map_buf. Expected _p_data1_handle");
7269             }
7270             arg1 = *argp;
7271         }
7272         {
7273             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_p_int,0) < 0) {
7274                 SWIG_croak("Type error in argument 2 of data1_get_map_buf. Expected _p_p_int");
7275             }
7276         }
7277         result = (char **)data1_get_map_buf(arg1,arg2);
7278
7279         {
7280             AV *myav;
7281             SV **svs;
7282             int i = 0,len = 0;
7283             /* Figure out how many elements we have */
7284             while (result[len])
7285             len++;
7286             svs = (SV **) malloc(len*sizeof(SV *));
7287             for (i = 0; i < len ; i++) {
7288                 svs[i] = sv_newmortal();
7289                 sv_setpv((SV*)svs[i],result[i]);
7290             };
7291             myav =  av_make(len,svs);
7292             free(svs);
7293             ST(argvi) = newRV((SV*)myav);
7294             sv_2mortal(ST(argvi));
7295             argvi++;
7296         }
7297         XSRETURN(argvi);
7298         fail:
7299         (void) _swigerr;
7300     }
7301     croak(_swigerr);
7302 }
7303
7304
7305 XS(_wrap_data1_absyn_cache_get) {
7306     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7307     const char *_swigerr = _swigmsg;
7308     {
7309         data1_handle arg1 ;
7310         data1_absyn_cache *result;
7311         int argvi = 0;
7312         dXSARGS;
7313
7314         if ((items < 1) || (items > 1)) {
7315             SWIG_croak("Usage: data1_absyn_cache_get(dh);");
7316         }
7317         {
7318             data1_handle * argp;
7319             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7320                 SWIG_croak("Type error in argument 1 of data1_absyn_cache_get. Expected _p_data1_handle");
7321             }
7322             arg1 = *argp;
7323         }
7324         result = (data1_absyn_cache *)data1_absyn_cache_get(arg1);
7325
7326         ST(argvi) = sv_newmortal();
7327         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_absyn_cache,0);
7328         XSRETURN(argvi);
7329         fail:
7330         (void) _swigerr;
7331     }
7332     croak(_swigerr);
7333 }
7334
7335
7336 XS(_wrap_data1_attset_cache_get) {
7337     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7338     const char *_swigerr = _swigmsg;
7339     {
7340         data1_handle arg1 ;
7341         data1_attset_cache *result;
7342         int argvi = 0;
7343         dXSARGS;
7344
7345         if ((items < 1) || (items > 1)) {
7346             SWIG_croak("Usage: data1_attset_cache_get(dh);");
7347         }
7348         {
7349             data1_handle * argp;
7350             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7351                 SWIG_croak("Type error in argument 1 of data1_attset_cache_get. Expected _p_data1_handle");
7352             }
7353             arg1 = *argp;
7354         }
7355         result = (data1_attset_cache *)data1_attset_cache_get(arg1);
7356
7357         ST(argvi) = sv_newmortal();
7358         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_attset_cache,0);
7359         XSRETURN(argvi);
7360         fail:
7361         (void) _swigerr;
7362     }
7363     croak(_swigerr);
7364 }
7365
7366
7367 XS(_wrap_data1_nmem_get) {
7368     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7369     const char *_swigerr = _swigmsg;
7370     {
7371         data1_handle arg1 ;
7372         NMEM result;
7373         int argvi = 0;
7374         dXSARGS;
7375
7376         if ((items < 1) || (items > 1)) {
7377             SWIG_croak("Usage: data1_nmem_get(dh);");
7378         }
7379         {
7380             data1_handle * argp;
7381             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7382                 SWIG_croak("Type error in argument 1 of data1_nmem_get. Expected _p_data1_handle");
7383             }
7384             arg1 = *argp;
7385         }
7386         result = data1_nmem_get(arg1);
7387
7388         {
7389             NMEM * resultobj = (NMEM *) malloc(sizeof(NMEM));
7390             memmove(resultobj, &result, sizeof(NMEM));
7391             ST(argvi) = sv_newmortal();
7392             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_NMEM,0);
7393         }
7394         XSRETURN(argvi);
7395         fail:
7396         (void) _swigerr;
7397     }
7398     croak(_swigerr);
7399 }
7400
7401
7402 XS(_wrap_data1_pr_tree) {
7403     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7404     const char *_swigerr = _swigmsg;
7405     {
7406         data1_handle arg1 ;
7407         data1_node *arg2 ;
7408         FILE *arg3 ;
7409         int argvi = 0;
7410         dXSARGS;
7411
7412         if ((items < 3) || (items > 3)) {
7413             SWIG_croak("Usage: data1_pr_tree(dh,n,out);");
7414         }
7415         {
7416             data1_handle * argp;
7417             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7418                 SWIG_croak("Type error in argument 1 of data1_pr_tree. Expected _p_data1_handle");
7419             }
7420             arg1 = *argp;
7421         }
7422         {
7423             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7424                 SWIG_croak("Type error in argument 2 of data1_pr_tree. Expected _p_data1_node");
7425             }
7426         }
7427         {
7428             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_FILE,0) < 0) {
7429                 SWIG_croak("Type error in argument 3 of data1_pr_tree. Expected _p_FILE");
7430             }
7431         }
7432         data1_pr_tree(arg1,arg2,arg3);
7433
7434
7435         XSRETURN(argvi);
7436         fail:
7437         (void) _swigerr;
7438     }
7439     croak(_swigerr);
7440 }
7441
7442
7443 XS(_wrap_data1_print_tree) {
7444     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7445     const char *_swigerr = _swigmsg;
7446     {
7447         data1_handle arg1 ;
7448         data1_node *arg2 ;
7449         int argvi = 0;
7450         dXSARGS;
7451
7452         if ((items < 2) || (items > 2)) {
7453             SWIG_croak("Usage: data1_print_tree(dh,n);");
7454         }
7455         {
7456             data1_handle * argp;
7457             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7458                 SWIG_croak("Type error in argument 1 of data1_print_tree. Expected _p_data1_handle");
7459             }
7460             arg1 = *argp;
7461         }
7462         {
7463             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7464                 SWIG_croak("Type error in argument 2 of data1_print_tree. Expected _p_data1_node");
7465             }
7466         }
7467         data1_print_tree(arg1,arg2);
7468
7469
7470         XSRETURN(argvi);
7471         fail:
7472         (void) _swigerr;
7473     }
7474     croak(_swigerr);
7475 }
7476
7477
7478 XS(_wrap_data1_insert_string) {
7479     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7480     const char *_swigerr = _swigmsg;
7481     {
7482         data1_handle arg1 ;
7483         data1_node *arg2 ;
7484         NMEM arg3 ;
7485         char *arg4 ;
7486         char *result;
7487         int argvi = 0;
7488         dXSARGS;
7489
7490         if ((items < 4) || (items > 4)) {
7491             SWIG_croak("Usage: data1_insert_string(dh,res,m,str);");
7492         }
7493         {
7494             data1_handle * argp;
7495             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7496                 SWIG_croak("Type error in argument 1 of data1_insert_string. Expected _p_data1_handle");
7497             }
7498             arg1 = *argp;
7499         }
7500         {
7501             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7502                 SWIG_croak("Type error in argument 2 of data1_insert_string. Expected _p_data1_node");
7503             }
7504         }
7505         {
7506             NMEM * argp;
7507             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
7508                 SWIG_croak("Type error in argument 3 of data1_insert_string. Expected _p_NMEM");
7509             }
7510             arg3 = *argp;
7511         }
7512         if (!SvOK((SV*) ST(3))) arg4 = 0;
7513         else arg4 = (char *) SvPV(ST(3), PL_na);
7514         result = (char *)data1_insert_string(arg1,arg2,arg3,(char const *)arg4);
7515
7516         ST(argvi) = sv_newmortal();
7517         if (result) {
7518             sv_setpv((SV*)ST(argvi++), (char *) result);
7519         }else {
7520             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7521         }
7522         XSRETURN(argvi);
7523         fail:
7524         (void) _swigerr;
7525     }
7526     croak(_swigerr);
7527 }
7528
7529
7530 XS(_wrap_data1_insert_string_n) {
7531     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7532     const char *_swigerr = _swigmsg;
7533     {
7534         data1_handle arg1 ;
7535         data1_node *arg2 ;
7536         NMEM arg3 ;
7537         char *arg4 ;
7538         size_t arg5 ;
7539         char *result;
7540         int argvi = 0;
7541         dXSARGS;
7542
7543         if ((items < 5) || (items > 5)) {
7544             SWIG_croak("Usage: data1_insert_string_n(dh,res,m,str,len);");
7545         }
7546         {
7547             data1_handle * argp;
7548             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7549                 SWIG_croak("Type error in argument 1 of data1_insert_string_n. Expected _p_data1_handle");
7550             }
7551             arg1 = *argp;
7552         }
7553         {
7554             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7555                 SWIG_croak("Type error in argument 2 of data1_insert_string_n. Expected _p_data1_node");
7556             }
7557         }
7558         {
7559             NMEM * argp;
7560             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
7561                 SWIG_croak("Type error in argument 3 of data1_insert_string_n. Expected _p_NMEM");
7562             }
7563             arg3 = *argp;
7564         }
7565         if (!SvOK((SV*) ST(3))) arg4 = 0;
7566         else arg4 = (char *) SvPV(ST(3), PL_na);
7567         arg5 = (size_t) SvUV(ST(4));
7568         result = (char *)data1_insert_string_n(arg1,arg2,arg3,(char const *)arg4,arg5);
7569
7570         ST(argvi) = sv_newmortal();
7571         if (result) {
7572             sv_setpv((SV*)ST(argvi++), (char *) result);
7573         }else {
7574             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7575         }
7576         XSRETURN(argvi);
7577         fail:
7578         (void) _swigerr;
7579     }
7580     croak(_swigerr);
7581 }
7582
7583
7584 XS(_wrap_data1_read_sgml) {
7585     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7586     const char *_swigerr = _swigmsg;
7587     {
7588         data1_handle arg1 ;
7589         NMEM arg2 ;
7590         char *arg3 ;
7591         data1_node *result;
7592         int argvi = 0;
7593         dXSARGS;
7594
7595         if ((items < 3) || (items > 3)) {
7596             SWIG_croak("Usage: data1_read_sgml(dh,m,buf);");
7597         }
7598         {
7599             data1_handle * argp;
7600             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7601                 SWIG_croak("Type error in argument 1 of data1_read_sgml. Expected _p_data1_handle");
7602             }
7603             arg1 = *argp;
7604         }
7605         {
7606             NMEM * argp;
7607             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
7608                 SWIG_croak("Type error in argument 2 of data1_read_sgml. Expected _p_NMEM");
7609             }
7610             arg2 = *argp;
7611         }
7612         if (!SvOK((SV*) ST(2))) arg3 = 0;
7613         else arg3 = (char *) SvPV(ST(2), PL_na);
7614         result = (data1_node *)data1_read_sgml(arg1,arg2,(char const *)arg3);
7615
7616         ST(argvi) = sv_newmortal();
7617         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
7618         XSRETURN(argvi);
7619         fail:
7620         (void) _swigerr;
7621     }
7622     croak(_swigerr);
7623 }
7624
7625
7626 XS(_wrap_data1_absyn_trav) {
7627     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7628     const char *_swigerr = _swigmsg;
7629     {
7630         data1_handle arg1 ;
7631         void *arg2 ;
7632         void (*arg3)(data1_handle,void *,data1_absyn *) ;
7633         int argvi = 0;
7634         dXSARGS;
7635
7636         if ((items < 3) || (items > 3)) {
7637             SWIG_croak("Usage: data1_absyn_trav(dh,handle,fh);");
7638         }
7639         {
7640             data1_handle * argp;
7641             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7642                 SWIG_croak("Type error in argument 1 of data1_absyn_trav. Expected _p_data1_handle");
7643             }
7644             arg1 = *argp;
7645         }
7646         {
7647             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, 0,0) < 0) {
7648                 SWIG_croak("Type error in argument 2 of data1_absyn_trav. Expected _p_void");
7649             }
7650         }
7651         {
7652             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_f_data1_handle_p_void_p_data1_absyn__void,0) < 0) {
7653                 SWIG_croak("Type error in argument 3 of data1_absyn_trav. Expected _p_f_data1_handle_p_void_p_data1_absyn__void");
7654             }
7655         }
7656         data1_absyn_trav(arg1,arg2,arg3);
7657
7658
7659         XSRETURN(argvi);
7660         fail:
7661         (void) _swigerr;
7662     }
7663     croak(_swigerr);
7664 }
7665
7666
7667 XS(_wrap_data1_attset_search_id) {
7668     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7669     const char *_swigerr = _swigmsg;
7670     {
7671         data1_handle arg1 ;
7672         int arg2 ;
7673         data1_attset *result;
7674         int argvi = 0;
7675         dXSARGS;
7676
7677         if ((items < 2) || (items > 2)) {
7678             SWIG_croak("Usage: data1_attset_search_id(dh,id);");
7679         }
7680         {
7681             data1_handle * argp;
7682             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7683                 SWIG_croak("Type error in argument 1 of data1_attset_search_id. Expected _p_data1_handle");
7684             }
7685             arg1 = *argp;
7686         }
7687         arg2 = (int) SvIV(ST(1));
7688         result = (data1_attset *)data1_attset_search_id(arg1,arg2);
7689
7690         ST(argvi) = sv_newmortal();
7691         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_attset,0);
7692         XSRETURN(argvi);
7693         fail:
7694         (void) _swigerr;
7695     }
7696     croak(_swigerr);
7697 }
7698
7699
7700 XS(_wrap_data1_getNodeValue) {
7701     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7702     const char *_swigerr = _swigmsg;
7703     {
7704         data1_node *arg1 ;
7705         char *arg2 ;
7706         char *result;
7707         int argvi = 0;
7708         dXSARGS;
7709
7710         if ((items < 2) || (items > 2)) {
7711             SWIG_croak("Usage: data1_getNodeValue(node,pTagPath);");
7712         }
7713         {
7714             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_data1_node,0) < 0) {
7715                 SWIG_croak("Type error in argument 1 of data1_getNodeValue. Expected _p_data1_node");
7716             }
7717         }
7718         if (!SvOK((SV*) ST(1))) arg2 = 0;
7719         else arg2 = (char *) SvPV(ST(1), PL_na);
7720         result = (char *)data1_getNodeValue(arg1,arg2);
7721
7722         ST(argvi) = sv_newmortal();
7723         if (result) {
7724             sv_setpv((SV*)ST(argvi++), (char *) result);
7725         }else {
7726             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7727         }
7728         XSRETURN(argvi);
7729         fail:
7730         (void) _swigerr;
7731     }
7732     croak(_swigerr);
7733 }
7734
7735
7736 XS(_wrap_data1_LookupNode) {
7737     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7738     const char *_swigerr = _swigmsg;
7739     {
7740         data1_node *arg1 ;
7741         char *arg2 ;
7742         data1_node *result;
7743         int argvi = 0;
7744         dXSARGS;
7745
7746         if ((items < 2) || (items > 2)) {
7747             SWIG_croak("Usage: data1_LookupNode(node,pTagPath);");
7748         }
7749         {
7750             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_data1_node,0) < 0) {
7751                 SWIG_croak("Type error in argument 1 of data1_LookupNode. Expected _p_data1_node");
7752             }
7753         }
7754         if (!SvOK((SV*) ST(1))) arg2 = 0;
7755         else arg2 = (char *) SvPV(ST(1), PL_na);
7756         result = (data1_node *)data1_LookupNode(arg1,arg2);
7757
7758         ST(argvi) = sv_newmortal();
7759         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
7760         XSRETURN(argvi);
7761         fail:
7762         (void) _swigerr;
7763     }
7764     croak(_swigerr);
7765 }
7766
7767
7768 XS(_wrap_data1_CountOccurences) {
7769     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7770     const char *_swigerr = _swigmsg;
7771     {
7772         data1_node *arg1 ;
7773         char *arg2 ;
7774         int result;
7775         int argvi = 0;
7776         dXSARGS;
7777
7778         if ((items < 2) || (items > 2)) {
7779             SWIG_croak("Usage: data1_CountOccurences(node,pTagPath);");
7780         }
7781         {
7782             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_data1_node,0) < 0) {
7783                 SWIG_croak("Type error in argument 1 of data1_CountOccurences. Expected _p_data1_node");
7784             }
7785         }
7786         if (!SvOK((SV*) ST(1))) arg2 = 0;
7787         else arg2 = (char *) SvPV(ST(1), PL_na);
7788         result = (int)data1_CountOccurences(arg1,arg2);
7789
7790         ST(argvi) = sv_newmortal();
7791         sv_setiv(ST(argvi++), (IV) result);
7792         XSRETURN(argvi);
7793         fail:
7794         (void) _swigerr;
7795     }
7796     croak(_swigerr);
7797 }
7798
7799
7800 XS(_wrap_data1_path_fopen) {
7801     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7802     const char *_swigerr = _swigmsg;
7803     {
7804         data1_handle arg1 ;
7805         char *arg2 ;
7806         char *arg3 ;
7807         FILE *result;
7808         int argvi = 0;
7809         dXSARGS;
7810
7811         if ((items < 3) || (items > 3)) {
7812             SWIG_croak("Usage: data1_path_fopen(dh,file,mode);");
7813         }
7814         {
7815             data1_handle * argp;
7816             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7817                 SWIG_croak("Type error in argument 1 of data1_path_fopen. Expected _p_data1_handle");
7818             }
7819             arg1 = *argp;
7820         }
7821         if (!SvOK((SV*) ST(1))) arg2 = 0;
7822         else arg2 = (char *) SvPV(ST(1), PL_na);
7823         if (!SvOK((SV*) ST(2))) arg3 = 0;
7824         else arg3 = (char *) SvPV(ST(2), PL_na);
7825         result = (FILE *)data1_path_fopen(arg1,(char const *)arg2,(char const *)arg3);
7826
7827         ST(argvi) = sv_newmortal();
7828         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_FILE,0);
7829         XSRETURN(argvi);
7830         fail:
7831         (void) _swigerr;
7832     }
7833     croak(_swigerr);
7834 }
7835
7836
7837 XS(_wrap_data1_set_tabpath) {
7838     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7839     const char *_swigerr = _swigmsg;
7840     {
7841         data1_handle arg1 ;
7842         char *arg2 ;
7843         int argvi = 0;
7844         dXSARGS;
7845
7846         if ((items < 2) || (items > 2)) {
7847             SWIG_croak("Usage: data1_set_tabpath(dh,path);");
7848         }
7849         {
7850             data1_handle * argp;
7851             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7852                 SWIG_croak("Type error in argument 1 of data1_set_tabpath. Expected _p_data1_handle");
7853             }
7854             arg1 = *argp;
7855         }
7856         if (!SvOK((SV*) ST(1))) arg2 = 0;
7857         else arg2 = (char *) SvPV(ST(1), PL_na);
7858         data1_set_tabpath(arg1,(char const *)arg2);
7859
7860
7861         XSRETURN(argvi);
7862         fail:
7863         (void) _swigerr;
7864     }
7865     croak(_swigerr);
7866 }
7867
7868
7869 XS(_wrap_data1_set_tabroot) {
7870     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7871     const char *_swigerr = _swigmsg;
7872     {
7873         data1_handle arg1 ;
7874         char *arg2 ;
7875         int argvi = 0;
7876         dXSARGS;
7877
7878         if ((items < 2) || (items > 2)) {
7879             SWIG_croak("Usage: data1_set_tabroot(dp,p);");
7880         }
7881         {
7882             data1_handle * argp;
7883             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7884                 SWIG_croak("Type error in argument 1 of data1_set_tabroot. Expected _p_data1_handle");
7885             }
7886             arg1 = *argp;
7887         }
7888         if (!SvOK((SV*) ST(1))) arg2 = 0;
7889         else arg2 = (char *) SvPV(ST(1), PL_na);
7890         data1_set_tabroot(arg1,(char const *)arg2);
7891
7892
7893         XSRETURN(argvi);
7894         fail:
7895         (void) _swigerr;
7896     }
7897     croak(_swigerr);
7898 }
7899
7900
7901 XS(_wrap_data1_get_tabpath) {
7902     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7903     const char *_swigerr = _swigmsg;
7904     {
7905         data1_handle arg1 ;
7906         char *result;
7907         int argvi = 0;
7908         dXSARGS;
7909
7910         if ((items < 1) || (items > 1)) {
7911             SWIG_croak("Usage: data1_get_tabpath(dh);");
7912         }
7913         {
7914             data1_handle * argp;
7915             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7916                 SWIG_croak("Type error in argument 1 of data1_get_tabpath. Expected _p_data1_handle");
7917             }
7918             arg1 = *argp;
7919         }
7920         result = (char *)data1_get_tabpath(arg1);
7921
7922         ST(argvi) = sv_newmortal();
7923         if (result) {
7924             sv_setpv((SV*)ST(argvi++), (char *) result);
7925         }else {
7926             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7927         }
7928         XSRETURN(argvi);
7929         fail:
7930         (void) _swigerr;
7931     }
7932     croak(_swigerr);
7933 }
7934
7935
7936 XS(_wrap_data1_get_tabroot) {
7937     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7938     const char *_swigerr = _swigmsg;
7939     {
7940         data1_handle arg1 ;
7941         char *result;
7942         int argvi = 0;
7943         dXSARGS;
7944
7945         if ((items < 1) || (items > 1)) {
7946             SWIG_croak("Usage: data1_get_tabroot(dh);");
7947         }
7948         {
7949             data1_handle * argp;
7950             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7951                 SWIG_croak("Type error in argument 1 of data1_get_tabroot. Expected _p_data1_handle");
7952             }
7953             arg1 = *argp;
7954         }
7955         result = (char *)data1_get_tabroot(arg1);
7956
7957         ST(argvi) = sv_newmortal();
7958         if (result) {
7959             sv_setpv((SV*)ST(argvi++), (char *) result);
7960         }else {
7961             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7962         }
7963         XSRETURN(argvi);
7964         fail:
7965         (void) _swigerr;
7966     }
7967     croak(_swigerr);
7968 }
7969
7970
7971 XS(_wrap_grs_perl_readf) {
7972     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7973     const char *_swigerr = _swigmsg;
7974     {
7975         struct perl_context *arg1 ;
7976         size_t arg2 ;
7977         int result;
7978         int argvi = 0;
7979         dXSARGS;
7980
7981         if ((items < 2) || (items > 2)) {
7982             SWIG_croak("Usage: grs_perl_readf(context,len);");
7983         }
7984         {
7985             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
7986                 SWIG_croak("Type error in argument 1 of grs_perl_readf. Expected _p_perl_context");
7987             }
7988         }
7989         arg2 = (size_t) SvUV(ST(1));
7990         result = (int)grs_perl_readf(arg1,arg2);
7991
7992         ST(argvi) = sv_newmortal();
7993         sv_setiv(ST(argvi++), (IV) result);
7994         XSRETURN(argvi);
7995         fail:
7996         (void) _swigerr;
7997     }
7998     croak(_swigerr);
7999 }
8000
8001
8002 XS(_wrap_grs_perl_readline) {
8003     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8004     const char *_swigerr = _swigmsg;
8005     {
8006         struct perl_context *arg1 ;
8007         int result;
8008         int argvi = 0;
8009         dXSARGS;
8010
8011         if ((items < 1) || (items > 1)) {
8012             SWIG_croak("Usage: grs_perl_readline(context);");
8013         }
8014         {
8015             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8016                 SWIG_croak("Type error in argument 1 of grs_perl_readline. Expected _p_perl_context");
8017             }
8018         }
8019         result = (int)grs_perl_readline(arg1);
8020
8021         ST(argvi) = sv_newmortal();
8022         sv_setiv(ST(argvi++), (IV) result);
8023         XSRETURN(argvi);
8024         fail:
8025         (void) _swigerr;
8026     }
8027     croak(_swigerr);
8028 }
8029
8030
8031 XS(_wrap_grs_perl_getc) {
8032     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8033     const char *_swigerr = _swigmsg;
8034     {
8035         struct perl_context *arg1 ;
8036         char result;
8037         int argvi = 0;
8038         dXSARGS;
8039
8040         if ((items < 1) || (items > 1)) {
8041             SWIG_croak("Usage: grs_perl_getc(context);");
8042         }
8043         {
8044             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8045                 SWIG_croak("Type error in argument 1 of grs_perl_getc. Expected _p_perl_context");
8046             }
8047         }
8048         result = (char)grs_perl_getc(arg1);
8049
8050         ST(argvi) = sv_newmortal();
8051         sv_setpvn((SV*)ST(argvi++), &result, 1);
8052         XSRETURN(argvi);
8053         fail:
8054         (void) _swigerr;
8055     }
8056     croak(_swigerr);
8057 }
8058
8059
8060 XS(_wrap_grs_perl_seekf) {
8061     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8062     const char *_swigerr = _swigmsg;
8063     {
8064         struct perl_context *arg1 ;
8065         off_t arg2 ;
8066         off_t result;
8067         int argvi = 0;
8068         dXSARGS;
8069
8070         if ((items < 2) || (items > 2)) {
8071             SWIG_croak("Usage: grs_perl_seekf(context,offset);");
8072         }
8073         {
8074             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8075                 SWIG_croak("Type error in argument 1 of grs_perl_seekf. Expected _p_perl_context");
8076             }
8077         }
8078         {
8079             off_t * argp;
8080             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_off_t,0) < 0) {
8081                 SWIG_croak("Type error in argument 2 of grs_perl_seekf. Expected _p_off_t");
8082             }
8083             arg2 = *argp;
8084         }
8085         result = grs_perl_seekf(arg1,arg2);
8086
8087         {
8088             off_t * resultobj = (off_t *) malloc(sizeof(off_t));
8089             memmove(resultobj, &result, sizeof(off_t));
8090             ST(argvi) = sv_newmortal();
8091             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_off_t,0);
8092         }
8093         XSRETURN(argvi);
8094         fail:
8095         (void) _swigerr;
8096     }
8097     croak(_swigerr);
8098 }
8099
8100
8101 XS(_wrap_grs_perl_tellf) {
8102     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8103     const char *_swigerr = _swigmsg;
8104     {
8105         struct perl_context *arg1 ;
8106         off_t result;
8107         int argvi = 0;
8108         dXSARGS;
8109
8110         if ((items < 1) || (items > 1)) {
8111             SWIG_croak("Usage: grs_perl_tellf(context);");
8112         }
8113         {
8114             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8115                 SWIG_croak("Type error in argument 1 of grs_perl_tellf. Expected _p_perl_context");
8116             }
8117         }
8118         result = grs_perl_tellf(arg1);
8119
8120         {
8121             off_t * resultobj = (off_t *) malloc(sizeof(off_t));
8122             memmove(resultobj, &result, sizeof(off_t));
8123             ST(argvi) = sv_newmortal();
8124             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_off_t,0);
8125         }
8126         XSRETURN(argvi);
8127         fail:
8128         (void) _swigerr;
8129     }
8130     croak(_swigerr);
8131 }
8132
8133
8134 XS(_wrap_grs_perl_endf) {
8135     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8136     const char *_swigerr = _swigmsg;
8137     {
8138         struct perl_context *arg1 ;
8139         off_t arg2 ;
8140         int argvi = 0;
8141         dXSARGS;
8142
8143         if ((items < 2) || (items > 2)) {
8144             SWIG_croak("Usage: grs_perl_endf(context,offset);");
8145         }
8146         {
8147             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8148                 SWIG_croak("Type error in argument 1 of grs_perl_endf. Expected _p_perl_context");
8149             }
8150         }
8151         {
8152             off_t * argp;
8153             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_off_t,0) < 0) {
8154                 SWIG_croak("Type error in argument 2 of grs_perl_endf. Expected _p_off_t");
8155             }
8156             arg2 = *argp;
8157         }
8158         grs_perl_endf(arg1,arg2);
8159
8160
8161         XSRETURN(argvi);
8162         fail:
8163         (void) _swigerr;
8164     }
8165     croak(_swigerr);
8166 }
8167
8168
8169 XS(_wrap_grs_perl_get_dh) {
8170     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8171     const char *_swigerr = _swigmsg;
8172     {
8173         struct perl_context *arg1 ;
8174         data1_handle *result;
8175         int argvi = 0;
8176         dXSARGS;
8177
8178         if ((items < 1) || (items > 1)) {
8179             SWIG_croak("Usage: grs_perl_get_dh(context);");
8180         }
8181         {
8182             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8183                 SWIG_croak("Type error in argument 1 of grs_perl_get_dh. Expected _p_perl_context");
8184             }
8185         }
8186         result = (data1_handle *)grs_perl_get_dh(arg1);
8187
8188         ST(argvi) = sv_newmortal();
8189         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_handle,0);
8190         XSRETURN(argvi);
8191         fail:
8192         (void) _swigerr;
8193     }
8194     croak(_swigerr);
8195 }
8196
8197
8198 XS(_wrap_grs_perl_get_mem) {
8199     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8200     const char *_swigerr = _swigmsg;
8201     {
8202         struct perl_context *arg1 ;
8203         NMEM *result;
8204         int argvi = 0;
8205         dXSARGS;
8206
8207         if ((items < 1) || (items > 1)) {
8208             SWIG_croak("Usage: grs_perl_get_mem(context);");
8209         }
8210         {
8211             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8212                 SWIG_croak("Type error in argument 1 of grs_perl_get_mem. Expected _p_perl_context");
8213             }
8214         }
8215         result = (NMEM *)grs_perl_get_mem(arg1);
8216
8217         ST(argvi) = sv_newmortal();
8218         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_NMEM,0);
8219         XSRETURN(argvi);
8220         fail:
8221         (void) _swigerr;
8222     }
8223     croak(_swigerr);
8224 }
8225
8226
8227 XS(_wrap_grs_perl_set_res) {
8228     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8229     const char *_swigerr = _swigmsg;
8230     {
8231         struct perl_context *arg1 ;
8232         data1_node *arg2 ;
8233         int argvi = 0;
8234         dXSARGS;
8235
8236         if ((items < 2) || (items > 2)) {
8237             SWIG_croak("Usage: grs_perl_set_res(context,n);");
8238         }
8239         {
8240             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8241                 SWIG_croak("Type error in argument 1 of grs_perl_set_res. Expected _p_perl_context");
8242             }
8243         }
8244         {
8245             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
8246                 SWIG_croak("Type error in argument 2 of grs_perl_set_res. Expected _p_data1_node");
8247             }
8248         }
8249         grs_perl_set_res(arg1,arg2);
8250
8251
8252         XSRETURN(argvi);
8253         fail:
8254         (void) _swigerr;
8255     }
8256     croak(_swigerr);
8257 }
8258
8259
8260
8261 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
8262
8263 static swig_type_info _swigt__p_ZebraService[] = {{"_p_ZebraService", 0, "ZebraService *", 0},{"_p_ZebraService"},{0}};
8264 static swig_type_info _swigt__p_cql_transform_t[] = {{"_p_cql_transform_t", 0, "cql_transform_t *", 0},{"_p_cql_transform_t"},{0}};
8265 static swig_type_info _swigt__p_data1_esetname[] = {{"_p_data1_esetname", 0, "data1_esetname *", 0},{"_p_data1_esetname"},{0}};
8266 static swig_type_info _swigt__p_data1_maptab[] = {{"_p_data1_maptab", 0, "data1_maptab *", 0},{"_p_data1_maptab"},{0}};
8267 static swig_type_info _swigt__p_ODR[] = {{"_p_ODR", 0, "ODR *", 0},{"_p_ODR"},{0}};
8268 static swig_type_info _swigt__p_f_p_void__int[] = {{"_p_f_p_void__int", 0, "int (*)(void *)", 0},{"_p_f_p_void__int"},{0}};
8269 static swig_type_info _swigt__p_p_char[] = {{"_p_p_char", 0, "char **", 0},{"_p_p_char"},{0}};
8270 static swig_type_info _swigt__p_data1_absyn[] = {{"_p_data1_absyn", 0, "data1_absyn *", 0},{"_p_data1_absyn"},{0}};
8271 static swig_type_info _swigt__p_ZebraHandle[] = {{"_p_ZebraHandle", 0, "ZebraHandle *", 0},{"_p_ZebraHandle"},{0}};
8272 static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0},{"_p_void"},{0}};
8273 static swig_type_info _swigt__p_data1_attset[] = {{"_p_data1_attset", 0, "data1_attset *", 0},{"_p_data1_attset"},{0}};
8274 static swig_type_info _swigt__p_size_t[] = {{"_p_size_t", 0, "size_t *", 0},{"_p_size_t"},{0}};
8275 static swig_type_info _swigt__p_WRBUF[] = {{"_p_WRBUF", 0, "WRBUF *", 0},{"_p_WRBUF"},{0}};
8276 static swig_type_info _swigt__p_f_data1_handle_p_void_p_data1_absyn__void[] = {{"_p_f_data1_handle_p_void_p_data1_absyn__void", 0, "void (*)(data1_handle,void *,data1_absyn *)", 0},{"_p_f_data1_handle_p_void_p_data1_absyn__void"},{0}};
8277 static swig_type_info _swigt__p_Z_Espec1[] = {{"_p_Z_Espec1", 0, "Z_Espec1 *", 0},{"_p_Z_Espec1"},{0}};
8278 static swig_type_info _swigt__p_off_t[] = {{"_p_off_t", 0, "off_t *", 0},{"_p_off_t"},{0}};
8279 static swig_type_info _swigt__p_Odr_oid[] = {{"_p_Odr_oid", 0, "Odr_oid *", 0},{"_p_Odr_oid"},{0}};
8280 static swig_type_info _swigt__p_data1_varset[] = {{"_p_data1_varset", 0, "data1_varset *", 0},{"_p_data1_varset"},{0}};
8281 static swig_type_info _swigt__p_RetrievalRecordBuf[] = {{"_p_RetrievalRecordBuf", 0, "RetrievalRecordBuf *", 0},{"_p_RetrievalRecordBuf"},{0}};
8282 static swig_type_info _swigt__p_perl_context[] = {{"_p_perl_context", 0, "struct perl_context *", 0},{"_p_perl_context"},{0}};
8283 static swig_type_info _swigt__p_data1_node[] = {{"_p_data1_node", 0, "data1_node *", 0},{"_p_data1_node"},{0}};
8284 static swig_type_info _swigt__p_ScanObj[] = {{"IDZebra::ScanObj", 0, "ScanObj *", 0},{"IDZebra::ScanObj"},{0}};
8285 static swig_type_info _swigt__p_RetrievalObj[] = {{"IDZebra::RetrievalObj", 0, "RetrievalObj *", 0},{"IDZebra::RetrievalObj"},{0}};
8286 static swig_type_info _swigt__p_data1_tagset[] = {{"_p_data1_tagset", 0, "data1_tagset *", 0},{"_p_data1_tagset"},{0}};
8287 static swig_type_info _swigt__p_data1_tag[] = {{"_p_data1_tag", 0, "data1_tag *", 0},{"_p_data1_tag"},{0}};
8288 static swig_type_info _swigt__p_ZebraRetrievalRecord[] = {{"_p_ZebraRetrievalRecord", 0, "ZebraRetrievalRecord *", 0},{"_p_ZebraRetrievalRecord"},{0}};
8289 static swig_type_info _swigt__p_RetrievalRecord[] = {{"IDZebra::RetrievalRecord", 0, "RetrievalRecord *", 0},{"IDZebra::RetrievalRecord"},{0}};
8290 static swig_type_info _swigt__p_NMEM[] = {{"_p_NMEM", 0, "NMEM *", 0},{"_p_NMEM"},{0}};
8291 static swig_type_info _swigt__p_Z_ExplainRecord[] = {{"_p_Z_ExplainRecord", 0, "Z_ExplainRecord *", 0},{"_p_Z_ExplainRecord"},{0}};
8292 static swig_type_info _swigt__p_data1_marctab[] = {{"_p_data1_marctab", 0, "data1_marctab *", 0},{"_p_data1_marctab"},{0}};
8293 static swig_type_info _swigt__p_ZebraTransactionStatus[] = {{"IDZebra::ZebraTransactionStatus", 0, "ZebraTransactionStatus *", 0},{"IDZebra::ZebraTransactionStatus"},{0}};
8294 static swig_type_info _swigt__p_Z_BriefBib[] = {{"_p_Z_BriefBib", 0, "Z_BriefBib *", 0},{"_p_Z_BriefBib"},{0}};
8295 static swig_type_info _swigt__p_scanEntry[] = {{"IDZebra::scanEntry", 0, "scanEntry *", 0},{"IDZebra::scanEntry"},{0}};
8296 static swig_type_info _swigt__p_f_p_void_p_char_size_t__int[] = {{"_p_f_p_void_p_char_size_t__int", 0, "int (*)(void *,char *,size_t)", 0},{"_p_f_p_void_p_char_size_t__int"},{0}};
8297 static swig_type_info _swigt__p_FILE[] = {{"_p_FILE", 0, "FILE *", 0},{"_p_FILE"},{0}};
8298 static swig_type_info _swigt__p_data1_element[] = {{"_p_data1_element", 0, "data1_element *", 0},{"_p_data1_element"},{0}};
8299 static swig_type_info _swigt__p_recordGroup[] = {{"IDZebra::recordGroup", 0, "recordGroup *", 0},{"IDZebra::recordGroup"},{0}};
8300 static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0},{"_p_int"},{0}};
8301 static swig_type_info _swigt__p_data1_handle[] = {{"_p_data1_handle", 0, "data1_handle *", 0},{"_p_data1_handle"},{0}};
8302 static swig_type_info _swigt__p_p_int[] = {{"_p_p_int", 0, "int **", 0},{"_p_p_int"},{0}};
8303 static swig_type_info _swigt__p_data1_absyn_cache[] = {{"_p_data1_absyn_cache", 0, "data1_absyn_cache *", 0},{"_p_data1_absyn_cache"},{0}};
8304 static swig_type_info _swigt__p_data1_attset_cache[] = {{"_p_data1_attset_cache", 0, "data1_attset_cache *", 0},{"_p_data1_attset_cache"},{0}};
8305 static swig_type_info _swigt__p_Z_GenericRecord[] = {{"_p_Z_GenericRecord", 0, "Z_GenericRecord *", 0},{"_p_Z_GenericRecord"},{0}};
8306 static swig_type_info _swigt__p_data1_vartype[] = {{"_p_data1_vartype", 0, "data1_vartype *", 0},{"_p_data1_vartype"},{0}};
8307
8308 static swig_type_info *swig_types_initial[] = {
8309 _swigt__p_ZebraService,
8310 _swigt__p_cql_transform_t,
8311 _swigt__p_data1_esetname,
8312 _swigt__p_data1_maptab,
8313 _swigt__p_ODR,
8314 _swigt__p_f_p_void__int,
8315 _swigt__p_p_char,
8316 _swigt__p_data1_absyn,
8317 _swigt__p_ZebraHandle,
8318 _swigt__p_void,
8319 _swigt__p_data1_attset,
8320 _swigt__p_size_t,
8321 _swigt__p_WRBUF,
8322 _swigt__p_f_data1_handle_p_void_p_data1_absyn__void,
8323 _swigt__p_Z_Espec1,
8324 _swigt__p_off_t,
8325 _swigt__p_Odr_oid,
8326 _swigt__p_data1_varset,
8327 _swigt__p_RetrievalRecordBuf,
8328 _swigt__p_perl_context,
8329 _swigt__p_data1_node,
8330 _swigt__p_ScanObj,
8331 _swigt__p_RetrievalObj,
8332 _swigt__p_data1_tagset,
8333 _swigt__p_data1_tag,
8334 _swigt__p_ZebraRetrievalRecord,
8335 _swigt__p_RetrievalRecord,
8336 _swigt__p_NMEM,
8337 _swigt__p_Z_ExplainRecord,
8338 _swigt__p_data1_marctab,
8339 _swigt__p_ZebraTransactionStatus,
8340 _swigt__p_Z_BriefBib,
8341 _swigt__p_scanEntry,
8342 _swigt__p_f_p_void_p_char_size_t__int,
8343 _swigt__p_FILE,
8344 _swigt__p_data1_element,
8345 _swigt__p_recordGroup,
8346 _swigt__p_int,
8347 _swigt__p_data1_handle,
8348 _swigt__p_p_int,
8349 _swigt__p_data1_absyn_cache,
8350 _swigt__p_data1_attset_cache,
8351 _swigt__p_Z_GenericRecord,
8352 _swigt__p_data1_vartype,
8353 0
8354 };
8355
8356
8357 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
8358
8359 static swig_constant_info swig_constants[] = {
8360 { SWIG_INT,     (char *) SWIG_prefix "LOG_FATAL", (long) 0x0001, 0, 0, 0},
8361 { SWIG_INT,     (char *) SWIG_prefix "LOG_DEBUG", (long) 0x0002, 0, 0, 0},
8362 { SWIG_INT,     (char *) SWIG_prefix "LOG_WARN", (long) 0x0004, 0, 0, 0},
8363 { SWIG_INT,     (char *) SWIG_prefix "LOG_LOG", (long) 0x0008, 0, 0, 0},
8364 { SWIG_INT,     (char *) SWIG_prefix "LOG_ERRNO", (long) 0x0010, 0, 0, 0},
8365 { SWIG_INT,     (char *) SWIG_prefix "LOG_FILE", (long) 0x0020, 0, 0, 0},
8366 { SWIG_INT,     (char *) SWIG_prefix "LOG_APP", (long) 0x0040, 0, 0, 0},
8367 { SWIG_INT,     (char *) SWIG_prefix "LOG_MALLOC", (long) 0x0080, 0, 0, 0},
8368 { SWIG_INT,     (char *) SWIG_prefix "LOG_ALL", (long) 0xff7f, 0, 0, 0},
8369 { SWIG_INT,     (char *) SWIG_prefix "LOG_DEFAULT_LEVEL", (long) (0x0001|0x0010|0x0008|0x0004), 0, 0, 0},
8370 { SWIG_INT,     (char *) SWIG_prefix "ODR_DECODE", (long) 0, 0, 0, 0},
8371 { SWIG_INT,     (char *) SWIG_prefix "ODR_ENCODE", (long) 1, 0, 0, 0},
8372 { SWIG_INT,     (char *) SWIG_prefix "ODR_PRINT", (long) 2, 0, 0, 0},
8373 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_unknown", (long) DATA1K_unknown, 0, 0, 0},
8374 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_structured", (long) DATA1K_structured, 0, 0, 0},
8375 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_string", (long) DATA1K_string, 0, 0, 0},
8376 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_numeric", (long) DATA1K_numeric, 0, 0, 0},
8377 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_bool", (long) DATA1K_bool, 0, 0, 0},
8378 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_oid", (long) DATA1K_oid, 0, 0, 0},
8379 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_generalizedtime", (long) DATA1K_generalizedtime, 0, 0, 0},
8380 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_intunit", (long) DATA1K_intunit, 0, 0, 0},
8381 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_int", (long) DATA1K_int, 0, 0, 0},
8382 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_octetstring", (long) DATA1K_octetstring, 0, 0, 0},
8383 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_null", (long) DATA1K_null, 0, 0, 0},
8384 { SWIG_INT,     (char *) SWIG_prefix "DATA1T_numeric", (long) 1, 0, 0, 0},
8385 { SWIG_INT,     (char *) SWIG_prefix "DATA1T_string", (long) 2, 0, 0, 0},
8386 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_root", (long) 1, 0, 0, 0},
8387 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_tag", (long) 2, 0, 0, 0},
8388 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_data", (long) 3, 0, 0, 0},
8389 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_variant", (long) 4, 0, 0, 0},
8390 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_comment", (long) 5, 0, 0, 0},
8391 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_preprocess", (long) 6, 0, 0, 0},
8392 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_inctxt", (long) 1, 0, 0, 0},
8393 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_incbin", (long) 2, 0, 0, 0},
8394 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_text", (long) 3, 0, 0, 0},
8395 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_num", (long) 4, 0, 0, 0},
8396 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_oid", (long) 5, 0, 0, 0},
8397 { SWIG_INT,     (char *) SWIG_prefix "DATA1_LOCALDATA", (long) 12, 0, 0, 0},
8398 { SWIG_INT,     (char *) SWIG_prefix "DATA1_FLAG_XML", (long) 1, 0, 0, 0},
8399 {0}
8400 };
8401 #ifdef __cplusplus
8402 }
8403 #endif
8404 static swig_variable_info swig_variables[] = {
8405 {0}
8406 };
8407 static swig_command_info swig_commands[] = {
8408 {"IDZebrac::recordGroup_groupName_set", _wrap_recordGroup_groupName_set},
8409 {"IDZebrac::recordGroup_groupName_get", _wrap_recordGroup_groupName_get},
8410 {"IDZebrac::recordGroup_databaseName_set", _wrap_recordGroup_databaseName_set},
8411 {"IDZebrac::recordGroup_databaseName_get", _wrap_recordGroup_databaseName_get},
8412 {"IDZebrac::recordGroup_path_set", _wrap_recordGroup_path_set},
8413 {"IDZebrac::recordGroup_path_get", _wrap_recordGroup_path_get},
8414 {"IDZebrac::recordGroup_recordId_set", _wrap_recordGroup_recordId_set},
8415 {"IDZebrac::recordGroup_recordId_get", _wrap_recordGroup_recordId_get},
8416 {"IDZebrac::recordGroup_recordType_set", _wrap_recordGroup_recordType_set},
8417 {"IDZebrac::recordGroup_recordType_get", _wrap_recordGroup_recordType_get},
8418 {"IDZebrac::recordGroup_flagStoreData_set", _wrap_recordGroup_flagStoreData_set},
8419 {"IDZebrac::recordGroup_flagStoreData_get", _wrap_recordGroup_flagStoreData_get},
8420 {"IDZebrac::recordGroup_flagStoreKeys_set", _wrap_recordGroup_flagStoreKeys_set},
8421 {"IDZebrac::recordGroup_flagStoreKeys_get", _wrap_recordGroup_flagStoreKeys_get},
8422 {"IDZebrac::recordGroup_flagRw_set", _wrap_recordGroup_flagRw_set},
8423 {"IDZebrac::recordGroup_flagRw_get", _wrap_recordGroup_flagRw_get},
8424 {"IDZebrac::recordGroup_fileVerboseLimit_set", _wrap_recordGroup_fileVerboseLimit_set},
8425 {"IDZebrac::recordGroup_fileVerboseLimit_get", _wrap_recordGroup_fileVerboseLimit_get},
8426 {"IDZebrac::recordGroup_databaseNamePath_set", _wrap_recordGroup_databaseNamePath_set},
8427 {"IDZebrac::recordGroup_databaseNamePath_get", _wrap_recordGroup_databaseNamePath_get},
8428 {"IDZebrac::recordGroup_explainDatabase_set", _wrap_recordGroup_explainDatabase_set},
8429 {"IDZebrac::recordGroup_explainDatabase_get", _wrap_recordGroup_explainDatabase_get},
8430 {"IDZebrac::recordGroup_followLinks_set", _wrap_recordGroup_followLinks_set},
8431 {"IDZebrac::recordGroup_followLinks_get", _wrap_recordGroup_followLinks_get},
8432 {"IDZebrac::new_recordGroup", _wrap_new_recordGroup},
8433 {"IDZebrac::delete_recordGroup", _wrap_delete_recordGroup},
8434 {"IDZebrac::RetrievalObj_noOfRecords_set", _wrap_RetrievalObj_noOfRecords_set},
8435 {"IDZebrac::RetrievalObj_noOfRecords_get", _wrap_RetrievalObj_noOfRecords_get},
8436 {"IDZebrac::RetrievalObj_records_set", _wrap_RetrievalObj_records_set},
8437 {"IDZebrac::RetrievalObj_records_get", _wrap_RetrievalObj_records_get},
8438 {"IDZebrac::new_RetrievalObj", _wrap_new_RetrievalObj},
8439 {"IDZebrac::delete_RetrievalObj", _wrap_delete_RetrievalObj},
8440 {"IDZebrac::RetrievalRecord_errCode_set", _wrap_RetrievalRecord_errCode_set},
8441 {"IDZebrac::RetrievalRecord_errCode_get", _wrap_RetrievalRecord_errCode_get},
8442 {"IDZebrac::RetrievalRecord_errString_set", _wrap_RetrievalRecord_errString_set},
8443 {"IDZebrac::RetrievalRecord_errString_get", _wrap_RetrievalRecord_errString_get},
8444 {"IDZebrac::RetrievalRecord_position_set", _wrap_RetrievalRecord_position_set},
8445 {"IDZebrac::RetrievalRecord_position_get", _wrap_RetrievalRecord_position_get},
8446 {"IDZebrac::RetrievalRecord_base_set", _wrap_RetrievalRecord_base_set},
8447 {"IDZebrac::RetrievalRecord_base_get", _wrap_RetrievalRecord_base_get},
8448 {"IDZebrac::RetrievalRecord_sysno_set", _wrap_RetrievalRecord_sysno_set},
8449 {"IDZebrac::RetrievalRecord_sysno_get", _wrap_RetrievalRecord_sysno_get},
8450 {"IDZebrac::RetrievalRecord_score_set", _wrap_RetrievalRecord_score_set},
8451 {"IDZebrac::RetrievalRecord_score_get", _wrap_RetrievalRecord_score_get},
8452 {"IDZebrac::RetrievalRecord_format_set", _wrap_RetrievalRecord_format_set},
8453 {"IDZebrac::RetrievalRecord_format_get", _wrap_RetrievalRecord_format_get},
8454 {"IDZebrac::RetrievalRecord_buf_set", _wrap_RetrievalRecord_buf_set},
8455 {"IDZebrac::RetrievalRecord_buf_get", _wrap_RetrievalRecord_buf_get},
8456 {"IDZebrac::new_RetrievalRecord", _wrap_new_RetrievalRecord},
8457 {"IDZebrac::delete_RetrievalRecord", _wrap_delete_RetrievalRecord},
8458 {"IDZebrac::scanEntry_occurrences_set", _wrap_scanEntry_occurrences_set},
8459 {"IDZebrac::scanEntry_occurrences_get", _wrap_scanEntry_occurrences_get},
8460 {"IDZebrac::scanEntry_term_set", _wrap_scanEntry_term_set},
8461 {"IDZebrac::scanEntry_term_get", _wrap_scanEntry_term_get},
8462 {"IDZebrac::new_scanEntry", _wrap_new_scanEntry},
8463 {"IDZebrac::delete_scanEntry", _wrap_delete_scanEntry},
8464 {"IDZebrac::ScanObj_num_entries_set", _wrap_ScanObj_num_entries_set},
8465 {"IDZebrac::ScanObj_num_entries_get", _wrap_ScanObj_num_entries_get},
8466 {"IDZebrac::ScanObj_position_set", _wrap_ScanObj_position_set},
8467 {"IDZebrac::ScanObj_position_get", _wrap_ScanObj_position_get},
8468 {"IDZebrac::ScanObj_is_partial_set", _wrap_ScanObj_is_partial_set},
8469 {"IDZebrac::ScanObj_is_partial_get", _wrap_ScanObj_is_partial_get},
8470 {"IDZebrac::ScanObj_entries_set", _wrap_ScanObj_entries_set},
8471 {"IDZebrac::ScanObj_entries_get", _wrap_ScanObj_entries_get},
8472 {"IDZebrac::new_ScanObj", _wrap_new_ScanObj},
8473 {"IDZebrac::delete_ScanObj", _wrap_delete_ScanObj},
8474 {"IDZebrac::ZebraTransactionStatus_processed_set", _wrap_ZebraTransactionStatus_processed_set},
8475 {"IDZebrac::ZebraTransactionStatus_processed_get", _wrap_ZebraTransactionStatus_processed_get},
8476 {"IDZebrac::ZebraTransactionStatus_inserted_set", _wrap_ZebraTransactionStatus_inserted_set},
8477 {"IDZebrac::ZebraTransactionStatus_inserted_get", _wrap_ZebraTransactionStatus_inserted_get},
8478 {"IDZebrac::ZebraTransactionStatus_updated_set", _wrap_ZebraTransactionStatus_updated_set},
8479 {"IDZebrac::ZebraTransactionStatus_updated_get", _wrap_ZebraTransactionStatus_updated_get},
8480 {"IDZebrac::ZebraTransactionStatus_deleted_set", _wrap_ZebraTransactionStatus_deleted_set},
8481 {"IDZebrac::ZebraTransactionStatus_deleted_get", _wrap_ZebraTransactionStatus_deleted_get},
8482 {"IDZebrac::ZebraTransactionStatus_utime_set", _wrap_ZebraTransactionStatus_utime_set},
8483 {"IDZebrac::ZebraTransactionStatus_utime_get", _wrap_ZebraTransactionStatus_utime_get},
8484 {"IDZebrac::ZebraTransactionStatus_stime_set", _wrap_ZebraTransactionStatus_stime_set},
8485 {"IDZebrac::ZebraTransactionStatus_stime_get", _wrap_ZebraTransactionStatus_stime_get},
8486 {"IDZebrac::new_ZebraTransactionStatus", _wrap_new_ZebraTransactionStatus},
8487 {"IDZebrac::delete_ZebraTransactionStatus", _wrap_delete_ZebraTransactionStatus},
8488 {"IDZebrac::DESTROY", _wrap_DESTROY},
8489 {"IDZebrac::logLevel", _wrap_logLevel},
8490 {"IDZebrac::logFile", _wrap_logFile},
8491 {"IDZebrac::logMsg", _wrap_logMsg},
8492 {"IDZebrac::odr_createmem", _wrap_odr_createmem},
8493 {"IDZebrac::odr_reset", _wrap_odr_reset},
8494 {"IDZebrac::odr_destroy", _wrap_odr_destroy},
8495 {"IDZebrac::odr_malloc", _wrap_odr_malloc},
8496 {"IDZebrac::start", _wrap_start},
8497 {"IDZebrac::open", _wrap_open},
8498 {"IDZebrac::close", _wrap_close},
8499 {"IDZebrac::stop", _wrap_stop},
8500 {"IDZebrac::errCode", _wrap_errCode},
8501 {"IDZebrac::errString", _wrap_errString},
8502 {"IDZebrac::errAdd", _wrap_errAdd},
8503 {"IDZebrac::init_recordGroup", _wrap_init_recordGroup},
8504 {"IDZebrac::res_get_recordGroup", _wrap_res_get_recordGroup},
8505 {"IDZebrac::set_group", _wrap_set_group},
8506 {"IDZebrac::select_database", _wrap_select_database},
8507 {"IDZebrac::select_databases", _wrap_select_databases},
8508 {"IDZebrac::begin_trans", _wrap_begin_trans},
8509 {"IDZebrac::end_trans", _wrap_end_trans},
8510 {"IDZebrac::trans_no", _wrap_trans_no},
8511 {"IDZebrac::begin_read", _wrap_begin_read},
8512 {"IDZebrac::end_read", _wrap_end_read},
8513 {"IDZebrac::commit", _wrap_commit},
8514 {"IDZebrac::get_shadow_enable", _wrap_get_shadow_enable},
8515 {"IDZebrac::set_shadow_enable", _wrap_set_shadow_enable},
8516 {"IDZebrac::init", _wrap_init},
8517 {"IDZebrac::compact", _wrap_compact},
8518 {"IDZebrac::repository_update", _wrap_repository_update},
8519 {"IDZebrac::repository_delete", _wrap_repository_delete},
8520 {"IDZebrac::repository_show", _wrap_repository_show},
8521 {"IDZebrac::update_record", _wrap_update_record},
8522 {"IDZebrac::delete_record", _wrap_delete_record},
8523 {"IDZebrac::search_PQF", _wrap_search_PQF},
8524 {"IDZebrac::cql_transform_open_fname", _wrap_cql_transform_open_fname},
8525 {"IDZebrac::cql_transform_close", _wrap_cql_transform_close},
8526 {"IDZebrac::cql_transform_error", _wrap_cql_transform_error},
8527 {"IDZebrac::cql2pqf", _wrap_cql2pqf},
8528 {"IDZebrac::records_retrieve", _wrap_records_retrieve},
8529 {"IDZebrac::record_retrieve", _wrap_record_retrieve},
8530 {"IDZebrac::deleteResultSet", _wrap_deleteResultSet},
8531 {"IDZebrac::sort", _wrap_sort},
8532 {"IDZebrac::scan_PQF", _wrap_scan_PQF},
8533 {"IDZebrac::getScanEntry", _wrap_getScanEntry},
8534 {"IDZebrac::nmem_create", _wrap_nmem_create},
8535 {"IDZebrac::nmem_destroy", _wrap_nmem_destroy},
8536 {"IDZebrac::data1_create", _wrap_data1_create},
8537 {"IDZebrac::data1_createx", _wrap_data1_createx},
8538 {"IDZebrac::data1_destroy", _wrap_data1_destroy},
8539 {"IDZebrac::get_parent_tag", _wrap_get_parent_tag},
8540 {"IDZebrac::data1_read_node", _wrap_data1_read_node},
8541 {"IDZebrac::data1_read_nodex", _wrap_data1_read_nodex},
8542 {"IDZebrac::data1_read_record", _wrap_data1_read_record},
8543 {"IDZebrac::data1_read_absyn", _wrap_data1_read_absyn},
8544 {"IDZebrac::data1_gettagbynum", _wrap_data1_gettagbynum},
8545 {"IDZebrac::data1_empty_tagset", _wrap_data1_empty_tagset},
8546 {"IDZebrac::data1_read_tagset", _wrap_data1_read_tagset},
8547 {"IDZebrac::data1_getelementbytagname", _wrap_data1_getelementbytagname},
8548 {"IDZebrac::data1_nodetogr", _wrap_data1_nodetogr},
8549 {"IDZebrac::data1_gettagbyname", _wrap_data1_gettagbyname},
8550 {"IDZebrac::data1_free_tree", _wrap_data1_free_tree},
8551 {"IDZebrac::data1_nodetobuf", _wrap_data1_nodetobuf},
8552 {"IDZebrac::data1_mk_tag_data_wd", _wrap_data1_mk_tag_data_wd},
8553 {"IDZebrac::data1_mk_tag_data", _wrap_data1_mk_tag_data},
8554 {"IDZebrac::data1_maptype", _wrap_data1_maptype},
8555 {"IDZebrac::data1_read_varset", _wrap_data1_read_varset},
8556 {"IDZebrac::data1_getvartypebyct", _wrap_data1_getvartypebyct},
8557 {"IDZebrac::data1_read_espec1", _wrap_data1_read_espec1},
8558 {"IDZebrac::data1_doespec1", _wrap_data1_doespec1},
8559 {"IDZebrac::data1_getesetbyname", _wrap_data1_getesetbyname},
8560 {"IDZebrac::data1_getelementbyname", _wrap_data1_getelementbyname},
8561 {"IDZebrac::data1_mk_node2", _wrap_data1_mk_node2},
8562 {"IDZebrac::data1_mk_tag", _wrap_data1_mk_tag},
8563 {"IDZebrac::data1_mk_tag_n", _wrap_data1_mk_tag_n},
8564 {"IDZebrac::data1_tag_add_attr", _wrap_data1_tag_add_attr},
8565 {"IDZebrac::data1_mk_text_n", _wrap_data1_mk_text_n},
8566 {"IDZebrac::data1_mk_text_nf", _wrap_data1_mk_text_nf},
8567 {"IDZebrac::data1_mk_text", _wrap_data1_mk_text},
8568 {"IDZebrac::data1_mk_comment_n", _wrap_data1_mk_comment_n},
8569 {"IDZebrac::data1_mk_comment", _wrap_data1_mk_comment},
8570 {"IDZebrac::data1_mk_preprocess", _wrap_data1_mk_preprocess},
8571 {"IDZebrac::data1_mk_root", _wrap_data1_mk_root},
8572 {"IDZebrac::data1_set_root", _wrap_data1_set_root},
8573 {"IDZebrac::data1_mk_tag_data_int", _wrap_data1_mk_tag_data_int},
8574 {"IDZebrac::data1_mk_tag_data_oid", _wrap_data1_mk_tag_data_oid},
8575 {"IDZebrac::data1_mk_tag_data_text", _wrap_data1_mk_tag_data_text},
8576 {"IDZebrac::data1_mk_tag_data_text_uni", _wrap_data1_mk_tag_data_text_uni},
8577 {"IDZebrac::data1_get_absyn", _wrap_data1_get_absyn},
8578 {"IDZebrac::data1_search_tag", _wrap_data1_search_tag},
8579 {"IDZebrac::data1_mk_tag_uni", _wrap_data1_mk_tag_uni},
8580 {"IDZebrac::data1_get_attset", _wrap_data1_get_attset},
8581 {"IDZebrac::data1_read_maptab", _wrap_data1_read_maptab},
8582 {"IDZebrac::data1_map_record", _wrap_data1_map_record},
8583 {"IDZebrac::data1_read_marctab", _wrap_data1_read_marctab},
8584 {"IDZebrac::data1_nodetomarc", _wrap_data1_nodetomarc},
8585 {"IDZebrac::data1_nodetoidsgml", _wrap_data1_nodetoidsgml},
8586 {"IDZebrac::data1_nodetoexplain", _wrap_data1_nodetoexplain},
8587 {"IDZebrac::data1_nodetosummary", _wrap_data1_nodetosummary},
8588 {"IDZebrac::data1_nodetosoif", _wrap_data1_nodetosoif},
8589 {"IDZebrac::data1_get_wrbuf", _wrap_data1_get_wrbuf},
8590 {"IDZebrac::data1_get_read_buf", _wrap_data1_get_read_buf},
8591 {"IDZebrac::data1_get_map_buf", _wrap_data1_get_map_buf},
8592 {"IDZebrac::data1_absyn_cache_get", _wrap_data1_absyn_cache_get},
8593 {"IDZebrac::data1_attset_cache_get", _wrap_data1_attset_cache_get},
8594 {"IDZebrac::data1_nmem_get", _wrap_data1_nmem_get},
8595 {"IDZebrac::data1_pr_tree", _wrap_data1_pr_tree},
8596 {"IDZebrac::data1_print_tree", _wrap_data1_print_tree},
8597 {"IDZebrac::data1_insert_string", _wrap_data1_insert_string},
8598 {"IDZebrac::data1_insert_string_n", _wrap_data1_insert_string_n},
8599 {"IDZebrac::data1_read_sgml", _wrap_data1_read_sgml},
8600 {"IDZebrac::data1_absyn_trav", _wrap_data1_absyn_trav},
8601 {"IDZebrac::data1_attset_search_id", _wrap_data1_attset_search_id},
8602 {"IDZebrac::data1_getNodeValue", _wrap_data1_getNodeValue},
8603 {"IDZebrac::data1_LookupNode", _wrap_data1_LookupNode},
8604 {"IDZebrac::data1_CountOccurences", _wrap_data1_CountOccurences},
8605 {"IDZebrac::data1_path_fopen", _wrap_data1_path_fopen},
8606 {"IDZebrac::data1_set_tabpath", _wrap_data1_set_tabpath},
8607 {"IDZebrac::data1_set_tabroot", _wrap_data1_set_tabroot},
8608 {"IDZebrac::data1_get_tabpath", _wrap_data1_get_tabpath},
8609 {"IDZebrac::data1_get_tabroot", _wrap_data1_get_tabroot},
8610 {"IDZebrac::grs_perl_readf", _wrap_grs_perl_readf},
8611 {"IDZebrac::grs_perl_readline", _wrap_grs_perl_readline},
8612 {"IDZebrac::grs_perl_getc", _wrap_grs_perl_getc},
8613 {"IDZebrac::grs_perl_seekf", _wrap_grs_perl_seekf},
8614 {"IDZebrac::grs_perl_tellf", _wrap_grs_perl_tellf},
8615 {"IDZebrac::grs_perl_endf", _wrap_grs_perl_endf},
8616 {"IDZebrac::grs_perl_get_dh", _wrap_grs_perl_get_dh},
8617 {"IDZebrac::grs_perl_get_mem", _wrap_grs_perl_get_mem},
8618 {"IDZebrac::grs_perl_set_res", _wrap_grs_perl_set_res},
8619 {0,0}
8620 };
8621
8622 #ifdef __cplusplus
8623 extern "C"
8624 #endif
8625
8626 XS(SWIG_init) {
8627     dXSARGS;
8628     int i;
8629     static int _init = 0;
8630     if (!_init) {
8631         for (i = 0; swig_types_initial[i]; i++) {
8632             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
8633         }
8634         _init = 1;
8635     }
8636
8637     /* Install commands */
8638     for (i = 0; swig_commands[i].name; i++) {
8639         newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
8640     }
8641
8642     /* Install variables */
8643     for (i = 0; swig_variables[i].name; i++) {
8644         SV *sv;
8645         sv = perl_get_sv((char*) swig_variables[i].name, TRUE | 0x2);
8646         if (swig_variables[i].type) {
8647             SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
8648         }else {
8649             sv_setiv(sv,(IV) 0);
8650         }
8651         swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
8652     }
8653
8654     /* Install constant */
8655     for (i = 0; swig_constants[i].type; i++) {
8656         SV *sv;
8657         sv = perl_get_sv((char*)swig_constants[i].name, TRUE | 0x2);
8658         switch(swig_constants[i].type) {
8659             case SWIG_INT:
8660             sv_setiv(sv, (IV) swig_constants[i].lvalue);
8661             break;
8662             case SWIG_FLOAT:
8663             sv_setnv(sv, (double) swig_constants[i].dvalue);
8664             break;
8665             case SWIG_STRING:
8666             sv_setpv(sv, (char *) swig_constants[i].pvalue);
8667             break;
8668             case SWIG_POINTER:
8669             SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
8670             break;
8671             case SWIG_BINARY:
8672             /*      obj = SWIG_NewPackedObj(swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype)); */
8673             break;
8674             default:
8675             break;
8676         }
8677         SvREADONLY_on(sv);
8678     }
8679
8680     SWIG_TypeClientData(SWIGTYPE_p_recordGroup, (void*) "IDZebra::recordGroup");
8681     SWIG_TypeClientData(SWIGTYPE_p_RetrievalObj, (void*) "IDZebra::RetrievalObj");
8682     SWIG_TypeClientData(SWIGTYPE_p_RetrievalRecord, (void*) "IDZebra::RetrievalRecord");
8683     SWIG_TypeClientData(SWIGTYPE_p_scanEntry, (void*) "IDZebra::scanEntry");
8684     SWIG_TypeClientData(SWIGTYPE_p_ScanObj, (void*) "IDZebra::ScanObj");
8685     SWIG_TypeClientData(SWIGTYPE_p_ZebraTransactionStatus, (void*) "IDZebra::ZebraTransactionStatus");
8686     ST(0) = &PL_sv_yes;
8687     XSRETURN(1);
8688 }
8689