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.11 2003-03-04 23:05:31 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_RetrievalRecordBuf_buf_set) {
1553     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1554     const char *_swigerr = _swigmsg;
1555     {
1556         RetrievalRecordBuf *arg1 ;
1557         char *arg2 ;
1558         int argvi = 0;
1559         dXSARGS;
1560
1561         if ((items < 2) || (items > 2)) {
1562             SWIG_croak("Usage: RetrievalRecordBuf_buf_set(self,buf);");
1563         }
1564         {
1565             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecordBuf,0) < 0) {
1566                 SWIG_croak("Type error in argument 1 of RetrievalRecordBuf_buf_set. Expected _p_RetrievalRecordBuf");
1567             }
1568         }
1569         if (!SvOK((SV*) ST(1))) arg2 = 0;
1570         else arg2 = (char *) SvPV(ST(1), PL_na);
1571         {
1572             if (arg1->buf) free((char*)arg1->buf);
1573             arg1->buf = (char *) malloc(strlen(arg2)+1);
1574             strcpy((char*)arg1->buf,arg2);
1575         }
1576
1577         XSRETURN(argvi);
1578         fail:
1579         (void) _swigerr;
1580     }
1581     croak(_swigerr);
1582 }
1583
1584
1585 XS(_wrap_RetrievalRecordBuf_buf_get) {
1586     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1587     const char *_swigerr = _swigmsg;
1588     {
1589         RetrievalRecordBuf *arg1 ;
1590         char *result;
1591         int argvi = 0;
1592         dXSARGS;
1593
1594         if ((items < 1) || (items > 1)) {
1595             SWIG_croak("Usage: RetrievalRecordBuf_buf_get(self);");
1596         }
1597         {
1598             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecordBuf,0) < 0) {
1599                 SWIG_croak("Type error in argument 1 of RetrievalRecordBuf_buf_get. Expected _p_RetrievalRecordBuf");
1600             }
1601         }
1602         result = (char *) ((arg1)->buf);
1603
1604         ST(argvi) = sv_newmortal();
1605         if (result) {
1606             sv_setpv((SV*)ST(argvi++), (char *) result);
1607         }else {
1608             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
1609         }
1610         XSRETURN(argvi);
1611         fail:
1612         (void) _swigerr;
1613     }
1614     croak(_swigerr);
1615 }
1616
1617
1618 XS(_wrap_RetrievalRecordBuf_len_set) {
1619     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1620     const char *_swigerr = _swigmsg;
1621     {
1622         RetrievalRecordBuf *arg1 ;
1623         int arg2 ;
1624         int argvi = 0;
1625         dXSARGS;
1626
1627         if ((items < 2) || (items > 2)) {
1628             SWIG_croak("Usage: RetrievalRecordBuf_len_set(self,len);");
1629         }
1630         {
1631             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecordBuf,0) < 0) {
1632                 SWIG_croak("Type error in argument 1 of RetrievalRecordBuf_len_set. Expected _p_RetrievalRecordBuf");
1633             }
1634         }
1635         arg2 = (int) SvIV(ST(1));
1636         if (arg1) (arg1)->len = arg2;
1637
1638
1639         XSRETURN(argvi);
1640         fail:
1641         (void) _swigerr;
1642     }
1643     croak(_swigerr);
1644 }
1645
1646
1647 XS(_wrap_RetrievalRecordBuf_len_get) {
1648     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1649     const char *_swigerr = _swigmsg;
1650     {
1651         RetrievalRecordBuf *arg1 ;
1652         int result;
1653         int argvi = 0;
1654         dXSARGS;
1655
1656         if ((items < 1) || (items > 1)) {
1657             SWIG_croak("Usage: RetrievalRecordBuf_len_get(self);");
1658         }
1659         {
1660             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecordBuf,0) < 0) {
1661                 SWIG_croak("Type error in argument 1 of RetrievalRecordBuf_len_get. Expected _p_RetrievalRecordBuf");
1662             }
1663         }
1664         result = (int) ((arg1)->len);
1665
1666         ST(argvi) = sv_newmortal();
1667         sv_setiv(ST(argvi++), (IV) result);
1668         XSRETURN(argvi);
1669         fail:
1670         (void) _swigerr;
1671     }
1672     croak(_swigerr);
1673 }
1674
1675
1676 XS(_wrap_new_RetrievalRecordBuf) {
1677     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1678     const char *_swigerr = _swigmsg;
1679     {
1680         RetrievalRecordBuf *result;
1681         int argvi = 0;
1682         dXSARGS;
1683
1684         if ((items < 0) || (items > 0)) {
1685             SWIG_croak("Usage: new_RetrievalRecordBuf();");
1686         }
1687         result = (RetrievalRecordBuf *)(RetrievalRecordBuf *) calloc(1, sizeof(RetrievalRecordBuf));
1688
1689         {
1690             if (result->len) {
1691                 ST(argvi) = newSVpv(result->buf,result->len);
1692             }else {
1693                 ST(argvi) = newSVpv("",0);
1694             }
1695             sv_2mortal(ST(argvi));
1696             argvi++;
1697         }
1698         XSRETURN(argvi);
1699         fail:
1700         (void) _swigerr;
1701     }
1702     croak(_swigerr);
1703 }
1704
1705
1706 XS(_wrap_delete_RetrievalRecordBuf) {
1707     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1708     const char *_swigerr = _swigmsg;
1709     {
1710         RetrievalRecordBuf *arg1 ;
1711         int argvi = 0;
1712         dXSARGS;
1713
1714         if ((items < 1) || (items > 1)) {
1715             SWIG_croak("Usage: delete_RetrievalRecordBuf(self);");
1716         }
1717         {
1718             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecordBuf,0) < 0) {
1719                 SWIG_croak("Type error in argument 1 of delete_RetrievalRecordBuf. Expected _p_RetrievalRecordBuf");
1720             }
1721         }
1722         free((char *) arg1);
1723
1724
1725         XSRETURN(argvi);
1726         fail:
1727         (void) _swigerr;
1728     }
1729     croak(_swigerr);
1730 }
1731
1732
1733 XS(_wrap_RetrievalRecord_errCode_set) {
1734     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1735     const char *_swigerr = _swigmsg;
1736     {
1737         RetrievalRecord *arg1 ;
1738         int arg2 ;
1739         int argvi = 0;
1740         dXSARGS;
1741
1742         if ((items < 2) || (items > 2)) {
1743             SWIG_croak("Usage: RetrievalRecord_errCode_set(self,errCode);");
1744         }
1745         {
1746             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1747                 SWIG_croak("Type error in argument 1 of RetrievalRecord_errCode_set. Expected _p_RetrievalRecord");
1748             }
1749         }
1750         arg2 = (int) SvIV(ST(1));
1751         if (arg1) (arg1)->errCode = arg2;
1752
1753
1754         XSRETURN(argvi);
1755         fail:
1756         (void) _swigerr;
1757     }
1758     croak(_swigerr);
1759 }
1760
1761
1762 XS(_wrap_RetrievalRecord_errCode_get) {
1763     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1764     const char *_swigerr = _swigmsg;
1765     {
1766         RetrievalRecord *arg1 ;
1767         int result;
1768         int argvi = 0;
1769         dXSARGS;
1770
1771         if ((items < 1) || (items > 1)) {
1772             SWIG_croak("Usage: RetrievalRecord_errCode_get(self);");
1773         }
1774         {
1775             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1776                 SWIG_croak("Type error in argument 1 of RetrievalRecord_errCode_get. Expected _p_RetrievalRecord");
1777             }
1778         }
1779         result = (int) ((arg1)->errCode);
1780
1781         ST(argvi) = sv_newmortal();
1782         sv_setiv(ST(argvi++), (IV) result);
1783         XSRETURN(argvi);
1784         fail:
1785         (void) _swigerr;
1786     }
1787     croak(_swigerr);
1788 }
1789
1790
1791 XS(_wrap_RetrievalRecord_errString_set) {
1792     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1793     const char *_swigerr = _swigmsg;
1794     {
1795         RetrievalRecord *arg1 ;
1796         char *arg2 ;
1797         int argvi = 0;
1798         dXSARGS;
1799
1800         if ((items < 2) || (items > 2)) {
1801             SWIG_croak("Usage: RetrievalRecord_errString_set(self,errString);");
1802         }
1803         {
1804             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1805                 SWIG_croak("Type error in argument 1 of RetrievalRecord_errString_set. Expected _p_RetrievalRecord");
1806             }
1807         }
1808         if (!SvOK((SV*) ST(1))) arg2 = 0;
1809         else arg2 = (char *) SvPV(ST(1), PL_na);
1810         {
1811             if (arg1->errString) free((char*)arg1->errString);
1812             arg1->errString = (char *) malloc(strlen(arg2)+1);
1813             strcpy((char*)arg1->errString,arg2);
1814         }
1815
1816         XSRETURN(argvi);
1817         fail:
1818         (void) _swigerr;
1819     }
1820     croak(_swigerr);
1821 }
1822
1823
1824 XS(_wrap_RetrievalRecord_errString_get) {
1825     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1826     const char *_swigerr = _swigmsg;
1827     {
1828         RetrievalRecord *arg1 ;
1829         char *result;
1830         int argvi = 0;
1831         dXSARGS;
1832
1833         if ((items < 1) || (items > 1)) {
1834             SWIG_croak("Usage: RetrievalRecord_errString_get(self);");
1835         }
1836         {
1837             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1838                 SWIG_croak("Type error in argument 1 of RetrievalRecord_errString_get. Expected _p_RetrievalRecord");
1839             }
1840         }
1841         result = (char *) ((arg1)->errString);
1842
1843         ST(argvi) = sv_newmortal();
1844         if (result) {
1845             sv_setpv((SV*)ST(argvi++), (char *) result);
1846         }else {
1847             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
1848         }
1849         XSRETURN(argvi);
1850         fail:
1851         (void) _swigerr;
1852     }
1853     croak(_swigerr);
1854 }
1855
1856
1857 XS(_wrap_RetrievalRecord_position_set) {
1858     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1859     const char *_swigerr = _swigmsg;
1860     {
1861         RetrievalRecord *arg1 ;
1862         int arg2 ;
1863         int argvi = 0;
1864         dXSARGS;
1865
1866         if ((items < 2) || (items > 2)) {
1867             SWIG_croak("Usage: RetrievalRecord_position_set(self,position);");
1868         }
1869         {
1870             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1871                 SWIG_croak("Type error in argument 1 of RetrievalRecord_position_set. Expected _p_RetrievalRecord");
1872             }
1873         }
1874         arg2 = (int) SvIV(ST(1));
1875         if (arg1) (arg1)->position = arg2;
1876
1877
1878         XSRETURN(argvi);
1879         fail:
1880         (void) _swigerr;
1881     }
1882     croak(_swigerr);
1883 }
1884
1885
1886 XS(_wrap_RetrievalRecord_position_get) {
1887     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1888     const char *_swigerr = _swigmsg;
1889     {
1890         RetrievalRecord *arg1 ;
1891         int result;
1892         int argvi = 0;
1893         dXSARGS;
1894
1895         if ((items < 1) || (items > 1)) {
1896             SWIG_croak("Usage: RetrievalRecord_position_get(self);");
1897         }
1898         {
1899             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1900                 SWIG_croak("Type error in argument 1 of RetrievalRecord_position_get. Expected _p_RetrievalRecord");
1901             }
1902         }
1903         result = (int) ((arg1)->position);
1904
1905         ST(argvi) = sv_newmortal();
1906         sv_setiv(ST(argvi++), (IV) result);
1907         XSRETURN(argvi);
1908         fail:
1909         (void) _swigerr;
1910     }
1911     croak(_swigerr);
1912 }
1913
1914
1915 XS(_wrap_RetrievalRecord_base_set) {
1916     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1917     const char *_swigerr = _swigmsg;
1918     {
1919         RetrievalRecord *arg1 ;
1920         char *arg2 ;
1921         int argvi = 0;
1922         dXSARGS;
1923
1924         if ((items < 2) || (items > 2)) {
1925             SWIG_croak("Usage: RetrievalRecord_base_set(self,base);");
1926         }
1927         {
1928             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1929                 SWIG_croak("Type error in argument 1 of RetrievalRecord_base_set. Expected _p_RetrievalRecord");
1930             }
1931         }
1932         if (!SvOK((SV*) ST(1))) arg2 = 0;
1933         else arg2 = (char *) SvPV(ST(1), PL_na);
1934         {
1935             if (arg1->base) free((char*)arg1->base);
1936             arg1->base = (char *) malloc(strlen(arg2)+1);
1937             strcpy((char*)arg1->base,arg2);
1938         }
1939
1940         XSRETURN(argvi);
1941         fail:
1942         (void) _swigerr;
1943     }
1944     croak(_swigerr);
1945 }
1946
1947
1948 XS(_wrap_RetrievalRecord_base_get) {
1949     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1950     const char *_swigerr = _swigmsg;
1951     {
1952         RetrievalRecord *arg1 ;
1953         char *result;
1954         int argvi = 0;
1955         dXSARGS;
1956
1957         if ((items < 1) || (items > 1)) {
1958             SWIG_croak("Usage: RetrievalRecord_base_get(self);");
1959         }
1960         {
1961             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1962                 SWIG_croak("Type error in argument 1 of RetrievalRecord_base_get. Expected _p_RetrievalRecord");
1963             }
1964         }
1965         result = (char *) ((arg1)->base);
1966
1967         ST(argvi) = sv_newmortal();
1968         if (result) {
1969             sv_setpv((SV*)ST(argvi++), (char *) result);
1970         }else {
1971             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
1972         }
1973         XSRETURN(argvi);
1974         fail:
1975         (void) _swigerr;
1976     }
1977     croak(_swigerr);
1978 }
1979
1980
1981 XS(_wrap_RetrievalRecord_sysno_set) {
1982     char _swigmsg[SWIG_MAX_ERRMSG] = "";
1983     const char *_swigerr = _swigmsg;
1984     {
1985         RetrievalRecord *arg1 ;
1986         int arg2 ;
1987         int argvi = 0;
1988         dXSARGS;
1989
1990         if ((items < 2) || (items > 2)) {
1991             SWIG_croak("Usage: RetrievalRecord_sysno_set(self,sysno);");
1992         }
1993         {
1994             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
1995                 SWIG_croak("Type error in argument 1 of RetrievalRecord_sysno_set. Expected _p_RetrievalRecord");
1996             }
1997         }
1998         arg2 = (int) SvIV(ST(1));
1999         if (arg1) (arg1)->sysno = arg2;
2000
2001
2002         XSRETURN(argvi);
2003         fail:
2004         (void) _swigerr;
2005     }
2006     croak(_swigerr);
2007 }
2008
2009
2010 XS(_wrap_RetrievalRecord_sysno_get) {
2011     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2012     const char *_swigerr = _swigmsg;
2013     {
2014         RetrievalRecord *arg1 ;
2015         int result;
2016         int argvi = 0;
2017         dXSARGS;
2018
2019         if ((items < 1) || (items > 1)) {
2020             SWIG_croak("Usage: RetrievalRecord_sysno_get(self);");
2021         }
2022         {
2023             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
2024                 SWIG_croak("Type error in argument 1 of RetrievalRecord_sysno_get. Expected _p_RetrievalRecord");
2025             }
2026         }
2027         result = (int) ((arg1)->sysno);
2028
2029         ST(argvi) = sv_newmortal();
2030         sv_setiv(ST(argvi++), (IV) result);
2031         XSRETURN(argvi);
2032         fail:
2033         (void) _swigerr;
2034     }
2035     croak(_swigerr);
2036 }
2037
2038
2039 XS(_wrap_RetrievalRecord_score_set) {
2040     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2041     const char *_swigerr = _swigmsg;
2042     {
2043         RetrievalRecord *arg1 ;
2044         int arg2 ;
2045         int argvi = 0;
2046         dXSARGS;
2047
2048         if ((items < 2) || (items > 2)) {
2049             SWIG_croak("Usage: RetrievalRecord_score_set(self,score);");
2050         }
2051         {
2052             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
2053                 SWIG_croak("Type error in argument 1 of RetrievalRecord_score_set. Expected _p_RetrievalRecord");
2054             }
2055         }
2056         arg2 = (int) SvIV(ST(1));
2057         if (arg1) (arg1)->score = arg2;
2058
2059
2060         XSRETURN(argvi);
2061         fail:
2062         (void) _swigerr;
2063     }
2064     croak(_swigerr);
2065 }
2066
2067
2068 XS(_wrap_RetrievalRecord_score_get) {
2069     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2070     const char *_swigerr = _swigmsg;
2071     {
2072         RetrievalRecord *arg1 ;
2073         int result;
2074         int argvi = 0;
2075         dXSARGS;
2076
2077         if ((items < 1) || (items > 1)) {
2078             SWIG_croak("Usage: RetrievalRecord_score_get(self);");
2079         }
2080         {
2081             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
2082                 SWIG_croak("Type error in argument 1 of RetrievalRecord_score_get. Expected _p_RetrievalRecord");
2083             }
2084         }
2085         result = (int) ((arg1)->score);
2086
2087         ST(argvi) = sv_newmortal();
2088         sv_setiv(ST(argvi++), (IV) result);
2089         XSRETURN(argvi);
2090         fail:
2091         (void) _swigerr;
2092     }
2093     croak(_swigerr);
2094 }
2095
2096
2097 XS(_wrap_RetrievalRecord_format_set) {
2098     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2099     const char *_swigerr = _swigmsg;
2100     {
2101         RetrievalRecord *arg1 ;
2102         char *arg2 ;
2103         int argvi = 0;
2104         dXSARGS;
2105
2106         if ((items < 2) || (items > 2)) {
2107             SWIG_croak("Usage: RetrievalRecord_format_set(self,format);");
2108         }
2109         {
2110             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
2111                 SWIG_croak("Type error in argument 1 of RetrievalRecord_format_set. Expected _p_RetrievalRecord");
2112             }
2113         }
2114         if (!SvOK((SV*) ST(1))) arg2 = 0;
2115         else arg2 = (char *) SvPV(ST(1), PL_na);
2116         {
2117             if (arg1->format) free((char*)arg1->format);
2118             arg1->format = (char *) malloc(strlen(arg2)+1);
2119             strcpy((char*)arg1->format,arg2);
2120         }
2121
2122         XSRETURN(argvi);
2123         fail:
2124         (void) _swigerr;
2125     }
2126     croak(_swigerr);
2127 }
2128
2129
2130 XS(_wrap_RetrievalRecord_format_get) {
2131     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2132     const char *_swigerr = _swigmsg;
2133     {
2134         RetrievalRecord *arg1 ;
2135         char *result;
2136         int argvi = 0;
2137         dXSARGS;
2138
2139         if ((items < 1) || (items > 1)) {
2140             SWIG_croak("Usage: RetrievalRecord_format_get(self);");
2141         }
2142         {
2143             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
2144                 SWIG_croak("Type error in argument 1 of RetrievalRecord_format_get. Expected _p_RetrievalRecord");
2145             }
2146         }
2147         result = (char *) ((arg1)->format);
2148
2149         ST(argvi) = sv_newmortal();
2150         if (result) {
2151             sv_setpv((SV*)ST(argvi++), (char *) result);
2152         }else {
2153             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
2154         }
2155         XSRETURN(argvi);
2156         fail:
2157         (void) _swigerr;
2158     }
2159     croak(_swigerr);
2160 }
2161
2162
2163 XS(_wrap_RetrievalRecord_buf_set) {
2164     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2165     const char *_swigerr = _swigmsg;
2166     {
2167         RetrievalRecord *arg1 ;
2168         RetrievalRecordBuf *arg2 ;
2169         int argvi = 0;
2170         dXSARGS;
2171
2172         if ((items < 2) || (items > 2)) {
2173             SWIG_croak("Usage: RetrievalRecord_buf_set(self,buf);");
2174         }
2175         {
2176             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
2177                 SWIG_croak("Type error in argument 1 of RetrievalRecord_buf_set. Expected _p_RetrievalRecord");
2178             }
2179         }
2180         {
2181             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_RetrievalRecordBuf,0) < 0) {
2182                 SWIG_croak("Type error in argument 2 of RetrievalRecord_buf_set. Expected _p_RetrievalRecordBuf");
2183             }
2184         }
2185         if (arg1) (arg1)->buf = arg2;
2186
2187
2188         XSRETURN(argvi);
2189         fail:
2190         (void) _swigerr;
2191     }
2192     croak(_swigerr);
2193 }
2194
2195
2196 XS(_wrap_RetrievalRecord_buf_get) {
2197     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2198     const char *_swigerr = _swigmsg;
2199     {
2200         RetrievalRecord *arg1 ;
2201         RetrievalRecordBuf *result;
2202         int argvi = 0;
2203         dXSARGS;
2204
2205         if ((items < 1) || (items > 1)) {
2206             SWIG_croak("Usage: RetrievalRecord_buf_get(self);");
2207         }
2208         {
2209             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
2210                 SWIG_croak("Type error in argument 1 of RetrievalRecord_buf_get. Expected _p_RetrievalRecord");
2211             }
2212         }
2213         result = (RetrievalRecordBuf *) ((arg1)->buf);
2214
2215         {
2216             if (result->len) {
2217                 ST(argvi) = newSVpv(result->buf,result->len);
2218             }else {
2219                 ST(argvi) = newSVpv("",0);
2220             }
2221             sv_2mortal(ST(argvi));
2222             argvi++;
2223         }
2224         XSRETURN(argvi);
2225         fail:
2226         (void) _swigerr;
2227     }
2228     croak(_swigerr);
2229 }
2230
2231
2232 XS(_wrap_new_RetrievalRecord) {
2233     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2234     const char *_swigerr = _swigmsg;
2235     {
2236         RetrievalRecord *result;
2237         int argvi = 0;
2238         dXSARGS;
2239
2240         if ((items < 0) || (items > 0)) {
2241             SWIG_croak("Usage: new_RetrievalRecord();");
2242         }
2243         result = (RetrievalRecord *)(RetrievalRecord *) calloc(1, sizeof(RetrievalRecord));
2244
2245         ST(argvi) = sv_newmortal();
2246         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_RetrievalRecord,0);
2247         XSRETURN(argvi);
2248         fail:
2249         (void) _swigerr;
2250     }
2251     croak(_swigerr);
2252 }
2253
2254
2255 XS(_wrap_delete_RetrievalRecord) {
2256     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2257     const char *_swigerr = _swigmsg;
2258     {
2259         RetrievalRecord *arg1 ;
2260         int argvi = 0;
2261         dXSARGS;
2262
2263         if ((items < 1) || (items > 1)) {
2264             SWIG_croak("Usage: delete_RetrievalRecord(self);");
2265         }
2266         {
2267             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) {
2268                 SWIG_croak("Type error in argument 1 of delete_RetrievalRecord. Expected _p_RetrievalRecord");
2269             }
2270         }
2271         free((char *) arg1);
2272
2273
2274         XSRETURN(argvi);
2275         fail:
2276         (void) _swigerr;
2277     }
2278     croak(_swigerr);
2279 }
2280
2281
2282 XS(_wrap_scanEntry_occurrences_set) {
2283     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2284     const char *_swigerr = _swigmsg;
2285     {
2286         scanEntry *arg1 ;
2287         int arg2 ;
2288         int argvi = 0;
2289         dXSARGS;
2290
2291         if ((items < 2) || (items > 2)) {
2292             SWIG_croak("Usage: scanEntry_occurrences_set(self,occurrences);");
2293         }
2294         {
2295             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) {
2296                 SWIG_croak("Type error in argument 1 of scanEntry_occurrences_set. Expected _p_scanEntry");
2297             }
2298         }
2299         arg2 = (int) SvIV(ST(1));
2300         if (arg1) (arg1)->occurrences = arg2;
2301
2302
2303         XSRETURN(argvi);
2304         fail:
2305         (void) _swigerr;
2306     }
2307     croak(_swigerr);
2308 }
2309
2310
2311 XS(_wrap_scanEntry_occurrences_get) {
2312     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2313     const char *_swigerr = _swigmsg;
2314     {
2315         scanEntry *arg1 ;
2316         int result;
2317         int argvi = 0;
2318         dXSARGS;
2319
2320         if ((items < 1) || (items > 1)) {
2321             SWIG_croak("Usage: scanEntry_occurrences_get(self);");
2322         }
2323         {
2324             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) {
2325                 SWIG_croak("Type error in argument 1 of scanEntry_occurrences_get. Expected _p_scanEntry");
2326             }
2327         }
2328         result = (int) ((arg1)->occurrences);
2329
2330         ST(argvi) = sv_newmortal();
2331         sv_setiv(ST(argvi++), (IV) result);
2332         XSRETURN(argvi);
2333         fail:
2334         (void) _swigerr;
2335     }
2336     croak(_swigerr);
2337 }
2338
2339
2340 XS(_wrap_scanEntry_term_set) {
2341     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2342     const char *_swigerr = _swigmsg;
2343     {
2344         scanEntry *arg1 ;
2345         char *arg2 ;
2346         int argvi = 0;
2347         dXSARGS;
2348
2349         if ((items < 2) || (items > 2)) {
2350             SWIG_croak("Usage: scanEntry_term_set(self,term);");
2351         }
2352         {
2353             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) {
2354                 SWIG_croak("Type error in argument 1 of scanEntry_term_set. Expected _p_scanEntry");
2355             }
2356         }
2357         if (!SvOK((SV*) ST(1))) arg2 = 0;
2358         else arg2 = (char *) SvPV(ST(1), PL_na);
2359         {
2360             if (arg1->term) free((char*)arg1->term);
2361             arg1->term = (char *) malloc(strlen(arg2)+1);
2362             strcpy((char*)arg1->term,arg2);
2363         }
2364
2365         XSRETURN(argvi);
2366         fail:
2367         (void) _swigerr;
2368     }
2369     croak(_swigerr);
2370 }
2371
2372
2373 XS(_wrap_scanEntry_term_get) {
2374     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2375     const char *_swigerr = _swigmsg;
2376     {
2377         scanEntry *arg1 ;
2378         char *result;
2379         int argvi = 0;
2380         dXSARGS;
2381
2382         if ((items < 1) || (items > 1)) {
2383             SWIG_croak("Usage: scanEntry_term_get(self);");
2384         }
2385         {
2386             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) {
2387                 SWIG_croak("Type error in argument 1 of scanEntry_term_get. Expected _p_scanEntry");
2388             }
2389         }
2390         result = (char *) ((arg1)->term);
2391
2392         ST(argvi) = sv_newmortal();
2393         if (result) {
2394             sv_setpv((SV*)ST(argvi++), (char *) result);
2395         }else {
2396             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
2397         }
2398         XSRETURN(argvi);
2399         fail:
2400         (void) _swigerr;
2401     }
2402     croak(_swigerr);
2403 }
2404
2405
2406 XS(_wrap_new_scanEntry) {
2407     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2408     const char *_swigerr = _swigmsg;
2409     {
2410         scanEntry *result;
2411         int argvi = 0;
2412         dXSARGS;
2413
2414         if ((items < 0) || (items > 0)) {
2415             SWIG_croak("Usage: new_scanEntry();");
2416         }
2417         result = (scanEntry *)(scanEntry *) calloc(1, sizeof(scanEntry));
2418
2419         ST(argvi) = sv_newmortal();
2420         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_scanEntry,0);
2421         XSRETURN(argvi);
2422         fail:
2423         (void) _swigerr;
2424     }
2425     croak(_swigerr);
2426 }
2427
2428
2429 XS(_wrap_delete_scanEntry) {
2430     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2431     const char *_swigerr = _swigmsg;
2432     {
2433         scanEntry *arg1 ;
2434         int argvi = 0;
2435         dXSARGS;
2436
2437         if ((items < 1) || (items > 1)) {
2438             SWIG_croak("Usage: delete_scanEntry(self);");
2439         }
2440         {
2441             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) {
2442                 SWIG_croak("Type error in argument 1 of delete_scanEntry. Expected _p_scanEntry");
2443             }
2444         }
2445         free((char *) arg1);
2446
2447
2448         XSRETURN(argvi);
2449         fail:
2450         (void) _swigerr;
2451     }
2452     croak(_swigerr);
2453 }
2454
2455
2456 XS(_wrap_ScanObj_num_entries_set) {
2457     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2458     const char *_swigerr = _swigmsg;
2459     {
2460         ScanObj *arg1 ;
2461         int arg2 ;
2462         int argvi = 0;
2463         dXSARGS;
2464
2465         if ((items < 2) || (items > 2)) {
2466             SWIG_croak("Usage: ScanObj_num_entries_set(self,num_entries);");
2467         }
2468         {
2469             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2470                 SWIG_croak("Type error in argument 1 of ScanObj_num_entries_set. Expected _p_ScanObj");
2471             }
2472         }
2473         arg2 = (int) SvIV(ST(1));
2474         if (arg1) (arg1)->num_entries = arg2;
2475
2476
2477         XSRETURN(argvi);
2478         fail:
2479         (void) _swigerr;
2480     }
2481     croak(_swigerr);
2482 }
2483
2484
2485 XS(_wrap_ScanObj_num_entries_get) {
2486     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2487     const char *_swigerr = _swigmsg;
2488     {
2489         ScanObj *arg1 ;
2490         int result;
2491         int argvi = 0;
2492         dXSARGS;
2493
2494         if ((items < 1) || (items > 1)) {
2495             SWIG_croak("Usage: ScanObj_num_entries_get(self);");
2496         }
2497         {
2498             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2499                 SWIG_croak("Type error in argument 1 of ScanObj_num_entries_get. Expected _p_ScanObj");
2500             }
2501         }
2502         result = (int) ((arg1)->num_entries);
2503
2504         ST(argvi) = sv_newmortal();
2505         sv_setiv(ST(argvi++), (IV) result);
2506         XSRETURN(argvi);
2507         fail:
2508         (void) _swigerr;
2509     }
2510     croak(_swigerr);
2511 }
2512
2513
2514 XS(_wrap_ScanObj_position_set) {
2515     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2516     const char *_swigerr = _swigmsg;
2517     {
2518         ScanObj *arg1 ;
2519         int arg2 ;
2520         int argvi = 0;
2521         dXSARGS;
2522
2523         if ((items < 2) || (items > 2)) {
2524             SWIG_croak("Usage: ScanObj_position_set(self,position);");
2525         }
2526         {
2527             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2528                 SWIG_croak("Type error in argument 1 of ScanObj_position_set. Expected _p_ScanObj");
2529             }
2530         }
2531         arg2 = (int) SvIV(ST(1));
2532         if (arg1) (arg1)->position = arg2;
2533
2534
2535         XSRETURN(argvi);
2536         fail:
2537         (void) _swigerr;
2538     }
2539     croak(_swigerr);
2540 }
2541
2542
2543 XS(_wrap_ScanObj_position_get) {
2544     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2545     const char *_swigerr = _swigmsg;
2546     {
2547         ScanObj *arg1 ;
2548         int result;
2549         int argvi = 0;
2550         dXSARGS;
2551
2552         if ((items < 1) || (items > 1)) {
2553             SWIG_croak("Usage: ScanObj_position_get(self);");
2554         }
2555         {
2556             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2557                 SWIG_croak("Type error in argument 1 of ScanObj_position_get. Expected _p_ScanObj");
2558             }
2559         }
2560         result = (int) ((arg1)->position);
2561
2562         ST(argvi) = sv_newmortal();
2563         sv_setiv(ST(argvi++), (IV) result);
2564         XSRETURN(argvi);
2565         fail:
2566         (void) _swigerr;
2567     }
2568     croak(_swigerr);
2569 }
2570
2571
2572 XS(_wrap_ScanObj_is_partial_set) {
2573     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2574     const char *_swigerr = _swigmsg;
2575     {
2576         ScanObj *arg1 ;
2577         int arg2 ;
2578         int argvi = 0;
2579         dXSARGS;
2580
2581         if ((items < 2) || (items > 2)) {
2582             SWIG_croak("Usage: ScanObj_is_partial_set(self,is_partial);");
2583         }
2584         {
2585             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2586                 SWIG_croak("Type error in argument 1 of ScanObj_is_partial_set. Expected _p_ScanObj");
2587             }
2588         }
2589         arg2 = (int) SvIV(ST(1));
2590         if (arg1) (arg1)->is_partial = arg2;
2591
2592
2593         XSRETURN(argvi);
2594         fail:
2595         (void) _swigerr;
2596     }
2597     croak(_swigerr);
2598 }
2599
2600
2601 XS(_wrap_ScanObj_is_partial_get) {
2602     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2603     const char *_swigerr = _swigmsg;
2604     {
2605         ScanObj *arg1 ;
2606         int result;
2607         int argvi = 0;
2608         dXSARGS;
2609
2610         if ((items < 1) || (items > 1)) {
2611             SWIG_croak("Usage: ScanObj_is_partial_get(self);");
2612         }
2613         {
2614             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2615                 SWIG_croak("Type error in argument 1 of ScanObj_is_partial_get. Expected _p_ScanObj");
2616             }
2617         }
2618         result = (int) ((arg1)->is_partial);
2619
2620         ST(argvi) = sv_newmortal();
2621         sv_setiv(ST(argvi++), (IV) result);
2622         XSRETURN(argvi);
2623         fail:
2624         (void) _swigerr;
2625     }
2626     croak(_swigerr);
2627 }
2628
2629
2630 XS(_wrap_ScanObj_entries_set) {
2631     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2632     const char *_swigerr = _swigmsg;
2633     {
2634         ScanObj *arg1 ;
2635         scanEntry *arg2 ;
2636         int argvi = 0;
2637         dXSARGS;
2638
2639         if ((items < 2) || (items > 2)) {
2640             SWIG_croak("Usage: ScanObj_entries_set(self,entries);");
2641         }
2642         {
2643             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2644                 SWIG_croak("Type error in argument 1 of ScanObj_entries_set. Expected _p_ScanObj");
2645             }
2646         }
2647         {
2648             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_scanEntry,0) < 0) {
2649                 SWIG_croak("Type error in argument 2 of ScanObj_entries_set. Expected _p_scanEntry");
2650             }
2651         }
2652         if (arg1) (arg1)->entries = arg2;
2653
2654
2655         XSRETURN(argvi);
2656         fail:
2657         (void) _swigerr;
2658     }
2659     croak(_swigerr);
2660 }
2661
2662
2663 XS(_wrap_ScanObj_entries_get) {
2664     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2665     const char *_swigerr = _swigmsg;
2666     {
2667         ScanObj *arg1 ;
2668         scanEntry *result;
2669         int argvi = 0;
2670         dXSARGS;
2671
2672         if ((items < 1) || (items > 1)) {
2673             SWIG_croak("Usage: ScanObj_entries_get(self);");
2674         }
2675         {
2676             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2677                 SWIG_croak("Type error in argument 1 of ScanObj_entries_get. Expected _p_ScanObj");
2678             }
2679         }
2680         result = (scanEntry *) ((arg1)->entries);
2681
2682         ST(argvi) = sv_newmortal();
2683         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_scanEntry,0);
2684         XSRETURN(argvi);
2685         fail:
2686         (void) _swigerr;
2687     }
2688     croak(_swigerr);
2689 }
2690
2691
2692 XS(_wrap_new_ScanObj) {
2693     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2694     const char *_swigerr = _swigmsg;
2695     {
2696         ScanObj *result;
2697         int argvi = 0;
2698         dXSARGS;
2699
2700         if ((items < 0) || (items > 0)) {
2701             SWIG_croak("Usage: new_ScanObj();");
2702         }
2703         result = (ScanObj *)(ScanObj *) calloc(1, sizeof(ScanObj));
2704
2705         ST(argvi) = sv_newmortal();
2706         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ScanObj,0);
2707         XSRETURN(argvi);
2708         fail:
2709         (void) _swigerr;
2710     }
2711     croak(_swigerr);
2712 }
2713
2714
2715 XS(_wrap_delete_ScanObj) {
2716     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2717     const char *_swigerr = _swigmsg;
2718     {
2719         ScanObj *arg1 ;
2720         int argvi = 0;
2721         dXSARGS;
2722
2723         if ((items < 1) || (items > 1)) {
2724             SWIG_croak("Usage: delete_ScanObj(self);");
2725         }
2726         {
2727             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
2728                 SWIG_croak("Type error in argument 1 of delete_ScanObj. Expected _p_ScanObj");
2729             }
2730         }
2731         free((char *) arg1);
2732
2733
2734         XSRETURN(argvi);
2735         fail:
2736         (void) _swigerr;
2737     }
2738     croak(_swigerr);
2739 }
2740
2741
2742 XS(_wrap_ZebraTransactionStatus_processed_set) {
2743     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2744     const char *_swigerr = _swigmsg;
2745     {
2746         ZebraTransactionStatus *arg1 ;
2747         int arg2 ;
2748         int argvi = 0;
2749         dXSARGS;
2750
2751         if ((items < 2) || (items > 2)) {
2752             SWIG_croak("Usage: ZebraTransactionStatus_processed_set(self,processed);");
2753         }
2754         {
2755             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2756                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_processed_set. Expected _p_ZebraTransactionStatus");
2757             }
2758         }
2759         arg2 = (int) SvIV(ST(1));
2760         if (arg1) (arg1)->processed = arg2;
2761
2762
2763         XSRETURN(argvi);
2764         fail:
2765         (void) _swigerr;
2766     }
2767     croak(_swigerr);
2768 }
2769
2770
2771 XS(_wrap_ZebraTransactionStatus_processed_get) {
2772     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2773     const char *_swigerr = _swigmsg;
2774     {
2775         ZebraTransactionStatus *arg1 ;
2776         int result;
2777         int argvi = 0;
2778         dXSARGS;
2779
2780         if ((items < 1) || (items > 1)) {
2781             SWIG_croak("Usage: ZebraTransactionStatus_processed_get(self);");
2782         }
2783         {
2784             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2785                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_processed_get. Expected _p_ZebraTransactionStatus");
2786             }
2787         }
2788         result = (int) ((arg1)->processed);
2789
2790         ST(argvi) = sv_newmortal();
2791         sv_setiv(ST(argvi++), (IV) result);
2792         XSRETURN(argvi);
2793         fail:
2794         (void) _swigerr;
2795     }
2796     croak(_swigerr);
2797 }
2798
2799
2800 XS(_wrap_ZebraTransactionStatus_inserted_set) {
2801     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2802     const char *_swigerr = _swigmsg;
2803     {
2804         ZebraTransactionStatus *arg1 ;
2805         int arg2 ;
2806         int argvi = 0;
2807         dXSARGS;
2808
2809         if ((items < 2) || (items > 2)) {
2810             SWIG_croak("Usage: ZebraTransactionStatus_inserted_set(self,inserted);");
2811         }
2812         {
2813             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2814                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_inserted_set. Expected _p_ZebraTransactionStatus");
2815             }
2816         }
2817         arg2 = (int) SvIV(ST(1));
2818         if (arg1) (arg1)->inserted = arg2;
2819
2820
2821         XSRETURN(argvi);
2822         fail:
2823         (void) _swigerr;
2824     }
2825     croak(_swigerr);
2826 }
2827
2828
2829 XS(_wrap_ZebraTransactionStatus_inserted_get) {
2830     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2831     const char *_swigerr = _swigmsg;
2832     {
2833         ZebraTransactionStatus *arg1 ;
2834         int result;
2835         int argvi = 0;
2836         dXSARGS;
2837
2838         if ((items < 1) || (items > 1)) {
2839             SWIG_croak("Usage: ZebraTransactionStatus_inserted_get(self);");
2840         }
2841         {
2842             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2843                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_inserted_get. Expected _p_ZebraTransactionStatus");
2844             }
2845         }
2846         result = (int) ((arg1)->inserted);
2847
2848         ST(argvi) = sv_newmortal();
2849         sv_setiv(ST(argvi++), (IV) result);
2850         XSRETURN(argvi);
2851         fail:
2852         (void) _swigerr;
2853     }
2854     croak(_swigerr);
2855 }
2856
2857
2858 XS(_wrap_ZebraTransactionStatus_updated_set) {
2859     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2860     const char *_swigerr = _swigmsg;
2861     {
2862         ZebraTransactionStatus *arg1 ;
2863         int arg2 ;
2864         int argvi = 0;
2865         dXSARGS;
2866
2867         if ((items < 2) || (items > 2)) {
2868             SWIG_croak("Usage: ZebraTransactionStatus_updated_set(self,updated);");
2869         }
2870         {
2871             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2872                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_updated_set. Expected _p_ZebraTransactionStatus");
2873             }
2874         }
2875         arg2 = (int) SvIV(ST(1));
2876         if (arg1) (arg1)->updated = arg2;
2877
2878
2879         XSRETURN(argvi);
2880         fail:
2881         (void) _swigerr;
2882     }
2883     croak(_swigerr);
2884 }
2885
2886
2887 XS(_wrap_ZebraTransactionStatus_updated_get) {
2888     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2889     const char *_swigerr = _swigmsg;
2890     {
2891         ZebraTransactionStatus *arg1 ;
2892         int result;
2893         int argvi = 0;
2894         dXSARGS;
2895
2896         if ((items < 1) || (items > 1)) {
2897             SWIG_croak("Usage: ZebraTransactionStatus_updated_get(self);");
2898         }
2899         {
2900             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2901                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_updated_get. Expected _p_ZebraTransactionStatus");
2902             }
2903         }
2904         result = (int) ((arg1)->updated);
2905
2906         ST(argvi) = sv_newmortal();
2907         sv_setiv(ST(argvi++), (IV) result);
2908         XSRETURN(argvi);
2909         fail:
2910         (void) _swigerr;
2911     }
2912     croak(_swigerr);
2913 }
2914
2915
2916 XS(_wrap_ZebraTransactionStatus_deleted_set) {
2917     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2918     const char *_swigerr = _swigmsg;
2919     {
2920         ZebraTransactionStatus *arg1 ;
2921         int arg2 ;
2922         int argvi = 0;
2923         dXSARGS;
2924
2925         if ((items < 2) || (items > 2)) {
2926             SWIG_croak("Usage: ZebraTransactionStatus_deleted_set(self,deleted);");
2927         }
2928         {
2929             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2930                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_deleted_set. Expected _p_ZebraTransactionStatus");
2931             }
2932         }
2933         arg2 = (int) SvIV(ST(1));
2934         if (arg1) (arg1)->deleted = arg2;
2935
2936
2937         XSRETURN(argvi);
2938         fail:
2939         (void) _swigerr;
2940     }
2941     croak(_swigerr);
2942 }
2943
2944
2945 XS(_wrap_ZebraTransactionStatus_deleted_get) {
2946     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2947     const char *_swigerr = _swigmsg;
2948     {
2949         ZebraTransactionStatus *arg1 ;
2950         int result;
2951         int argvi = 0;
2952         dXSARGS;
2953
2954         if ((items < 1) || (items > 1)) {
2955             SWIG_croak("Usage: ZebraTransactionStatus_deleted_get(self);");
2956         }
2957         {
2958             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2959                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_deleted_get. Expected _p_ZebraTransactionStatus");
2960             }
2961         }
2962         result = (int) ((arg1)->deleted);
2963
2964         ST(argvi) = sv_newmortal();
2965         sv_setiv(ST(argvi++), (IV) result);
2966         XSRETURN(argvi);
2967         fail:
2968         (void) _swigerr;
2969     }
2970     croak(_swigerr);
2971 }
2972
2973
2974 XS(_wrap_ZebraTransactionStatus_utime_set) {
2975     char _swigmsg[SWIG_MAX_ERRMSG] = "";
2976     const char *_swigerr = _swigmsg;
2977     {
2978         ZebraTransactionStatus *arg1 ;
2979         long arg2 ;
2980         int argvi = 0;
2981         dXSARGS;
2982
2983         if ((items < 2) || (items > 2)) {
2984             SWIG_croak("Usage: ZebraTransactionStatus_utime_set(self,utime);");
2985         }
2986         {
2987             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
2988                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_utime_set. Expected _p_ZebraTransactionStatus");
2989             }
2990         }
2991         arg2 = (long) SvIV(ST(1));
2992         if (arg1) (arg1)->utime = arg2;
2993
2994
2995         XSRETURN(argvi);
2996         fail:
2997         (void) _swigerr;
2998     }
2999     croak(_swigerr);
3000 }
3001
3002
3003 XS(_wrap_ZebraTransactionStatus_utime_get) {
3004     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3005     const char *_swigerr = _swigmsg;
3006     {
3007         ZebraTransactionStatus *arg1 ;
3008         long result;
3009         int argvi = 0;
3010         dXSARGS;
3011
3012         if ((items < 1) || (items > 1)) {
3013             SWIG_croak("Usage: ZebraTransactionStatus_utime_get(self);");
3014         }
3015         {
3016             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
3017                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_utime_get. Expected _p_ZebraTransactionStatus");
3018             }
3019         }
3020         result = (long) ((arg1)->utime);
3021
3022         ST(argvi) = sv_newmortal();
3023         sv_setiv(ST(argvi++), (IV) result);
3024         XSRETURN(argvi);
3025         fail:
3026         (void) _swigerr;
3027     }
3028     croak(_swigerr);
3029 }
3030
3031
3032 XS(_wrap_ZebraTransactionStatus_stime_set) {
3033     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3034     const char *_swigerr = _swigmsg;
3035     {
3036         ZebraTransactionStatus *arg1 ;
3037         long arg2 ;
3038         int argvi = 0;
3039         dXSARGS;
3040
3041         if ((items < 2) || (items > 2)) {
3042             SWIG_croak("Usage: ZebraTransactionStatus_stime_set(self,stime);");
3043         }
3044         {
3045             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
3046                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_stime_set. Expected _p_ZebraTransactionStatus");
3047             }
3048         }
3049         arg2 = (long) SvIV(ST(1));
3050         if (arg1) (arg1)->stime = arg2;
3051
3052
3053         XSRETURN(argvi);
3054         fail:
3055         (void) _swigerr;
3056     }
3057     croak(_swigerr);
3058 }
3059
3060
3061 XS(_wrap_ZebraTransactionStatus_stime_get) {
3062     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3063     const char *_swigerr = _swigmsg;
3064     {
3065         ZebraTransactionStatus *arg1 ;
3066         long result;
3067         int argvi = 0;
3068         dXSARGS;
3069
3070         if ((items < 1) || (items > 1)) {
3071             SWIG_croak("Usage: ZebraTransactionStatus_stime_get(self);");
3072         }
3073         {
3074             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
3075                 SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_stime_get. Expected _p_ZebraTransactionStatus");
3076             }
3077         }
3078         result = (long) ((arg1)->stime);
3079
3080         ST(argvi) = sv_newmortal();
3081         sv_setiv(ST(argvi++), (IV) result);
3082         XSRETURN(argvi);
3083         fail:
3084         (void) _swigerr;
3085     }
3086     croak(_swigerr);
3087 }
3088
3089
3090 XS(_wrap_new_ZebraTransactionStatus) {
3091     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3092     const char *_swigerr = _swigmsg;
3093     {
3094         ZebraTransactionStatus *result;
3095         int argvi = 0;
3096         dXSARGS;
3097
3098         if ((items < 0) || (items > 0)) {
3099             SWIG_croak("Usage: new_ZebraTransactionStatus();");
3100         }
3101         result = (ZebraTransactionStatus *)(ZebraTransactionStatus *) calloc(1, sizeof(ZebraTransactionStatus));
3102
3103         ST(argvi) = sv_newmortal();
3104         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ZebraTransactionStatus,0);
3105         XSRETURN(argvi);
3106         fail:
3107         (void) _swigerr;
3108     }
3109     croak(_swigerr);
3110 }
3111
3112
3113 XS(_wrap_delete_ZebraTransactionStatus) {
3114     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3115     const char *_swigerr = _swigmsg;
3116     {
3117         ZebraTransactionStatus *arg1 ;
3118         int argvi = 0;
3119         dXSARGS;
3120
3121         if ((items < 1) || (items > 1)) {
3122             SWIG_croak("Usage: delete_ZebraTransactionStatus(self);");
3123         }
3124         {
3125             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
3126                 SWIG_croak("Type error in argument 1 of delete_ZebraTransactionStatus. Expected _p_ZebraTransactionStatus");
3127             }
3128         }
3129         free((char *) arg1);
3130
3131
3132         XSRETURN(argvi);
3133         fail:
3134         (void) _swigerr;
3135     }
3136     croak(_swigerr);
3137 }
3138
3139
3140 XS(_wrap_init__SWIG_0) {
3141     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3142     const char *_swigerr = _swigmsg;
3143     {
3144         int argvi = 0;
3145         dXSARGS;
3146
3147         if ((items < 0) || (items > 0)) {
3148             SWIG_croak("Usage: init();");
3149         }
3150         init();
3151
3152
3153         XSRETURN(argvi);
3154         fail:
3155         (void) _swigerr;
3156     }
3157     croak(_swigerr);
3158 }
3159
3160
3161 XS(_wrap_DESTROY) {
3162     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3163     const char *_swigerr = _swigmsg;
3164     {
3165         int argvi = 0;
3166         dXSARGS;
3167
3168         if ((items < 0) || (items > 0)) {
3169             SWIG_croak("Usage: DESTROY();");
3170         }
3171         DESTROY();
3172
3173
3174         XSRETURN(argvi);
3175         fail:
3176         (void) _swigerr;
3177     }
3178     croak(_swigerr);
3179 }
3180
3181
3182 XS(_wrap_logLevel) {
3183     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3184     const char *_swigerr = _swigmsg;
3185     {
3186         int arg1 ;
3187         int argvi = 0;
3188         dXSARGS;
3189
3190         if ((items < 1) || (items > 1)) {
3191             SWIG_croak("Usage: logLevel(level);");
3192         }
3193         arg1 = (int) SvIV(ST(0));
3194         logLevel(arg1);
3195
3196
3197         XSRETURN(argvi);
3198         fail:
3199         (void) _swigerr;
3200     }
3201     croak(_swigerr);
3202 }
3203
3204
3205 XS(_wrap_logFile) {
3206     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3207     const char *_swigerr = _swigmsg;
3208     {
3209         char *arg1 ;
3210         int argvi = 0;
3211         dXSARGS;
3212
3213         if ((items < 1) || (items > 1)) {
3214             SWIG_croak("Usage: logFile(fname);");
3215         }
3216         if (!SvOK((SV*) ST(0))) arg1 = 0;
3217         else arg1 = (char *) SvPV(ST(0), PL_na);
3218         logFile((char const *)arg1);
3219
3220
3221         XSRETURN(argvi);
3222         fail:
3223         (void) _swigerr;
3224     }
3225     croak(_swigerr);
3226 }
3227
3228
3229 XS(_wrap_logMsg) {
3230     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3231     const char *_swigerr = _swigmsg;
3232     {
3233         int arg1 ;
3234         char *arg2 ;
3235         int argvi = 0;
3236         dXSARGS;
3237
3238         if ((items < 2) || (items > 2)) {
3239             SWIG_croak("Usage: logMsg(level,message);");
3240         }
3241         arg1 = (int) SvIV(ST(0));
3242         if (!SvOK((SV*) ST(1))) arg2 = 0;
3243         else arg2 = (char *) SvPV(ST(1), PL_na);
3244         logMsg(arg1,(char const *)arg2);
3245
3246
3247         XSRETURN(argvi);
3248         fail:
3249         (void) _swigerr;
3250     }
3251     croak(_swigerr);
3252 }
3253
3254
3255 XS(_wrap_odr_createmem) {
3256     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3257     const char *_swigerr = _swigmsg;
3258     {
3259         int arg1 ;
3260         ODR result;
3261         int argvi = 0;
3262         dXSARGS;
3263
3264         if ((items < 1) || (items > 1)) {
3265             SWIG_croak("Usage: odr_createmem(direction);");
3266         }
3267         arg1 = (int) SvIV(ST(0));
3268         result = odr_createmem(arg1);
3269
3270         {
3271             ODR * resultobj = (ODR *) malloc(sizeof(ODR));
3272             memmove(resultobj, &result, sizeof(ODR));
3273             ST(argvi) = sv_newmortal();
3274             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ODR,0);
3275         }
3276         XSRETURN(argvi);
3277         fail:
3278         (void) _swigerr;
3279     }
3280     croak(_swigerr);
3281 }
3282
3283
3284 XS(_wrap_odr_reset) {
3285     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3286     const char *_swigerr = _swigmsg;
3287     {
3288         ODR arg1 ;
3289         int argvi = 0;
3290         dXSARGS;
3291
3292         if ((items < 1) || (items > 1)) {
3293             SWIG_croak("Usage: odr_reset(o);");
3294         }
3295         {
3296             ODR * argp;
3297             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
3298                 SWIG_croak("Type error in argument 1 of odr_reset. Expected _p_ODR");
3299             }
3300             arg1 = *argp;
3301         }
3302         odr_reset(arg1);
3303
3304
3305         XSRETURN(argvi);
3306         fail:
3307         (void) _swigerr;
3308     }
3309     croak(_swigerr);
3310 }
3311
3312
3313 XS(_wrap_odr_destroy) {
3314     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3315     const char *_swigerr = _swigmsg;
3316     {
3317         ODR arg1 ;
3318         int argvi = 0;
3319         dXSARGS;
3320
3321         if ((items < 1) || (items > 1)) {
3322             SWIG_croak("Usage: odr_destroy(o);");
3323         }
3324         {
3325             ODR * argp;
3326             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
3327                 SWIG_croak("Type error in argument 1 of odr_destroy. Expected _p_ODR");
3328             }
3329             arg1 = *argp;
3330         }
3331         odr_destroy(arg1);
3332
3333
3334         XSRETURN(argvi);
3335         fail:
3336         (void) _swigerr;
3337     }
3338     croak(_swigerr);
3339 }
3340
3341
3342 XS(_wrap_odr_malloc) {
3343     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3344     const char *_swigerr = _swigmsg;
3345     {
3346         ODR arg1 ;
3347         int arg2 ;
3348         void *result;
3349         int argvi = 0;
3350         dXSARGS;
3351
3352         if ((items < 2) || (items > 2)) {
3353             SWIG_croak("Usage: odr_malloc(o,size);");
3354         }
3355         {
3356             ODR * argp;
3357             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
3358                 SWIG_croak("Type error in argument 1 of odr_malloc. Expected _p_ODR");
3359             }
3360             arg1 = *argp;
3361         }
3362         arg2 = (int) SvIV(ST(1));
3363         result = (void *)odr_malloc(arg1,arg2);
3364
3365         ST(argvi) = sv_newmortal();
3366         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_void,0);
3367         XSRETURN(argvi);
3368         fail:
3369         (void) _swigerr;
3370     }
3371     croak(_swigerr);
3372 }
3373
3374
3375 XS(_wrap_start) {
3376     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3377     const char *_swigerr = _swigmsg;
3378     {
3379         char *arg1 ;
3380         ZebraService result;
3381         int argvi = 0;
3382         dXSARGS;
3383
3384         if ((items < 1) || (items > 1)) {
3385             SWIG_croak("Usage: start(configName);");
3386         }
3387         if (!SvOK((SV*) ST(0))) arg1 = 0;
3388         else arg1 = (char *) SvPV(ST(0), PL_na);
3389         result = zebra_start((char const *)arg1);
3390
3391         {
3392             ZebraService * resultobj = (ZebraService *) malloc(sizeof(ZebraService));
3393             memmove(resultobj, &result, sizeof(ZebraService));
3394             ST(argvi) = sv_newmortal();
3395             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ZebraService,0);
3396         }
3397         XSRETURN(argvi);
3398         fail:
3399         (void) _swigerr;
3400     }
3401     croak(_swigerr);
3402 }
3403
3404
3405 XS(_wrap_open) {
3406     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3407     const char *_swigerr = _swigmsg;
3408     {
3409         ZebraService arg1 ;
3410         ZebraHandle result;
3411         int argvi = 0;
3412         dXSARGS;
3413
3414         if ((items < 1) || (items > 1)) {
3415             SWIG_croak("Usage: open(zs);");
3416         }
3417         {
3418             ZebraService * argp;
3419             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraService,0) < 0) {
3420                 SWIG_croak("Type error in argument 1 of open. Expected _p_ZebraService");
3421             }
3422             arg1 = *argp;
3423         }
3424         result = zebra_open(arg1);
3425
3426         {
3427             ZebraHandle * resultobj = (ZebraHandle *) malloc(sizeof(ZebraHandle));
3428             memmove(resultobj, &result, sizeof(ZebraHandle));
3429             ST(argvi) = sv_newmortal();
3430             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_ZebraHandle,0);
3431         }
3432         XSRETURN(argvi);
3433         fail:
3434         (void) _swigerr;
3435     }
3436     croak(_swigerr);
3437 }
3438
3439
3440 XS(_wrap_close) {
3441     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3442     const char *_swigerr = _swigmsg;
3443     {
3444         ZebraHandle arg1 ;
3445         int argvi = 0;
3446         dXSARGS;
3447
3448         if ((items < 1) || (items > 1)) {
3449             SWIG_croak("Usage: close(zh);");
3450         }
3451         {
3452             ZebraHandle * argp;
3453             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3454                 SWIG_croak("Type error in argument 1 of close. Expected _p_ZebraHandle");
3455             }
3456             arg1 = *argp;
3457         }
3458         zebra_close(arg1);
3459
3460
3461         XSRETURN(argvi);
3462         fail:
3463         (void) _swigerr;
3464     }
3465     croak(_swigerr);
3466 }
3467
3468
3469 XS(_wrap_stop) {
3470     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3471     const char *_swigerr = _swigmsg;
3472     {
3473         ZebraService arg1 ;
3474         int argvi = 0;
3475         dXSARGS;
3476
3477         if ((items < 1) || (items > 1)) {
3478             SWIG_croak("Usage: stop(zs);");
3479         }
3480         {
3481             ZebraService * argp;
3482             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraService,0) < 0) {
3483                 SWIG_croak("Type error in argument 1 of stop. Expected _p_ZebraService");
3484             }
3485             arg1 = *argp;
3486         }
3487         zebra_stop(arg1);
3488
3489
3490         XSRETURN(argvi);
3491         fail:
3492         (void) _swigerr;
3493     }
3494     croak(_swigerr);
3495 }
3496
3497
3498 XS(_wrap_errCode) {
3499     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3500     const char *_swigerr = _swigmsg;
3501     {
3502         ZebraHandle arg1 ;
3503         int result;
3504         int argvi = 0;
3505         dXSARGS;
3506
3507         if ((items < 1) || (items > 1)) {
3508             SWIG_croak("Usage: errCode(zh);");
3509         }
3510         {
3511             ZebraHandle * argp;
3512             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3513                 SWIG_croak("Type error in argument 1 of errCode. Expected _p_ZebraHandle");
3514             }
3515             arg1 = *argp;
3516         }
3517         result = (int)zebra_errCode(arg1);
3518
3519         ST(argvi) = sv_newmortal();
3520         sv_setiv(ST(argvi++), (IV) result);
3521         XSRETURN(argvi);
3522         fail:
3523         (void) _swigerr;
3524     }
3525     croak(_swigerr);
3526 }
3527
3528
3529 XS(_wrap_errString) {
3530     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3531     const char *_swigerr = _swigmsg;
3532     {
3533         ZebraHandle arg1 ;
3534         char *result;
3535         int argvi = 0;
3536         dXSARGS;
3537
3538         if ((items < 1) || (items > 1)) {
3539             SWIG_croak("Usage: errString(zh);");
3540         }
3541         {
3542             ZebraHandle * argp;
3543             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3544                 SWIG_croak("Type error in argument 1 of errString. Expected _p_ZebraHandle");
3545             }
3546             arg1 = *argp;
3547         }
3548         result = (char *)zebra_errString(arg1);
3549
3550         ST(argvi) = sv_newmortal();
3551         if (result) {
3552             sv_setpv((SV*)ST(argvi++), (char *) result);
3553         }else {
3554             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
3555         }
3556         XSRETURN(argvi);
3557         fail:
3558         (void) _swigerr;
3559     }
3560     croak(_swigerr);
3561 }
3562
3563
3564 XS(_wrap_errAdd) {
3565     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3566     const char *_swigerr = _swigmsg;
3567     {
3568         ZebraHandle arg1 ;
3569         char *result;
3570         int argvi = 0;
3571         dXSARGS;
3572
3573         if ((items < 1) || (items > 1)) {
3574             SWIG_croak("Usage: errAdd(zh);");
3575         }
3576         {
3577             ZebraHandle * argp;
3578             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3579                 SWIG_croak("Type error in argument 1 of errAdd. Expected _p_ZebraHandle");
3580             }
3581             arg1 = *argp;
3582         }
3583         result = (char *)zebra_errAdd(arg1);
3584
3585         ST(argvi) = sv_newmortal();
3586         if (result) {
3587             sv_setpv((SV*)ST(argvi++), (char *) result);
3588         }else {
3589             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
3590         }
3591         XSRETURN(argvi);
3592         fail:
3593         (void) _swigerr;
3594     }
3595     croak(_swigerr);
3596 }
3597
3598
3599 XS(_wrap_init_recordGroup) {
3600     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3601     const char *_swigerr = _swigmsg;
3602     {
3603         recordGroup *arg1 ;
3604         int argvi = 0;
3605         dXSARGS;
3606
3607         if ((items < 1) || (items > 1)) {
3608             SWIG_croak("Usage: init_recordGroup(rg);");
3609         }
3610         {
3611             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_recordGroup,0) < 0) {
3612                 SWIG_croak("Type error in argument 1 of init_recordGroup. Expected _p_recordGroup");
3613             }
3614         }
3615         init_recordGroup(arg1);
3616
3617
3618         XSRETURN(argvi);
3619         fail:
3620         (void) _swigerr;
3621     }
3622     croak(_swigerr);
3623 }
3624
3625
3626 XS(_wrap_res_get_recordGroup) {
3627     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3628     const char *_swigerr = _swigmsg;
3629     {
3630         ZebraHandle arg1 ;
3631         recordGroup *arg2 ;
3632         char *arg3 ;
3633         int argvi = 0;
3634         dXSARGS;
3635
3636         if ((items < 3) || (items > 3)) {
3637             SWIG_croak("Usage: res_get_recordGroup(zh,rg,ext);");
3638         }
3639         {
3640             ZebraHandle * argp;
3641             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3642                 SWIG_croak("Type error in argument 1 of res_get_recordGroup. Expected _p_ZebraHandle");
3643             }
3644             arg1 = *argp;
3645         }
3646         {
3647             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) {
3648                 SWIG_croak("Type error in argument 2 of res_get_recordGroup. Expected _p_recordGroup");
3649             }
3650         }
3651         if (!SvOK((SV*) ST(2))) arg3 = 0;
3652         else arg3 = (char *) SvPV(ST(2), PL_na);
3653         res_get_recordGroup(arg1,arg2,(char const *)arg3);
3654
3655
3656         XSRETURN(argvi);
3657         fail:
3658         (void) _swigerr;
3659     }
3660     croak(_swigerr);
3661 }
3662
3663
3664 XS(_wrap_set_group) {
3665     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3666     const char *_swigerr = _swigmsg;
3667     {
3668         ZebraHandle arg1 ;
3669         struct recordGroup *arg2 ;
3670         int argvi = 0;
3671         dXSARGS;
3672
3673         if ((items < 2) || (items > 2)) {
3674             SWIG_croak("Usage: set_group(zh,rg);");
3675         }
3676         {
3677             ZebraHandle * argp;
3678             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3679                 SWIG_croak("Type error in argument 1 of set_group. Expected _p_ZebraHandle");
3680             }
3681             arg1 = *argp;
3682         }
3683         {
3684             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) {
3685                 SWIG_croak("Type error in argument 2 of set_group. Expected _p_recordGroup");
3686             }
3687         }
3688         zebra_set_group(arg1,arg2);
3689
3690
3691         XSRETURN(argvi);
3692         fail:
3693         (void) _swigerr;
3694     }
3695     croak(_swigerr);
3696 }
3697
3698
3699 XS(_wrap_select_database) {
3700     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3701     const char *_swigerr = _swigmsg;
3702     {
3703         ZebraHandle arg1 ;
3704         char *arg2 ;
3705         int result;
3706         int argvi = 0;
3707         dXSARGS;
3708
3709         if ((items < 2) || (items > 2)) {
3710             SWIG_croak("Usage: select_database(zh,basename);");
3711         }
3712         {
3713             ZebraHandle * argp;
3714             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3715                 SWIG_croak("Type error in argument 1 of select_database. Expected _p_ZebraHandle");
3716             }
3717             arg1 = *argp;
3718         }
3719         if (!SvOK((SV*) ST(1))) arg2 = 0;
3720         else arg2 = (char *) SvPV(ST(1), PL_na);
3721         result = (int)zebra_select_database(arg1,(char const *)arg2);
3722
3723         ST(argvi) = sv_newmortal();
3724         sv_setiv(ST(argvi++), (IV) result);
3725         XSRETURN(argvi);
3726         fail:
3727         (void) _swigerr;
3728     }
3729     croak(_swigerr);
3730 }
3731
3732
3733 XS(_wrap_select_databases) {
3734     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3735     const char *_swigerr = _swigmsg;
3736     {
3737         ZebraHandle arg1 ;
3738         int arg2 ;
3739         char **arg3 ;
3740         int result;
3741         int argvi = 0;
3742         dXSARGS;
3743
3744         if ((items < 3) || (items > 3)) {
3745             SWIG_croak("Usage: select_databases(zh,num_bases,basenames);");
3746         }
3747         {
3748             ZebraHandle * argp;
3749             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3750                 SWIG_croak("Type error in argument 1 of select_databases. Expected _p_ZebraHandle");
3751             }
3752             arg1 = *argp;
3753         }
3754         arg2 = (int) SvIV(ST(1));
3755         {
3756             AV *tempav;
3757             I32 len;
3758             int i;
3759             SV  **tv;
3760             STRLEN na;
3761             if (!SvROK(ST(2)))
3762             croak("Argument 3 is not a reference.");
3763             if (SvTYPE(SvRV(ST(2))) != SVt_PVAV)
3764             croak("Argument 3 is not an array.");
3765             tempav = (AV*)SvRV(ST(2));
3766             len = av_len(tempav);
3767             arg3 = (char **) malloc((len+2)*sizeof(char *));
3768             for (i = 0; i <= len; i++) {
3769                 tv = av_fetch(tempav, i, 0);
3770                 arg3[i] = (char *) SvPV(*tv,na);
3771             }
3772             arg3[i] = NULL;
3773         }
3774         result = (int)zebra_select_databases(arg1,arg2,(char const **)arg3);
3775
3776         ST(argvi) = sv_newmortal();
3777         sv_setiv(ST(argvi++), (IV) result);
3778         {
3779             free(arg3);
3780         }
3781         XSRETURN(argvi);
3782         fail:
3783         {
3784             free(arg3);
3785         }
3786         (void) _swigerr;
3787     }
3788     croak(_swigerr);
3789 }
3790
3791
3792 XS(_wrap_begin_trans) {
3793     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3794     const char *_swigerr = _swigmsg;
3795     {
3796         ZebraHandle arg1 ;
3797         int argvi = 0;
3798         dXSARGS;
3799
3800         if ((items < 1) || (items > 1)) {
3801             SWIG_croak("Usage: begin_trans(zh);");
3802         }
3803         {
3804             ZebraHandle * argp;
3805             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3806                 SWIG_croak("Type error in argument 1 of begin_trans. Expected _p_ZebraHandle");
3807             }
3808             arg1 = *argp;
3809         }
3810         zebra_begin_trans(arg1);
3811
3812
3813         XSRETURN(argvi);
3814         fail:
3815         (void) _swigerr;
3816     }
3817     croak(_swigerr);
3818 }
3819
3820
3821 XS(_wrap_end_trans) {
3822     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3823     const char *_swigerr = _swigmsg;
3824     {
3825         ZebraHandle arg1 ;
3826         ZebraTransactionStatus *arg2 ;
3827         int argvi = 0;
3828         dXSARGS;
3829
3830         if ((items < 2) || (items > 2)) {
3831             SWIG_croak("Usage: end_trans(zh,stat);");
3832         }
3833         {
3834             ZebraHandle * argp;
3835             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3836                 SWIG_croak("Type error in argument 1 of end_trans. Expected _p_ZebraHandle");
3837             }
3838             arg1 = *argp;
3839         }
3840         {
3841             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) {
3842                 SWIG_croak("Type error in argument 2 of end_trans. Expected _p_ZebraTransactionStatus");
3843             }
3844         }
3845         zebra_end_transaction(arg1,arg2);
3846
3847
3848         XSRETURN(argvi);
3849         fail:
3850         (void) _swigerr;
3851     }
3852     croak(_swigerr);
3853 }
3854
3855
3856 XS(_wrap_trans_no) {
3857     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3858     const char *_swigerr = _swigmsg;
3859     {
3860         ZebraHandle arg1 ;
3861         int result;
3862         int argvi = 0;
3863         dXSARGS;
3864
3865         if ((items < 1) || (items > 1)) {
3866             SWIG_croak("Usage: trans_no(zh);");
3867         }
3868         {
3869             ZebraHandle * argp;
3870             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3871                 SWIG_croak("Type error in argument 1 of trans_no. Expected _p_ZebraHandle");
3872             }
3873             arg1 = *argp;
3874         }
3875         result = (int)zebra_trans_no(arg1);
3876
3877         ST(argvi) = sv_newmortal();
3878         sv_setiv(ST(argvi++), (IV) result);
3879         XSRETURN(argvi);
3880         fail:
3881         (void) _swigerr;
3882     }
3883     croak(_swigerr);
3884 }
3885
3886
3887 XS(_wrap_begin_read) {
3888     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3889     const char *_swigerr = _swigmsg;
3890     {
3891         ZebraHandle arg1 ;
3892         int result;
3893         int argvi = 0;
3894         dXSARGS;
3895
3896         if ((items < 1) || (items > 1)) {
3897             SWIG_croak("Usage: begin_read(zh);");
3898         }
3899         {
3900             ZebraHandle * argp;
3901             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3902                 SWIG_croak("Type error in argument 1 of begin_read. Expected _p_ZebraHandle");
3903             }
3904             arg1 = *argp;
3905         }
3906         result = (int)zebra_begin_read(arg1);
3907
3908         ST(argvi) = sv_newmortal();
3909         sv_setiv(ST(argvi++), (IV) result);
3910         XSRETURN(argvi);
3911         fail:
3912         (void) _swigerr;
3913     }
3914     croak(_swigerr);
3915 }
3916
3917
3918 XS(_wrap_end_read) {
3919     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3920     const char *_swigerr = _swigmsg;
3921     {
3922         ZebraHandle arg1 ;
3923         int argvi = 0;
3924         dXSARGS;
3925
3926         if ((items < 1) || (items > 1)) {
3927             SWIG_croak("Usage: end_read(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 end_read. Expected _p_ZebraHandle");
3933             }
3934             arg1 = *argp;
3935         }
3936         zebra_end_read(arg1);
3937
3938
3939         XSRETURN(argvi);
3940         fail:
3941         (void) _swigerr;
3942     }
3943     croak(_swigerr);
3944 }
3945
3946
3947 XS(_wrap_commit) {
3948     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3949     const char *_swigerr = _swigmsg;
3950     {
3951         ZebraHandle arg1 ;
3952         int result;
3953         int argvi = 0;
3954         dXSARGS;
3955
3956         if ((items < 1) || (items > 1)) {
3957             SWIG_croak("Usage: commit(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 commit. Expected _p_ZebraHandle");
3963             }
3964             arg1 = *argp;
3965         }
3966         result = (int)zebra_commit(arg1);
3967
3968         ST(argvi) = sv_newmortal();
3969         sv_setiv(ST(argvi++), (IV) result);
3970         XSRETURN(argvi);
3971         fail:
3972         (void) _swigerr;
3973     }
3974     croak(_swigerr);
3975 }
3976
3977
3978 XS(_wrap_get_shadow_enable) {
3979     char _swigmsg[SWIG_MAX_ERRMSG] = "";
3980     const char *_swigerr = _swigmsg;
3981     {
3982         ZebraHandle arg1 ;
3983         int result;
3984         int argvi = 0;
3985         dXSARGS;
3986
3987         if ((items < 1) || (items > 1)) {
3988             SWIG_croak("Usage: get_shadow_enable(zh);");
3989         }
3990         {
3991             ZebraHandle * argp;
3992             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
3993                 SWIG_croak("Type error in argument 1 of get_shadow_enable. Expected _p_ZebraHandle");
3994             }
3995             arg1 = *argp;
3996         }
3997         result = (int)zebra_get_shadow_enable(arg1);
3998
3999         ST(argvi) = sv_newmortal();
4000         sv_setiv(ST(argvi++), (IV) result);
4001         XSRETURN(argvi);
4002         fail:
4003         (void) _swigerr;
4004     }
4005     croak(_swigerr);
4006 }
4007
4008
4009 XS(_wrap_set_shadow_enable) {
4010     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4011     const char *_swigerr = _swigmsg;
4012     {
4013         ZebraHandle arg1 ;
4014         int arg2 ;
4015         int argvi = 0;
4016         dXSARGS;
4017
4018         if ((items < 2) || (items > 2)) {
4019             SWIG_croak("Usage: set_shadow_enable(zh,value);");
4020         }
4021         {
4022             ZebraHandle * argp;
4023             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4024                 SWIG_croak("Type error in argument 1 of set_shadow_enable. Expected _p_ZebraHandle");
4025             }
4026             arg1 = *argp;
4027         }
4028         arg2 = (int) SvIV(ST(1));
4029         zebra_set_shadow_enable(arg1,arg2);
4030
4031
4032         XSRETURN(argvi);
4033         fail:
4034         (void) _swigerr;
4035     }
4036     croak(_swigerr);
4037 }
4038
4039
4040 XS(_wrap_init__SWIG_1) {
4041     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4042     const char *_swigerr = _swigmsg;
4043     {
4044         ZebraHandle arg1 ;
4045         int result;
4046         int argvi = 0;
4047         dXSARGS;
4048
4049         if ((items < 1) || (items > 1)) {
4050             SWIG_croak("Usage: init(zh);");
4051         }
4052         {
4053             ZebraHandle * argp;
4054             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4055                 SWIG_croak("Type error in argument 1 of init. Expected _p_ZebraHandle");
4056             }
4057             arg1 = *argp;
4058         }
4059         result = (int)zebra_init(arg1);
4060
4061         ST(argvi) = sv_newmortal();
4062         sv_setiv(ST(argvi++), (IV) result);
4063         XSRETURN(argvi);
4064         fail:
4065         (void) _swigerr;
4066     }
4067     croak(_swigerr);
4068 }
4069
4070
4071 XS(_wrap_init) {
4072     dXSARGS;
4073
4074     if (items == 0) {
4075         int _v;
4076         (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_init__SWIG_0); return;
4077     }
4078     if (items == 1) {
4079         int _v;
4080         {
4081             void *tmp;
4082             if (SWIG_ConvertPtr(ST(0), (void **) &tmp, SWIGTYPE_p_ZebraHandle, 0) == -1) {
4083                 _v = 0;
4084             }else {
4085                 _v = 1;
4086             }
4087         }
4088         if (_v) {
4089             (*PL_markstack_ptr++);SWIG_CALLXS(_wrap_init__SWIG_1); return;
4090         }
4091     }
4092
4093     croak("No matching function for overloaded 'init'");
4094     XSRETURN(0);
4095 }
4096
4097
4098 XS(_wrap_compact) {
4099     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4100     const char *_swigerr = _swigmsg;
4101     {
4102         ZebraHandle arg1 ;
4103         int result;
4104         int argvi = 0;
4105         dXSARGS;
4106
4107         if ((items < 1) || (items > 1)) {
4108             SWIG_croak("Usage: compact(zh);");
4109         }
4110         {
4111             ZebraHandle * argp;
4112             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4113                 SWIG_croak("Type error in argument 1 of compact. Expected _p_ZebraHandle");
4114             }
4115             arg1 = *argp;
4116         }
4117         result = (int)zebra_compact(arg1);
4118
4119         ST(argvi) = sv_newmortal();
4120         sv_setiv(ST(argvi++), (IV) result);
4121         XSRETURN(argvi);
4122         fail:
4123         (void) _swigerr;
4124     }
4125     croak(_swigerr);
4126 }
4127
4128
4129 XS(_wrap_repository_update) {
4130     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4131     const char *_swigerr = _swigmsg;
4132     {
4133         ZebraHandle arg1 ;
4134         int argvi = 0;
4135         dXSARGS;
4136
4137         if ((items < 1) || (items > 1)) {
4138             SWIG_croak("Usage: repository_update(zh);");
4139         }
4140         {
4141             ZebraHandle * argp;
4142             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4143                 SWIG_croak("Type error in argument 1 of repository_update. Expected _p_ZebraHandle");
4144             }
4145             arg1 = *argp;
4146         }
4147         zebra_repository_update(arg1);
4148
4149
4150         XSRETURN(argvi);
4151         fail:
4152         (void) _swigerr;
4153     }
4154     croak(_swigerr);
4155 }
4156
4157
4158 XS(_wrap_repository_delete) {
4159     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4160     const char *_swigerr = _swigmsg;
4161     {
4162         ZebraHandle arg1 ;
4163         int argvi = 0;
4164         dXSARGS;
4165
4166         if ((items < 1) || (items > 1)) {
4167             SWIG_croak("Usage: repository_delete(zh);");
4168         }
4169         {
4170             ZebraHandle * argp;
4171             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4172                 SWIG_croak("Type error in argument 1 of repository_delete. Expected _p_ZebraHandle");
4173             }
4174             arg1 = *argp;
4175         }
4176         zebra_repository_delete(arg1);
4177
4178
4179         XSRETURN(argvi);
4180         fail:
4181         (void) _swigerr;
4182     }
4183     croak(_swigerr);
4184 }
4185
4186
4187 XS(_wrap_repository_show) {
4188     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4189     const char *_swigerr = _swigmsg;
4190     {
4191         ZebraHandle arg1 ;
4192         int argvi = 0;
4193         dXSARGS;
4194
4195         if ((items < 1) || (items > 1)) {
4196             SWIG_croak("Usage: repository_show(zh);");
4197         }
4198         {
4199             ZebraHandle * argp;
4200             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4201                 SWIG_croak("Type error in argument 1 of repository_show. Expected _p_ZebraHandle");
4202             }
4203             arg1 = *argp;
4204         }
4205         zebra_repository_show(arg1);
4206
4207
4208         XSRETURN(argvi);
4209         fail:
4210         (void) _swigerr;
4211     }
4212     croak(_swigerr);
4213 }
4214
4215
4216 XS(_wrap_update_record) {
4217     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4218     const char *_swigerr = _swigmsg;
4219     {
4220         ZebraHandle arg1 ;
4221         recordGroup *arg2 ;
4222         char *arg3 ;
4223         int arg4 ;
4224         char *arg5 ;
4225         char *arg6 ;
4226         char *arg7 ;
4227         int arg8 ;
4228         int result;
4229         int argvi = 0;
4230         dXSARGS;
4231
4232         if ((items < 8) || (items > 8)) {
4233             SWIG_croak("Usage: update_record(zh,rGroup,recordType,sysno,match,fname,buf,buf_size);");
4234         }
4235         {
4236             ZebraHandle * argp;
4237             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4238                 SWIG_croak("Type error in argument 1 of update_record. Expected _p_ZebraHandle");
4239             }
4240             arg1 = *argp;
4241         }
4242         {
4243             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) {
4244                 SWIG_croak("Type error in argument 2 of update_record. Expected _p_recordGroup");
4245             }
4246         }
4247         if (!SvOK((SV*) ST(2))) arg3 = 0;
4248         else arg3 = (char *) SvPV(ST(2), PL_na);
4249         arg4 = (int) SvIV(ST(3));
4250         if (!SvOK((SV*) ST(4))) arg5 = 0;
4251         else arg5 = (char *) SvPV(ST(4), PL_na);
4252         if (!SvOK((SV*) ST(5))) arg6 = 0;
4253         else arg6 = (char *) SvPV(ST(5), PL_na);
4254         if (!SvOK((SV*) ST(6))) arg7 = 0;
4255         else arg7 = (char *) SvPV(ST(6), PL_na);
4256         arg8 = (int) SvIV(ST(7));
4257         result = (int)zebra_update_record(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8);
4258
4259         ST(argvi) = sv_newmortal();
4260         sv_setiv(ST(argvi++), (IV) result);
4261         XSRETURN(argvi);
4262         fail:
4263         (void) _swigerr;
4264     }
4265     croak(_swigerr);
4266 }
4267
4268
4269 XS(_wrap_delete_record) {
4270     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4271     const char *_swigerr = _swigmsg;
4272     {
4273         ZebraHandle arg1 ;
4274         recordGroup *arg2 ;
4275         char *arg3 ;
4276         int arg4 ;
4277         char *arg5 ;
4278         char *arg6 ;
4279         char *arg7 ;
4280         int arg8 ;
4281         int result;
4282         int argvi = 0;
4283         dXSARGS;
4284
4285         if ((items < 8) || (items > 8)) {
4286             SWIG_croak("Usage: delete_record(zh,rGroup,recordType,sysno,match,fname,buf,buf_size);");
4287         }
4288         {
4289             ZebraHandle * argp;
4290             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4291                 SWIG_croak("Type error in argument 1 of delete_record. Expected _p_ZebraHandle");
4292             }
4293             arg1 = *argp;
4294         }
4295         {
4296             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) {
4297                 SWIG_croak("Type error in argument 2 of delete_record. Expected _p_recordGroup");
4298             }
4299         }
4300         if (!SvOK((SV*) ST(2))) arg3 = 0;
4301         else arg3 = (char *) SvPV(ST(2), PL_na);
4302         arg4 = (int) SvIV(ST(3));
4303         if (!SvOK((SV*) ST(4))) arg5 = 0;
4304         else arg5 = (char *) SvPV(ST(4), PL_na);
4305         if (!SvOK((SV*) ST(5))) arg6 = 0;
4306         else arg6 = (char *) SvPV(ST(5), PL_na);
4307         if (!SvOK((SV*) ST(6))) arg7 = 0;
4308         else arg7 = (char *) SvPV(ST(6), PL_na);
4309         arg8 = (int) SvIV(ST(7));
4310         result = (int)zebra_delete_record(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8);
4311
4312         ST(argvi) = sv_newmortal();
4313         sv_setiv(ST(argvi++), (IV) result);
4314         XSRETURN(argvi);
4315         fail:
4316         (void) _swigerr;
4317     }
4318     croak(_swigerr);
4319 }
4320
4321
4322 XS(_wrap_search_PQF) {
4323     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4324     const char *_swigerr = _swigmsg;
4325     {
4326         ZebraHandle arg1 ;
4327         ODR arg2 ;
4328         ODR arg3 ;
4329         char *arg4 ;
4330         char *arg5 ;
4331         int result;
4332         int argvi = 0;
4333         dXSARGS;
4334
4335         if ((items < 5) || (items > 5)) {
4336             SWIG_croak("Usage: search_PQF(zh,odr_input,odr_output,pqf_query,setname);");
4337         }
4338         {
4339             ZebraHandle * argp;
4340             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4341                 SWIG_croak("Type error in argument 1 of search_PQF. Expected _p_ZebraHandle");
4342             }
4343             arg1 = *argp;
4344         }
4345         {
4346             ODR * argp;
4347             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4348                 SWIG_croak("Type error in argument 2 of search_PQF. Expected _p_ODR");
4349             }
4350             arg2 = *argp;
4351         }
4352         {
4353             ODR * argp;
4354             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4355                 SWIG_croak("Type error in argument 3 of search_PQF. Expected _p_ODR");
4356             }
4357             arg3 = *argp;
4358         }
4359         if (!SvOK((SV*) ST(3))) arg4 = 0;
4360         else arg4 = (char *) SvPV(ST(3), PL_na);
4361         if (!SvOK((SV*) ST(4))) arg5 = 0;
4362         else arg5 = (char *) SvPV(ST(4), PL_na);
4363         result = (int)zebra_search_PQF(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5);
4364
4365         ST(argvi) = sv_newmortal();
4366         sv_setiv(ST(argvi++), (IV) result);
4367         XSRETURN(argvi);
4368         fail:
4369         (void) _swigerr;
4370     }
4371     croak(_swigerr);
4372 }
4373
4374
4375 XS(_wrap_cql_transform_open_fname) {
4376     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4377     const char *_swigerr = _swigmsg;
4378     {
4379         char *arg1 ;
4380         cql_transform_t result;
4381         int argvi = 0;
4382         dXSARGS;
4383
4384         if ((items < 1) || (items > 1)) {
4385             SWIG_croak("Usage: cql_transform_open_fname(fname);");
4386         }
4387         if (!SvOK((SV*) ST(0))) arg1 = 0;
4388         else arg1 = (char *) SvPV(ST(0), PL_na);
4389         result = cql_transform_open_fname((char const *)arg1);
4390
4391         {
4392             cql_transform_t * resultobj = (cql_transform_t *) malloc(sizeof(cql_transform_t));
4393             memmove(resultobj, &result, sizeof(cql_transform_t));
4394             ST(argvi) = sv_newmortal();
4395             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_cql_transform_t,0);
4396         }
4397         XSRETURN(argvi);
4398         fail:
4399         (void) _swigerr;
4400     }
4401     croak(_swigerr);
4402 }
4403
4404
4405 XS(_wrap_cql_transform_close) {
4406     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4407     const char *_swigerr = _swigmsg;
4408     {
4409         cql_transform_t arg1 ;
4410         int argvi = 0;
4411         dXSARGS;
4412
4413         if ((items < 1) || (items > 1)) {
4414             SWIG_croak("Usage: cql_transform_close(ct);");
4415         }
4416         {
4417             cql_transform_t * argp;
4418             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_cql_transform_t,0) < 0) {
4419                 SWIG_croak("Type error in argument 1 of cql_transform_close. Expected _p_cql_transform_t");
4420             }
4421             arg1 = *argp;
4422         }
4423         cql_transform_close(arg1);
4424
4425
4426         XSRETURN(argvi);
4427         fail:
4428         (void) _swigerr;
4429     }
4430     croak(_swigerr);
4431 }
4432
4433
4434 XS(_wrap_cql_transform_error) {
4435     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4436     const char *_swigerr = _swigmsg;
4437     {
4438         cql_transform_t arg1 ;
4439         char **arg2 ;
4440         int result;
4441         int argvi = 0;
4442         dXSARGS;
4443
4444         if ((items < 2) || (items > 2)) {
4445             SWIG_croak("Usage: cql_transform_error(ct,addinfo);");
4446         }
4447         {
4448             cql_transform_t * argp;
4449             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_cql_transform_t,0) < 0) {
4450                 SWIG_croak("Type error in argument 1 of cql_transform_error. Expected _p_cql_transform_t");
4451             }
4452             arg1 = *argp;
4453         }
4454         {
4455             AV *tempav;
4456             I32 len;
4457             int i;
4458             SV  **tv;
4459             STRLEN na;
4460             if (!SvROK(ST(1)))
4461             croak("Argument 2 is not a reference.");
4462             if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
4463             croak("Argument 2 is not an array.");
4464             tempav = (AV*)SvRV(ST(1));
4465             len = av_len(tempav);
4466             arg2 = (char **) malloc((len+2)*sizeof(char *));
4467             for (i = 0; i <= len; i++) {
4468                 tv = av_fetch(tempav, i, 0);
4469                 arg2[i] = (char *) SvPV(*tv,na);
4470             }
4471             arg2[i] = NULL;
4472         }
4473         result = (int)cql_transform_error(arg1,(char const **)arg2);
4474
4475         ST(argvi) = sv_newmortal();
4476         sv_setiv(ST(argvi++), (IV) result);
4477         {
4478             free(arg2);
4479         }
4480         XSRETURN(argvi);
4481         fail:
4482         {
4483             free(arg2);
4484         }
4485         (void) _swigerr;
4486     }
4487     croak(_swigerr);
4488 }
4489
4490
4491 XS(_wrap_cql2pqf) {
4492     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4493     const char *_swigerr = _swigmsg;
4494     {
4495         cql_transform_t arg1 ;
4496         char *arg2 ;
4497         char *arg3 ;
4498         int arg4 ;
4499         int result;
4500         int argvi = 0;
4501         dXSARGS;
4502
4503         if ((items < 4) || (items > 4)) {
4504             SWIG_croak("Usage: cql2pqf(ct,query,res,len);");
4505         }
4506         {
4507             cql_transform_t * argp;
4508             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_cql_transform_t,0) < 0) {
4509                 SWIG_croak("Type error in argument 1 of cql2pqf. Expected _p_cql_transform_t");
4510             }
4511             arg1 = *argp;
4512         }
4513         if (!SvOK((SV*) ST(1))) arg2 = 0;
4514         else arg2 = (char *) SvPV(ST(1), PL_na);
4515         if (!SvOK((SV*) ST(2))) arg3 = 0;
4516         else arg3 = (char *) SvPV(ST(2), PL_na);
4517         arg4 = (int) SvIV(ST(3));
4518         result = (int)zebra_cql2pqf(arg1,(char const *)arg2,arg3,arg4);
4519
4520         ST(argvi) = sv_newmortal();
4521         sv_setiv(ST(argvi++), (IV) result);
4522         XSRETURN(argvi);
4523         fail:
4524         (void) _swigerr;
4525     }
4526     croak(_swigerr);
4527 }
4528
4529
4530 XS(_wrap_records_retrieve) {
4531     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4532     const char *_swigerr = _swigmsg;
4533     {
4534         ZebraHandle arg1 ;
4535         ODR arg2 ;
4536         char *arg3 ;
4537         char *arg4 ;
4538         char *arg5 ;
4539         char *arg6 ;
4540         int arg7 ;
4541         int arg8 ;
4542         RetrievalObj *arg9 ;
4543         int argvi = 0;
4544         dXSARGS;
4545
4546         if ((items < 9) || (items > 9)) {
4547             SWIG_croak("Usage: records_retrieve(zh,stream,setname,a_eset,a_schema,a_format,from,to,res);");
4548         }
4549         {
4550             ZebraHandle * argp;
4551             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4552                 SWIG_croak("Type error in argument 1 of records_retrieve. Expected _p_ZebraHandle");
4553             }
4554             arg1 = *argp;
4555         }
4556         {
4557             ODR * argp;
4558             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4559                 SWIG_croak("Type error in argument 2 of records_retrieve. Expected _p_ODR");
4560             }
4561             arg2 = *argp;
4562         }
4563         if (!SvOK((SV*) ST(2))) arg3 = 0;
4564         else arg3 = (char *) SvPV(ST(2), PL_na);
4565         if (!SvOK((SV*) ST(3))) arg4 = 0;
4566         else arg4 = (char *) SvPV(ST(3), PL_na);
4567         if (!SvOK((SV*) ST(4))) arg5 = 0;
4568         else arg5 = (char *) SvPV(ST(4), PL_na);
4569         if (!SvOK((SV*) ST(5))) arg6 = 0;
4570         else arg6 = (char *) SvPV(ST(5), PL_na);
4571         arg7 = (int) SvIV(ST(6));
4572         arg8 = (int) SvIV(ST(7));
4573         {
4574             if (SWIG_ConvertPtr(ST(8), (void **) &arg9, SWIGTYPE_p_RetrievalObj,0) < 0) {
4575                 SWIG_croak("Type error in argument 9 of records_retrieve. Expected _p_RetrievalObj");
4576             }
4577         }
4578         records_retrieve(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,arg9);
4579
4580
4581         XSRETURN(argvi);
4582         fail:
4583         (void) _swigerr;
4584     }
4585     croak(_swigerr);
4586 }
4587
4588
4589 XS(_wrap_record_retrieve) {
4590     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4591     const char *_swigerr = _swigmsg;
4592     {
4593         RetrievalObj *arg1 ;
4594         ODR arg2 ;
4595         RetrievalRecord *arg3 ;
4596         int arg4 ;
4597         int argvi = 0;
4598         dXSARGS;
4599
4600         if ((items < 4) || (items > 4)) {
4601             SWIG_croak("Usage: record_retrieve(ro,stream,res,pos);");
4602         }
4603         {
4604             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalObj,0) < 0) {
4605                 SWIG_croak("Type error in argument 1 of record_retrieve. Expected _p_RetrievalObj");
4606             }
4607         }
4608         {
4609             ODR * argp;
4610             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4611                 SWIG_croak("Type error in argument 2 of record_retrieve. Expected _p_ODR");
4612             }
4613             arg2 = *argp;
4614         }
4615         {
4616             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_RetrievalRecord,0) < 0) {
4617                 SWIG_croak("Type error in argument 3 of record_retrieve. Expected _p_RetrievalRecord");
4618             }
4619         }
4620         arg4 = (int) SvIV(ST(3));
4621         record_retrieve(arg1,arg2,arg3,arg4);
4622
4623
4624         XSRETURN(argvi);
4625         fail:
4626         (void) _swigerr;
4627     }
4628     croak(_swigerr);
4629 }
4630
4631
4632 XS(_wrap_deleteResultSet) {
4633     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4634     const char *_swigerr = _swigmsg;
4635     {
4636         ZebraHandle arg1 ;
4637         int arg2 ;
4638         int arg3 ;
4639         char **arg4 ;
4640         int *arg5 ;
4641         int result;
4642         int argvi = 0;
4643         dXSARGS;
4644
4645         if ((items < 5) || (items > 5)) {
4646             SWIG_croak("Usage: deleteResultSet(zh,function,num_setnames,setnames,statuses);");
4647         }
4648         {
4649             ZebraHandle * argp;
4650             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4651                 SWIG_croak("Type error in argument 1 of deleteResultSet. Expected _p_ZebraHandle");
4652             }
4653             arg1 = *argp;
4654         }
4655         arg2 = (int) SvIV(ST(1));
4656         arg3 = (int) SvIV(ST(2));
4657         {
4658             AV *tempav;
4659             I32 len;
4660             int i;
4661             SV  **tv;
4662             STRLEN na;
4663             if (!SvROK(ST(3)))
4664             croak("Argument 4 is not a reference.");
4665             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
4666             croak("Argument 4 is not an array.");
4667             tempav = (AV*)SvRV(ST(3));
4668             len = av_len(tempav);
4669             arg4 = (char **) malloc((len+2)*sizeof(char *));
4670             for (i = 0; i <= len; i++) {
4671                 tv = av_fetch(tempav, i, 0);
4672                 arg4[i] = (char *) SvPV(*tv,na);
4673             }
4674             arg4[i] = NULL;
4675         }
4676         {
4677             int i;
4678             if (!SvIOK(ST(4)))
4679             croak("Argument 5 is not an integer.");
4680             i = SvIV(ST(4));
4681             arg5 = &i;
4682         }
4683         result = (int)zebra_deleleResultSet(arg1,arg2,arg3,arg4,arg5);
4684
4685         ST(argvi) = sv_newmortal();
4686         sv_setiv(ST(argvi++), (IV) result);
4687         {
4688             free(arg4);
4689         }
4690         XSRETURN(argvi);
4691         fail:
4692         {
4693             free(arg4);
4694         }
4695         (void) _swigerr;
4696     }
4697     croak(_swigerr);
4698 }
4699
4700
4701 XS(_wrap_sort) {
4702     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4703     const char *_swigerr = _swigmsg;
4704     {
4705         ZebraHandle arg1 ;
4706         ODR arg2 ;
4707         char *arg3 ;
4708         char *arg4 ;
4709         char **arg5 ;
4710         int result;
4711         int argvi = 0;
4712         dXSARGS;
4713
4714         if ((items < 5) || (items > 5)) {
4715             SWIG_croak("Usage: sort(zh,stream,sort_spec,output_setname,input_setnames);");
4716         }
4717         {
4718             ZebraHandle * argp;
4719             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4720                 SWIG_croak("Type error in argument 1 of sort. Expected _p_ZebraHandle");
4721             }
4722             arg1 = *argp;
4723         }
4724         {
4725             ODR * argp;
4726             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4727                 SWIG_croak("Type error in argument 2 of sort. Expected _p_ODR");
4728             }
4729             arg2 = *argp;
4730         }
4731         if (!SvOK((SV*) ST(2))) arg3 = 0;
4732         else arg3 = (char *) SvPV(ST(2), PL_na);
4733         if (!SvOK((SV*) ST(3))) arg4 = 0;
4734         else arg4 = (char *) SvPV(ST(3), PL_na);
4735         {
4736             AV *tempav;
4737             I32 len;
4738             int i;
4739             SV  **tv;
4740             STRLEN na;
4741             if (!SvROK(ST(4)))
4742             croak("Argument 5 is not a reference.");
4743             if (SvTYPE(SvRV(ST(4))) != SVt_PVAV)
4744             croak("Argument 5 is not an array.");
4745             tempav = (AV*)SvRV(ST(4));
4746             len = av_len(tempav);
4747             arg5 = (char **) malloc((len+2)*sizeof(char *));
4748             for (i = 0; i <= len; i++) {
4749                 tv = av_fetch(tempav, i, 0);
4750                 arg5[i] = (char *) SvPV(*tv,na);
4751             }
4752             arg5[i] = NULL;
4753         }
4754         result = (int)sort(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const **)arg5);
4755
4756         ST(argvi) = sv_newmortal();
4757         sv_setiv(ST(argvi++), (IV) result);
4758         {
4759             free(arg5);
4760         }
4761         XSRETURN(argvi);
4762         fail:
4763         {
4764             free(arg5);
4765         }
4766         (void) _swigerr;
4767     }
4768     croak(_swigerr);
4769 }
4770
4771
4772 XS(_wrap_scan_PQF) {
4773     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4774     const char *_swigerr = _swigmsg;
4775     {
4776         ZebraHandle arg1 ;
4777         ScanObj *arg2 ;
4778         ODR arg3 ;
4779         char *arg4 ;
4780         int argvi = 0;
4781         dXSARGS;
4782
4783         if ((items < 4) || (items > 4)) {
4784             SWIG_croak("Usage: scan_PQF(zh,so,stream,pqf_query);");
4785         }
4786         {
4787             ZebraHandle * argp;
4788             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) {
4789                 SWIG_croak("Type error in argument 1 of scan_PQF. Expected _p_ZebraHandle");
4790             }
4791             arg1 = *argp;
4792         }
4793         {
4794             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ScanObj,0) < 0) {
4795                 SWIG_croak("Type error in argument 2 of scan_PQF. Expected _p_ScanObj");
4796             }
4797         }
4798         {
4799             ODR * argp;
4800             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4801                 SWIG_croak("Type error in argument 3 of scan_PQF. Expected _p_ODR");
4802             }
4803             arg3 = *argp;
4804         }
4805         if (!SvOK((SV*) ST(3))) arg4 = 0;
4806         else arg4 = (char *) SvPV(ST(3), PL_na);
4807         zebra_scan_PQF(arg1,arg2,arg3,(char const *)arg4);
4808
4809
4810         XSRETURN(argvi);
4811         fail:
4812         (void) _swigerr;
4813     }
4814     croak(_swigerr);
4815 }
4816
4817
4818 XS(_wrap_getScanEntry) {
4819     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4820     const char *_swigerr = _swigmsg;
4821     {
4822         ScanObj *arg1 ;
4823         int arg2 ;
4824         scanEntry *result;
4825         int argvi = 0;
4826         dXSARGS;
4827
4828         if ((items < 2) || (items > 2)) {
4829             SWIG_croak("Usage: getScanEntry(so,pos);");
4830         }
4831         {
4832             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
4833                 SWIG_croak("Type error in argument 1 of getScanEntry. Expected _p_ScanObj");
4834             }
4835         }
4836         arg2 = (int) SvIV(ST(1));
4837         result = (scanEntry *)getScanEntry(arg1,arg2);
4838
4839         ST(argvi) = sv_newmortal();
4840         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_scanEntry,0);
4841         XSRETURN(argvi);
4842         fail:
4843         (void) _swigerr;
4844     }
4845     croak(_swigerr);
4846 }
4847
4848
4849 XS(_wrap_nmem_create) {
4850     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4851     const char *_swigerr = _swigmsg;
4852     {
4853         NMEM result;
4854         int argvi = 0;
4855         dXSARGS;
4856
4857         if ((items < 0) || (items > 0)) {
4858             SWIG_croak("Usage: nmem_create();");
4859         }
4860         result = nmem_create();
4861
4862         {
4863             NMEM * resultobj = (NMEM *) malloc(sizeof(NMEM));
4864             memmove(resultobj, &result, sizeof(NMEM));
4865             ST(argvi) = sv_newmortal();
4866             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_NMEM,0);
4867         }
4868         XSRETURN(argvi);
4869         fail:
4870         (void) _swigerr;
4871     }
4872     croak(_swigerr);
4873 }
4874
4875
4876 XS(_wrap_nmem_destroy) {
4877     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4878     const char *_swigerr = _swigmsg;
4879     {
4880         NMEM arg1 ;
4881         int argvi = 0;
4882         dXSARGS;
4883
4884         if ((items < 1) || (items > 1)) {
4885             SWIG_croak("Usage: nmem_destroy(handle);");
4886         }
4887         {
4888             NMEM * argp;
4889             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
4890                 SWIG_croak("Type error in argument 1 of nmem_destroy. Expected _p_NMEM");
4891             }
4892             arg1 = *argp;
4893         }
4894         nmem_destroy(arg1);
4895
4896
4897         XSRETURN(argvi);
4898         fail:
4899         (void) _swigerr;
4900     }
4901     croak(_swigerr);
4902 }
4903
4904
4905 XS(_wrap_data1_create) {
4906     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4907     const char *_swigerr = _swigmsg;
4908     {
4909         data1_handle result;
4910         int argvi = 0;
4911         dXSARGS;
4912
4913         if ((items < 0) || (items > 0)) {
4914             SWIG_croak("Usage: data1_create();");
4915         }
4916         result = data1_create();
4917
4918         {
4919             data1_handle * resultobj = (data1_handle *) malloc(sizeof(data1_handle));
4920             memmove(resultobj, &result, sizeof(data1_handle));
4921             ST(argvi) = sv_newmortal();
4922             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_data1_handle,0);
4923         }
4924         XSRETURN(argvi);
4925         fail:
4926         (void) _swigerr;
4927     }
4928     croak(_swigerr);
4929 }
4930
4931
4932 XS(_wrap_data1_createx) {
4933     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4934     const char *_swigerr = _swigmsg;
4935     {
4936         int arg1 ;
4937         data1_handle result;
4938         int argvi = 0;
4939         dXSARGS;
4940
4941         if ((items < 1) || (items > 1)) {
4942             SWIG_croak("Usage: data1_createx(flags);");
4943         }
4944         arg1 = (int) SvIV(ST(0));
4945         result = data1_createx(arg1);
4946
4947         {
4948             data1_handle * resultobj = (data1_handle *) malloc(sizeof(data1_handle));
4949             memmove(resultobj, &result, sizeof(data1_handle));
4950             ST(argvi) = sv_newmortal();
4951             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_data1_handle,0);
4952         }
4953         XSRETURN(argvi);
4954         fail:
4955         (void) _swigerr;
4956     }
4957     croak(_swigerr);
4958 }
4959
4960
4961 XS(_wrap_data1_destroy) {
4962     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4963     const char *_swigerr = _swigmsg;
4964     {
4965         data1_handle arg1 ;
4966         int argvi = 0;
4967         dXSARGS;
4968
4969         if ((items < 1) || (items > 1)) {
4970             SWIG_croak("Usage: data1_destroy(dh);");
4971         }
4972         {
4973             data1_handle * argp;
4974             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4975                 SWIG_croak("Type error in argument 1 of data1_destroy. Expected _p_data1_handle");
4976             }
4977             arg1 = *argp;
4978         }
4979         data1_destroy(arg1);
4980
4981
4982         XSRETURN(argvi);
4983         fail:
4984         (void) _swigerr;
4985     }
4986     croak(_swigerr);
4987 }
4988
4989
4990 XS(_wrap_get_parent_tag) {
4991     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4992     const char *_swigerr = _swigmsg;
4993     {
4994         data1_handle arg1 ;
4995         data1_node *arg2 ;
4996         data1_node *result;
4997         int argvi = 0;
4998         dXSARGS;
4999
5000         if ((items < 2) || (items > 2)) {
5001             SWIG_croak("Usage: get_parent_tag(dh,n);");
5002         }
5003         {
5004             data1_handle * argp;
5005             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5006                 SWIG_croak("Type error in argument 1 of get_parent_tag. Expected _p_data1_handle");
5007             }
5008             arg1 = *argp;
5009         }
5010         {
5011             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5012                 SWIG_croak("Type error in argument 2 of get_parent_tag. Expected _p_data1_node");
5013             }
5014         }
5015         result = (data1_node *)get_parent_tag(arg1,arg2);
5016
5017         ST(argvi) = sv_newmortal();
5018         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5019         XSRETURN(argvi);
5020         fail:
5021         (void) _swigerr;
5022     }
5023     croak(_swigerr);
5024 }
5025
5026
5027 XS(_wrap_data1_read_node) {
5028     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5029     const char *_swigerr = _swigmsg;
5030     {
5031         data1_handle arg1 ;
5032         char **arg2 ;
5033         NMEM arg3 ;
5034         data1_node *result;
5035         int argvi = 0;
5036         dXSARGS;
5037
5038         if ((items < 3) || (items > 3)) {
5039             SWIG_croak("Usage: data1_read_node(dh,buf,m);");
5040         }
5041         {
5042             data1_handle * argp;
5043             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5044                 SWIG_croak("Type error in argument 1 of data1_read_node. Expected _p_data1_handle");
5045             }
5046             arg1 = *argp;
5047         }
5048         {
5049             AV *tempav;
5050             I32 len;
5051             int i;
5052             SV  **tv;
5053             STRLEN na;
5054             if (!SvROK(ST(1)))
5055             croak("Argument 2 is not a reference.");
5056             if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
5057             croak("Argument 2 is not an array.");
5058             tempav = (AV*)SvRV(ST(1));
5059             len = av_len(tempav);
5060             arg2 = (char **) malloc((len+2)*sizeof(char *));
5061             for (i = 0; i <= len; i++) {
5062                 tv = av_fetch(tempav, i, 0);
5063                 arg2[i] = (char *) SvPV(*tv,na);
5064             }
5065             arg2[i] = NULL;
5066         }
5067         {
5068             NMEM * argp;
5069             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5070                 SWIG_croak("Type error in argument 3 of data1_read_node. Expected _p_NMEM");
5071             }
5072             arg3 = *argp;
5073         }
5074         result = (data1_node *)data1_read_node(arg1,(char const **)arg2,arg3);
5075
5076         ST(argvi) = sv_newmortal();
5077         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5078         {
5079             free(arg2);
5080         }
5081         XSRETURN(argvi);
5082         fail:
5083         {
5084             free(arg2);
5085         }
5086         (void) _swigerr;
5087     }
5088     croak(_swigerr);
5089 }
5090
5091
5092 XS(_wrap_data1_read_nodex) {
5093     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5094     const char *_swigerr = _swigmsg;
5095     {
5096         data1_handle arg1 ;
5097         NMEM arg2 ;
5098         int (*arg3)(void *) ;
5099         void *arg4 ;
5100         WRBUF arg5 ;
5101         data1_node *result;
5102         int argvi = 0;
5103         dXSARGS;
5104
5105         if ((items < 5) || (items > 5)) {
5106             SWIG_croak("Usage: data1_read_nodex(dh,m,get_byte,fh,wrbuf);");
5107         }
5108         {
5109             data1_handle * argp;
5110             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5111                 SWIG_croak("Type error in argument 1 of data1_read_nodex. Expected _p_data1_handle");
5112             }
5113             arg1 = *argp;
5114         }
5115         {
5116             NMEM * argp;
5117             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5118                 SWIG_croak("Type error in argument 2 of data1_read_nodex. Expected _p_NMEM");
5119             }
5120             arg2 = *argp;
5121         }
5122         {
5123             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_f_p_void__int,0) < 0) {
5124                 SWIG_croak("Type error in argument 3 of data1_read_nodex. Expected _p_f_p_void__int");
5125             }
5126         }
5127         {
5128             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, 0,0) < 0) {
5129                 SWIG_croak("Type error in argument 4 of data1_read_nodex. Expected _p_void");
5130             }
5131         }
5132         {
5133             WRBUF * argp;
5134             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_WRBUF,0) < 0) {
5135                 SWIG_croak("Type error in argument 5 of data1_read_nodex. Expected _p_WRBUF");
5136             }
5137             arg5 = *argp;
5138         }
5139         result = (data1_node *)data1_read_nodex(arg1,arg2,arg3,arg4,arg5);
5140
5141         ST(argvi) = sv_newmortal();
5142         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5143         XSRETURN(argvi);
5144         fail:
5145         (void) _swigerr;
5146     }
5147     croak(_swigerr);
5148 }
5149
5150
5151 XS(_wrap_data1_read_record) {
5152     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5153     const char *_swigerr = _swigmsg;
5154     {
5155         data1_handle arg1 ;
5156         int (*arg2)(void *,char *,size_t) ;
5157         void *arg3 ;
5158         NMEM arg4 ;
5159         data1_node *result;
5160         int argvi = 0;
5161         dXSARGS;
5162
5163         if ((items < 4) || (items > 4)) {
5164             SWIG_croak("Usage: data1_read_record(dh,rf,fh,m);");
5165         }
5166         {
5167             data1_handle * argp;
5168             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5169                 SWIG_croak("Type error in argument 1 of data1_read_record. Expected _p_data1_handle");
5170             }
5171             arg1 = *argp;
5172         }
5173         {
5174             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_f_p_void_p_char_size_t__int,0) < 0) {
5175                 SWIG_croak("Type error in argument 2 of data1_read_record. Expected _p_f_p_void_p_char_size_t__int");
5176             }
5177         }
5178         {
5179             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, 0,0) < 0) {
5180                 SWIG_croak("Type error in argument 3 of data1_read_record. Expected _p_void");
5181             }
5182         }
5183         {
5184             NMEM * argp;
5185             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5186                 SWIG_croak("Type error in argument 4 of data1_read_record. Expected _p_NMEM");
5187             }
5188             arg4 = *argp;
5189         }
5190         result = (data1_node *)data1_read_record(arg1,arg2,arg3,arg4);
5191
5192         ST(argvi) = sv_newmortal();
5193         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5194         XSRETURN(argvi);
5195         fail:
5196         (void) _swigerr;
5197     }
5198     croak(_swigerr);
5199 }
5200
5201
5202 XS(_wrap_data1_read_absyn) {
5203     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5204     const char *_swigerr = _swigmsg;
5205     {
5206         data1_handle arg1 ;
5207         char *arg2 ;
5208         int arg3 ;
5209         data1_absyn *result;
5210         int argvi = 0;
5211         dXSARGS;
5212
5213         if ((items < 3) || (items > 3)) {
5214             SWIG_croak("Usage: data1_read_absyn(dh,file,file_must_exist);");
5215         }
5216         {
5217             data1_handle * argp;
5218             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5219                 SWIG_croak("Type error in argument 1 of data1_read_absyn. Expected _p_data1_handle");
5220             }
5221             arg1 = *argp;
5222         }
5223         if (!SvOK((SV*) ST(1))) arg2 = 0;
5224         else arg2 = (char *) SvPV(ST(1), PL_na);
5225         arg3 = (int) SvIV(ST(2));
5226         result = (data1_absyn *)data1_read_absyn(arg1,(char const *)arg2,arg3);
5227
5228         ST(argvi) = sv_newmortal();
5229         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_absyn,0);
5230         XSRETURN(argvi);
5231         fail:
5232         (void) _swigerr;
5233     }
5234     croak(_swigerr);
5235 }
5236
5237
5238 XS(_wrap_data1_gettagbynum) {
5239     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5240     const char *_swigerr = _swigmsg;
5241     {
5242         data1_handle arg1 ;
5243         data1_tagset *arg2 ;
5244         int arg3 ;
5245         int arg4 ;
5246         data1_tag *result;
5247         int argvi = 0;
5248         dXSARGS;
5249
5250         if ((items < 4) || (items > 4)) {
5251             SWIG_croak("Usage: data1_gettagbynum(dh,s,type,value);");
5252         }
5253         {
5254             data1_handle * argp;
5255             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5256                 SWIG_croak("Type error in argument 1 of data1_gettagbynum. Expected _p_data1_handle");
5257             }
5258             arg1 = *argp;
5259         }
5260         {
5261             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_tagset,0) < 0) {
5262                 SWIG_croak("Type error in argument 2 of data1_gettagbynum. Expected _p_data1_tagset");
5263             }
5264         }
5265         arg3 = (int) SvIV(ST(2));
5266         arg4 = (int) SvIV(ST(3));
5267         result = (data1_tag *)data1_gettagbynum(arg1,arg2,arg3,arg4);
5268
5269         ST(argvi) = sv_newmortal();
5270         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tag,0);
5271         XSRETURN(argvi);
5272         fail:
5273         (void) _swigerr;
5274     }
5275     croak(_swigerr);
5276 }
5277
5278
5279 XS(_wrap_data1_empty_tagset) {
5280     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5281     const char *_swigerr = _swigmsg;
5282     {
5283         data1_handle arg1 ;
5284         data1_tagset *result;
5285         int argvi = 0;
5286         dXSARGS;
5287
5288         if ((items < 1) || (items > 1)) {
5289             SWIG_croak("Usage: data1_empty_tagset(dh);");
5290         }
5291         {
5292             data1_handle * argp;
5293             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5294                 SWIG_croak("Type error in argument 1 of data1_empty_tagset. Expected _p_data1_handle");
5295             }
5296             arg1 = *argp;
5297         }
5298         result = (data1_tagset *)data1_empty_tagset(arg1);
5299
5300         ST(argvi) = sv_newmortal();
5301         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tagset,0);
5302         XSRETURN(argvi);
5303         fail:
5304         (void) _swigerr;
5305     }
5306     croak(_swigerr);
5307 }
5308
5309
5310 XS(_wrap_data1_read_tagset) {
5311     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5312     const char *_swigerr = _swigmsg;
5313     {
5314         data1_handle arg1 ;
5315         char *arg2 ;
5316         int arg3 ;
5317         data1_tagset *result;
5318         int argvi = 0;
5319         dXSARGS;
5320
5321         if ((items < 3) || (items > 3)) {
5322             SWIG_croak("Usage: data1_read_tagset(dh,file,type);");
5323         }
5324         {
5325             data1_handle * argp;
5326             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5327                 SWIG_croak("Type error in argument 1 of data1_read_tagset. Expected _p_data1_handle");
5328             }
5329             arg1 = *argp;
5330         }
5331         if (!SvOK((SV*) ST(1))) arg2 = 0;
5332         else arg2 = (char *) SvPV(ST(1), PL_na);
5333         arg3 = (int) SvIV(ST(2));
5334         result = (data1_tagset *)data1_read_tagset(arg1,(char const *)arg2,arg3);
5335
5336         ST(argvi) = sv_newmortal();
5337         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tagset,0);
5338         XSRETURN(argvi);
5339         fail:
5340         (void) _swigerr;
5341     }
5342     croak(_swigerr);
5343 }
5344
5345
5346 XS(_wrap_data1_getelementbytagname) {
5347     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5348     const char *_swigerr = _swigmsg;
5349     {
5350         data1_handle arg1 ;
5351         data1_absyn *arg2 ;
5352         data1_element *arg3 ;
5353         char *arg4 ;
5354         data1_element *result;
5355         int argvi = 0;
5356         dXSARGS;
5357
5358         if ((items < 4) || (items > 4)) {
5359             SWIG_croak("Usage: data1_getelementbytagname(dh,abs,parent,tagname);");
5360         }
5361         {
5362             data1_handle * argp;
5363             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5364                 SWIG_croak("Type error in argument 1 of data1_getelementbytagname. Expected _p_data1_handle");
5365             }
5366             arg1 = *argp;
5367         }
5368         {
5369             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_absyn,0) < 0) {
5370                 SWIG_croak("Type error in argument 2 of data1_getelementbytagname. Expected _p_data1_absyn");
5371             }
5372         }
5373         {
5374             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_element,0) < 0) {
5375                 SWIG_croak("Type error in argument 3 of data1_getelementbytagname. Expected _p_data1_element");
5376             }
5377         }
5378         if (!SvOK((SV*) ST(3))) arg4 = 0;
5379         else arg4 = (char *) SvPV(ST(3), PL_na);
5380         result = (data1_element *)data1_getelementbytagname(arg1,arg2,arg3,(char const *)arg4);
5381
5382         ST(argvi) = sv_newmortal();
5383         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_element,0);
5384         XSRETURN(argvi);
5385         fail:
5386         (void) _swigerr;
5387     }
5388     croak(_swigerr);
5389 }
5390
5391
5392 XS(_wrap_data1_nodetogr) {
5393     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5394     const char *_swigerr = _swigmsg;
5395     {
5396         data1_handle arg1 ;
5397         data1_node *arg2 ;
5398         int arg3 ;
5399         ODR arg4 ;
5400         int *arg5 ;
5401         Z_GenericRecord *result;
5402         int argvi = 0;
5403         dXSARGS;
5404
5405         if ((items < 5) || (items > 5)) {
5406             SWIG_croak("Usage: data1_nodetogr(dh,n,select,o,len);");
5407         }
5408         {
5409             data1_handle * argp;
5410             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5411                 SWIG_croak("Type error in argument 1 of data1_nodetogr. Expected _p_data1_handle");
5412             }
5413             arg1 = *argp;
5414         }
5415         {
5416             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5417                 SWIG_croak("Type error in argument 2 of data1_nodetogr. Expected _p_data1_node");
5418             }
5419         }
5420         arg3 = (int) SvIV(ST(2));
5421         {
5422             ODR * argp;
5423             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
5424                 SWIG_croak("Type error in argument 4 of data1_nodetogr. Expected _p_ODR");
5425             }
5426             arg4 = *argp;
5427         }
5428         {
5429             int i;
5430             if (!SvIOK(ST(4)))
5431             croak("Argument 5 is not an integer.");
5432             i = SvIV(ST(4));
5433             arg5 = &i;
5434         }
5435         result = (Z_GenericRecord *)data1_nodetogr(arg1,arg2,arg3,arg4,arg5);
5436
5437         ST(argvi) = sv_newmortal();
5438         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_GenericRecord,0);
5439         XSRETURN(argvi);
5440         fail:
5441         (void) _swigerr;
5442     }
5443     croak(_swigerr);
5444 }
5445
5446
5447 XS(_wrap_data1_gettagbyname) {
5448     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5449     const char *_swigerr = _swigmsg;
5450     {
5451         data1_handle arg1 ;
5452         data1_tagset *arg2 ;
5453         char *arg3 ;
5454         data1_tag *result;
5455         int argvi = 0;
5456         dXSARGS;
5457
5458         if ((items < 3) || (items > 3)) {
5459             SWIG_croak("Usage: data1_gettagbyname(dh,s,name);");
5460         }
5461         {
5462             data1_handle * argp;
5463             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5464                 SWIG_croak("Type error in argument 1 of data1_gettagbyname. Expected _p_data1_handle");
5465             }
5466             arg1 = *argp;
5467         }
5468         {
5469             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_tagset,0) < 0) {
5470                 SWIG_croak("Type error in argument 2 of data1_gettagbyname. Expected _p_data1_tagset");
5471             }
5472         }
5473         if (!SvOK((SV*) ST(2))) arg3 = 0;
5474         else arg3 = (char *) SvPV(ST(2), PL_na);
5475         result = (data1_tag *)data1_gettagbyname(arg1,arg2,(char const *)arg3);
5476
5477         ST(argvi) = sv_newmortal();
5478         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tag,0);
5479         XSRETURN(argvi);
5480         fail:
5481         (void) _swigerr;
5482     }
5483     croak(_swigerr);
5484 }
5485
5486
5487 XS(_wrap_data1_free_tree) {
5488     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5489     const char *_swigerr = _swigmsg;
5490     {
5491         data1_handle arg1 ;
5492         data1_node *arg2 ;
5493         int argvi = 0;
5494         dXSARGS;
5495
5496         if ((items < 2) || (items > 2)) {
5497             SWIG_croak("Usage: data1_free_tree(dh,t);");
5498         }
5499         {
5500             data1_handle * argp;
5501             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5502                 SWIG_croak("Type error in argument 1 of data1_free_tree. Expected _p_data1_handle");
5503             }
5504             arg1 = *argp;
5505         }
5506         {
5507             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5508                 SWIG_croak("Type error in argument 2 of data1_free_tree. Expected _p_data1_node");
5509             }
5510         }
5511         data1_free_tree(arg1,arg2);
5512
5513
5514         XSRETURN(argvi);
5515         fail:
5516         (void) _swigerr;
5517     }
5518     croak(_swigerr);
5519 }
5520
5521
5522 XS(_wrap_data1_nodetobuf) {
5523     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5524     const char *_swigerr = _swigmsg;
5525     {
5526         data1_handle arg1 ;
5527         data1_node *arg2 ;
5528         int arg3 ;
5529         int *arg4 ;
5530         char *result;
5531         int argvi = 0;
5532         dXSARGS;
5533
5534         if ((items < 4) || (items > 4)) {
5535             SWIG_croak("Usage: data1_nodetobuf(dh,n,select,len);");
5536         }
5537         {
5538             data1_handle * argp;
5539             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5540                 SWIG_croak("Type error in argument 1 of data1_nodetobuf. Expected _p_data1_handle");
5541             }
5542             arg1 = *argp;
5543         }
5544         {
5545             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5546                 SWIG_croak("Type error in argument 2 of data1_nodetobuf. Expected _p_data1_node");
5547             }
5548         }
5549         arg3 = (int) SvIV(ST(2));
5550         {
5551             int i;
5552             if (!SvIOK(ST(3)))
5553             croak("Argument 4 is not an integer.");
5554             i = SvIV(ST(3));
5555             arg4 = &i;
5556         }
5557         result = (char *)data1_nodetobuf(arg1,arg2,arg3,arg4);
5558
5559         ST(argvi) = sv_newmortal();
5560         if (result) {
5561             sv_setpv((SV*)ST(argvi++), (char *) result);
5562         }else {
5563             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
5564         }
5565         XSRETURN(argvi);
5566         fail:
5567         (void) _swigerr;
5568     }
5569     croak(_swigerr);
5570 }
5571
5572
5573 XS(_wrap_data1_mk_tag_data_wd) {
5574     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5575     const char *_swigerr = _swigmsg;
5576     {
5577         data1_handle arg1 ;
5578         data1_node *arg2 ;
5579         char *arg3 ;
5580         NMEM arg4 ;
5581         data1_node *result;
5582         int argvi = 0;
5583         dXSARGS;
5584
5585         if ((items < 4) || (items > 4)) {
5586             SWIG_croak("Usage: data1_mk_tag_data_wd(dh,at,tagname,m);");
5587         }
5588         {
5589             data1_handle * argp;
5590             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5591                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_wd. Expected _p_data1_handle");
5592             }
5593             arg1 = *argp;
5594         }
5595         {
5596             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5597                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_wd. Expected _p_data1_node");
5598             }
5599         }
5600         if (!SvOK((SV*) ST(2))) arg3 = 0;
5601         else arg3 = (char *) SvPV(ST(2), PL_na);
5602         {
5603             NMEM * argp;
5604             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5605                 SWIG_croak("Type error in argument 4 of data1_mk_tag_data_wd. Expected _p_NMEM");
5606             }
5607             arg4 = *argp;
5608         }
5609         result = (data1_node *)data1_mk_tag_data_wd(arg1,arg2,(char const *)arg3,arg4);
5610
5611         ST(argvi) = sv_newmortal();
5612         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5613         XSRETURN(argvi);
5614         fail:
5615         (void) _swigerr;
5616     }
5617     croak(_swigerr);
5618 }
5619
5620
5621 XS(_wrap_data1_mk_tag_data) {
5622     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5623     const char *_swigerr = _swigmsg;
5624     {
5625         data1_handle arg1 ;
5626         data1_node *arg2 ;
5627         char *arg3 ;
5628         NMEM arg4 ;
5629         data1_node *result;
5630         int argvi = 0;
5631         dXSARGS;
5632
5633         if ((items < 4) || (items > 4)) {
5634             SWIG_croak("Usage: data1_mk_tag_data(dh,at,tagname,m);");
5635         }
5636         {
5637             data1_handle * argp;
5638             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5639                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data. Expected _p_data1_handle");
5640             }
5641             arg1 = *argp;
5642         }
5643         {
5644             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5645                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data. Expected _p_data1_node");
5646             }
5647         }
5648         if (!SvOK((SV*) ST(2))) arg3 = 0;
5649         else arg3 = (char *) SvPV(ST(2), PL_na);
5650         {
5651             NMEM * argp;
5652             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5653                 SWIG_croak("Type error in argument 4 of data1_mk_tag_data. Expected _p_NMEM");
5654             }
5655             arg4 = *argp;
5656         }
5657         result = (data1_node *)data1_mk_tag_data(arg1,arg2,(char const *)arg3,arg4);
5658
5659         ST(argvi) = sv_newmortal();
5660         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5661         XSRETURN(argvi);
5662         fail:
5663         (void) _swigerr;
5664     }
5665     croak(_swigerr);
5666 }
5667
5668
5669 XS(_wrap_data1_maptype) {
5670     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5671     const char *_swigerr = _swigmsg;
5672     {
5673         data1_handle arg1 ;
5674         char *arg2 ;
5675         int result;
5676         int argvi = 0;
5677         dXSARGS;
5678
5679         if ((items < 2) || (items > 2)) {
5680             SWIG_croak("Usage: data1_maptype(dh,t);");
5681         }
5682         {
5683             data1_handle * argp;
5684             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5685                 SWIG_croak("Type error in argument 1 of data1_maptype. Expected _p_data1_handle");
5686             }
5687             arg1 = *argp;
5688         }
5689         if (!SvOK((SV*) ST(1))) arg2 = 0;
5690         else arg2 = (char *) SvPV(ST(1), PL_na);
5691         result = (int)data1_maptype(arg1,arg2);
5692
5693         ST(argvi) = sv_newmortal();
5694         sv_setiv(ST(argvi++), (IV) result);
5695         XSRETURN(argvi);
5696         fail:
5697         (void) _swigerr;
5698     }
5699     croak(_swigerr);
5700 }
5701
5702
5703 XS(_wrap_data1_read_varset) {
5704     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5705     const char *_swigerr = _swigmsg;
5706     {
5707         data1_handle arg1 ;
5708         char *arg2 ;
5709         data1_varset *result;
5710         int argvi = 0;
5711         dXSARGS;
5712
5713         if ((items < 2) || (items > 2)) {
5714             SWIG_croak("Usage: data1_read_varset(dh,file);");
5715         }
5716         {
5717             data1_handle * argp;
5718             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5719                 SWIG_croak("Type error in argument 1 of data1_read_varset. Expected _p_data1_handle");
5720             }
5721             arg1 = *argp;
5722         }
5723         if (!SvOK((SV*) ST(1))) arg2 = 0;
5724         else arg2 = (char *) SvPV(ST(1), PL_na);
5725         result = (data1_varset *)data1_read_varset(arg1,(char const *)arg2);
5726
5727         ST(argvi) = sv_newmortal();
5728         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_varset,0);
5729         XSRETURN(argvi);
5730         fail:
5731         (void) _swigerr;
5732     }
5733     croak(_swigerr);
5734 }
5735
5736
5737 XS(_wrap_data1_getvartypebyct) {
5738     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5739     const char *_swigerr = _swigmsg;
5740     {
5741         data1_handle arg1 ;
5742         data1_varset *arg2 ;
5743         char *arg3 ;
5744         char *arg4 ;
5745         data1_vartype *result;
5746         int argvi = 0;
5747         dXSARGS;
5748
5749         if ((items < 4) || (items > 4)) {
5750             SWIG_croak("Usage: data1_getvartypebyct(dh,set,zclass,type);");
5751         }
5752         {
5753             data1_handle * argp;
5754             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5755                 SWIG_croak("Type error in argument 1 of data1_getvartypebyct. Expected _p_data1_handle");
5756             }
5757             arg1 = *argp;
5758         }
5759         {
5760             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_varset,0) < 0) {
5761                 SWIG_croak("Type error in argument 2 of data1_getvartypebyct. Expected _p_data1_varset");
5762             }
5763         }
5764         if (!SvOK((SV*) ST(2))) arg3 = 0;
5765         else arg3 = (char *) SvPV(ST(2), PL_na);
5766         if (!SvOK((SV*) ST(3))) arg4 = 0;
5767         else arg4 = (char *) SvPV(ST(3), PL_na);
5768         result = (data1_vartype *)data1_getvartypebyct(arg1,arg2,arg3,arg4);
5769
5770         ST(argvi) = sv_newmortal();
5771         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_vartype,0);
5772         XSRETURN(argvi);
5773         fail:
5774         (void) _swigerr;
5775     }
5776     croak(_swigerr);
5777 }
5778
5779
5780 XS(_wrap_data1_read_espec1) {
5781     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5782     const char *_swigerr = _swigmsg;
5783     {
5784         data1_handle arg1 ;
5785         char *arg2 ;
5786         Z_Espec1 *result;
5787         int argvi = 0;
5788         dXSARGS;
5789
5790         if ((items < 2) || (items > 2)) {
5791             SWIG_croak("Usage: data1_read_espec1(dh,file);");
5792         }
5793         {
5794             data1_handle * argp;
5795             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5796                 SWIG_croak("Type error in argument 1 of data1_read_espec1. Expected _p_data1_handle");
5797             }
5798             arg1 = *argp;
5799         }
5800         if (!SvOK((SV*) ST(1))) arg2 = 0;
5801         else arg2 = (char *) SvPV(ST(1), PL_na);
5802         result = (Z_Espec1 *)data1_read_espec1(arg1,(char const *)arg2);
5803
5804         ST(argvi) = sv_newmortal();
5805         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_Espec1,0);
5806         XSRETURN(argvi);
5807         fail:
5808         (void) _swigerr;
5809     }
5810     croak(_swigerr);
5811 }
5812
5813
5814 XS(_wrap_data1_doespec1) {
5815     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5816     const char *_swigerr = _swigmsg;
5817     {
5818         data1_handle arg1 ;
5819         data1_node *arg2 ;
5820         Z_Espec1 *arg3 ;
5821         int result;
5822         int argvi = 0;
5823         dXSARGS;
5824
5825         if ((items < 3) || (items > 3)) {
5826             SWIG_croak("Usage: data1_doespec1(dh,n,e);");
5827         }
5828         {
5829             data1_handle * argp;
5830             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5831                 SWIG_croak("Type error in argument 1 of data1_doespec1. Expected _p_data1_handle");
5832             }
5833             arg1 = *argp;
5834         }
5835         {
5836             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5837                 SWIG_croak("Type error in argument 2 of data1_doespec1. Expected _p_data1_node");
5838             }
5839         }
5840         {
5841             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_Z_Espec1,0) < 0) {
5842                 SWIG_croak("Type error in argument 3 of data1_doespec1. Expected _p_Z_Espec1");
5843             }
5844         }
5845         result = (int)data1_doespec1(arg1,arg2,arg3);
5846
5847         ST(argvi) = sv_newmortal();
5848         sv_setiv(ST(argvi++), (IV) result);
5849         XSRETURN(argvi);
5850         fail:
5851         (void) _swigerr;
5852     }
5853     croak(_swigerr);
5854 }
5855
5856
5857 XS(_wrap_data1_getesetbyname) {
5858     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5859     const char *_swigerr = _swigmsg;
5860     {
5861         data1_handle arg1 ;
5862         data1_absyn *arg2 ;
5863         char *arg3 ;
5864         data1_esetname *result;
5865         int argvi = 0;
5866         dXSARGS;
5867
5868         if ((items < 3) || (items > 3)) {
5869             SWIG_croak("Usage: data1_getesetbyname(dh,a,name);");
5870         }
5871         {
5872             data1_handle * argp;
5873             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5874                 SWIG_croak("Type error in argument 1 of data1_getesetbyname. Expected _p_data1_handle");
5875             }
5876             arg1 = *argp;
5877         }
5878         {
5879             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_absyn,0) < 0) {
5880                 SWIG_croak("Type error in argument 2 of data1_getesetbyname. Expected _p_data1_absyn");
5881             }
5882         }
5883         if (!SvOK((SV*) ST(2))) arg3 = 0;
5884         else arg3 = (char *) SvPV(ST(2), PL_na);
5885         result = (data1_esetname *)data1_getesetbyname(arg1,arg2,(char const *)arg3);
5886
5887         ST(argvi) = sv_newmortal();
5888         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_esetname,0);
5889         XSRETURN(argvi);
5890         fail:
5891         (void) _swigerr;
5892     }
5893     croak(_swigerr);
5894 }
5895
5896
5897 XS(_wrap_data1_getelementbyname) {
5898     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5899     const char *_swigerr = _swigmsg;
5900     {
5901         data1_handle arg1 ;
5902         data1_absyn *arg2 ;
5903         char *arg3 ;
5904         data1_element *result;
5905         int argvi = 0;
5906         dXSARGS;
5907
5908         if ((items < 3) || (items > 3)) {
5909             SWIG_croak("Usage: data1_getelementbyname(dh,absyn,name);");
5910         }
5911         {
5912             data1_handle * argp;
5913             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5914                 SWIG_croak("Type error in argument 1 of data1_getelementbyname. Expected _p_data1_handle");
5915             }
5916             arg1 = *argp;
5917         }
5918         {
5919             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_absyn,0) < 0) {
5920                 SWIG_croak("Type error in argument 2 of data1_getelementbyname. Expected _p_data1_absyn");
5921             }
5922         }
5923         if (!SvOK((SV*) ST(2))) arg3 = 0;
5924         else arg3 = (char *) SvPV(ST(2), PL_na);
5925         result = (data1_element *)data1_getelementbyname(arg1,arg2,(char const *)arg3);
5926
5927         ST(argvi) = sv_newmortal();
5928         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_element,0);
5929         XSRETURN(argvi);
5930         fail:
5931         (void) _swigerr;
5932     }
5933     croak(_swigerr);
5934 }
5935
5936
5937 XS(_wrap_data1_mk_node2) {
5938     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5939     const char *_swigerr = _swigmsg;
5940     {
5941         data1_handle arg1 ;
5942         NMEM arg2 ;
5943         int arg3 ;
5944         data1_node *arg4 ;
5945         data1_node *result;
5946         int argvi = 0;
5947         dXSARGS;
5948
5949         if ((items < 4) || (items > 4)) {
5950             SWIG_croak("Usage: data1_mk_node2(dh,m,type,parent);");
5951         }
5952         {
5953             data1_handle * argp;
5954             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5955                 SWIG_croak("Type error in argument 1 of data1_mk_node2. Expected _p_data1_handle");
5956             }
5957             arg1 = *argp;
5958         }
5959         {
5960             NMEM * argp;
5961             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5962                 SWIG_croak("Type error in argument 2 of data1_mk_node2. Expected _p_NMEM");
5963             }
5964             arg2 = *argp;
5965         }
5966         arg3 = (int) SvIV(ST(2));
5967         {
5968             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
5969                 SWIG_croak("Type error in argument 4 of data1_mk_node2. Expected _p_data1_node");
5970             }
5971         }
5972         result = (data1_node *)data1_mk_node2(arg1,arg2,arg3,arg4);
5973
5974         ST(argvi) = sv_newmortal();
5975         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5976         XSRETURN(argvi);
5977         fail:
5978         (void) _swigerr;
5979     }
5980     croak(_swigerr);
5981 }
5982
5983
5984 XS(_wrap_data1_mk_tag) {
5985     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5986     const char *_swigerr = _swigmsg;
5987     {
5988         data1_handle arg1 ;
5989         NMEM arg2 ;
5990         char *arg3 ;
5991         char **arg4 ;
5992         data1_node *arg5 ;
5993         data1_node *result;
5994         int argvi = 0;
5995         dXSARGS;
5996
5997         if ((items < 5) || (items > 5)) {
5998             SWIG_croak("Usage: data1_mk_tag(dh,nmem,tag,attr,at);");
5999         }
6000         {
6001             data1_handle * argp;
6002             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6003                 SWIG_croak("Type error in argument 1 of data1_mk_tag. Expected _p_data1_handle");
6004             }
6005             arg1 = *argp;
6006         }
6007         {
6008             NMEM * argp;
6009             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6010                 SWIG_croak("Type error in argument 2 of data1_mk_tag. Expected _p_NMEM");
6011             }
6012             arg2 = *argp;
6013         }
6014         if (!SvOK((SV*) ST(2))) arg3 = 0;
6015         else arg3 = (char *) SvPV(ST(2), PL_na);
6016         {
6017             AV *tempav;
6018             I32 len;
6019             int i;
6020             SV  **tv;
6021             STRLEN na;
6022             if (!SvROK(ST(3)))
6023             croak("Argument 4 is not a reference.");
6024             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
6025             croak("Argument 4 is not an array.");
6026             tempav = (AV*)SvRV(ST(3));
6027             len = av_len(tempav);
6028             arg4 = (char **) malloc((len+2)*sizeof(char *));
6029             for (i = 0; i <= len; i++) {
6030                 tv = av_fetch(tempav, i, 0);
6031                 arg4[i] = (char *) SvPV(*tv,na);
6032             }
6033             arg4[i] = NULL;
6034         }
6035         {
6036             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6037                 SWIG_croak("Type error in argument 5 of data1_mk_tag. Expected _p_data1_node");
6038             }
6039         }
6040         result = (data1_node *)data1_mk_tag(arg1,arg2,(char const *)arg3,(char const **)arg4,arg5);
6041
6042         ST(argvi) = sv_newmortal();
6043         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6044         {
6045             free(arg4);
6046         }
6047         XSRETURN(argvi);
6048         fail:
6049         {
6050             free(arg4);
6051         }
6052         (void) _swigerr;
6053     }
6054     croak(_swigerr);
6055 }
6056
6057
6058 XS(_wrap_data1_mk_tag_n) {
6059     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6060     const char *_swigerr = _swigmsg;
6061     {
6062         data1_handle arg1 ;
6063         NMEM arg2 ;
6064         char *arg3 ;
6065         size_t arg4 ;
6066         char **arg5 ;
6067         data1_node *arg6 ;
6068         data1_node *result;
6069         int argvi = 0;
6070         dXSARGS;
6071
6072         if ((items < 6) || (items > 6)) {
6073             SWIG_croak("Usage: data1_mk_tag_n(dh,nmem,tag,len,attr,at);");
6074         }
6075         {
6076             data1_handle * argp;
6077             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6078                 SWIG_croak("Type error in argument 1 of data1_mk_tag_n. Expected _p_data1_handle");
6079             }
6080             arg1 = *argp;
6081         }
6082         {
6083             NMEM * argp;
6084             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6085                 SWIG_croak("Type error in argument 2 of data1_mk_tag_n. Expected _p_NMEM");
6086             }
6087             arg2 = *argp;
6088         }
6089         if (!SvOK((SV*) ST(2))) arg3 = 0;
6090         else arg3 = (char *) SvPV(ST(2), PL_na);
6091         arg4 = (size_t) SvUV(ST(3));
6092         {
6093             AV *tempav;
6094             I32 len;
6095             int i;
6096             SV  **tv;
6097             STRLEN na;
6098             if (!SvROK(ST(4)))
6099             croak("Argument 5 is not a reference.");
6100             if (SvTYPE(SvRV(ST(4))) != SVt_PVAV)
6101             croak("Argument 5 is not an array.");
6102             tempav = (AV*)SvRV(ST(4));
6103             len = av_len(tempav);
6104             arg5 = (char **) malloc((len+2)*sizeof(char *));
6105             for (i = 0; i <= len; i++) {
6106                 tv = av_fetch(tempav, i, 0);
6107                 arg5[i] = (char *) SvPV(*tv,na);
6108             }
6109             arg5[i] = NULL;
6110         }
6111         {
6112             if (SWIG_ConvertPtr(ST(5), (void **) &arg6, SWIGTYPE_p_data1_node,0) < 0) {
6113                 SWIG_croak("Type error in argument 6 of data1_mk_tag_n. Expected _p_data1_node");
6114             }
6115         }
6116         result = (data1_node *)data1_mk_tag_n(arg1,arg2,(char const *)arg3,arg4,(char const **)arg5,arg6);
6117
6118         ST(argvi) = sv_newmortal();
6119         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6120         {
6121             free(arg5);
6122         }
6123         XSRETURN(argvi);
6124         fail:
6125         {
6126             free(arg5);
6127         }
6128         (void) _swigerr;
6129     }
6130     croak(_swigerr);
6131 }
6132
6133
6134 XS(_wrap_data1_tag_add_attr) {
6135     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6136     const char *_swigerr = _swigmsg;
6137     {
6138         data1_handle arg1 ;
6139         NMEM arg2 ;
6140         data1_node *arg3 ;
6141         char **arg4 ;
6142         int argvi = 0;
6143         dXSARGS;
6144
6145         if ((items < 4) || (items > 4)) {
6146             SWIG_croak("Usage: data1_tag_add_attr(dh,nmem,res,attr);");
6147         }
6148         {
6149             data1_handle * argp;
6150             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6151                 SWIG_croak("Type error in argument 1 of data1_tag_add_attr. Expected _p_data1_handle");
6152             }
6153             arg1 = *argp;
6154         }
6155         {
6156             NMEM * argp;
6157             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6158                 SWIG_croak("Type error in argument 2 of data1_tag_add_attr. Expected _p_NMEM");
6159             }
6160             arg2 = *argp;
6161         }
6162         {
6163             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_node,0) < 0) {
6164                 SWIG_croak("Type error in argument 3 of data1_tag_add_attr. Expected _p_data1_node");
6165             }
6166         }
6167         {
6168             AV *tempav;
6169             I32 len;
6170             int i;
6171             SV  **tv;
6172             STRLEN na;
6173             if (!SvROK(ST(3)))
6174             croak("Argument 4 is not a reference.");
6175             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
6176             croak("Argument 4 is not an array.");
6177             tempav = (AV*)SvRV(ST(3));
6178             len = av_len(tempav);
6179             arg4 = (char **) malloc((len+2)*sizeof(char *));
6180             for (i = 0; i <= len; i++) {
6181                 tv = av_fetch(tempav, i, 0);
6182                 arg4[i] = (char *) SvPV(*tv,na);
6183             }
6184             arg4[i] = NULL;
6185         }
6186         data1_tag_add_attr(arg1,arg2,arg3,(char const **)arg4);
6187
6188
6189         {
6190             free(arg4);
6191         }
6192         XSRETURN(argvi);
6193         fail:
6194         {
6195             free(arg4);
6196         }
6197         (void) _swigerr;
6198     }
6199     croak(_swigerr);
6200 }
6201
6202
6203 XS(_wrap_data1_mk_text_n) {
6204     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6205     const char *_swigerr = _swigmsg;
6206     {
6207         data1_handle arg1 ;
6208         NMEM arg2 ;
6209         char *arg3 ;
6210         size_t arg4 ;
6211         data1_node *arg5 ;
6212         data1_node *result;
6213         int argvi = 0;
6214         dXSARGS;
6215
6216         if ((items < 5) || (items > 5)) {
6217             SWIG_croak("Usage: data1_mk_text_n(dh,mem,buf,len,parent);");
6218         }
6219         {
6220             data1_handle * argp;
6221             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6222                 SWIG_croak("Type error in argument 1 of data1_mk_text_n. Expected _p_data1_handle");
6223             }
6224             arg1 = *argp;
6225         }
6226         {
6227             NMEM * argp;
6228             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6229                 SWIG_croak("Type error in argument 2 of data1_mk_text_n. Expected _p_NMEM");
6230             }
6231             arg2 = *argp;
6232         }
6233         if (!SvOK((SV*) ST(2))) arg3 = 0;
6234         else arg3 = (char *) SvPV(ST(2), PL_na);
6235         arg4 = (size_t) SvUV(ST(3));
6236         {
6237             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6238                 SWIG_croak("Type error in argument 5 of data1_mk_text_n. Expected _p_data1_node");
6239             }
6240         }
6241         result = (data1_node *)data1_mk_text_n(arg1,arg2,(char const *)arg3,arg4,arg5);
6242
6243         ST(argvi) = sv_newmortal();
6244         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6245         XSRETURN(argvi);
6246         fail:
6247         (void) _swigerr;
6248     }
6249     croak(_swigerr);
6250 }
6251
6252
6253 XS(_wrap_data1_mk_text_nf) {
6254     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6255     const char *_swigerr = _swigmsg;
6256     {
6257         data1_handle arg1 ;
6258         NMEM arg2 ;
6259         char *arg3 ;
6260         size_t arg4 ;
6261         data1_node *arg5 ;
6262         data1_node *result;
6263         int argvi = 0;
6264         dXSARGS;
6265
6266         if ((items < 5) || (items > 5)) {
6267             SWIG_croak("Usage: data1_mk_text_nf(dh,mem,buf,len,parent);");
6268         }
6269         {
6270             data1_handle * argp;
6271             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6272                 SWIG_croak("Type error in argument 1 of data1_mk_text_nf. Expected _p_data1_handle");
6273             }
6274             arg1 = *argp;
6275         }
6276         {
6277             NMEM * argp;
6278             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6279                 SWIG_croak("Type error in argument 2 of data1_mk_text_nf. Expected _p_NMEM");
6280             }
6281             arg2 = *argp;
6282         }
6283         if (!SvOK((SV*) ST(2))) arg3 = 0;
6284         else arg3 = (char *) SvPV(ST(2), PL_na);
6285         arg4 = (size_t) SvUV(ST(3));
6286         {
6287             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6288                 SWIG_croak("Type error in argument 5 of data1_mk_text_nf. Expected _p_data1_node");
6289             }
6290         }
6291         result = (data1_node *)data1_mk_text_nf(arg1,arg2,(char const *)arg3,arg4,arg5);
6292
6293         ST(argvi) = sv_newmortal();
6294         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6295         XSRETURN(argvi);
6296         fail:
6297         (void) _swigerr;
6298     }
6299     croak(_swigerr);
6300 }
6301
6302
6303 XS(_wrap_data1_mk_text) {
6304     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6305     const char *_swigerr = _swigmsg;
6306     {
6307         data1_handle arg1 ;
6308         NMEM arg2 ;
6309         char *arg3 ;
6310         data1_node *arg4 ;
6311         data1_node *result;
6312         int argvi = 0;
6313         dXSARGS;
6314
6315         if ((items < 4) || (items > 4)) {
6316             SWIG_croak("Usage: data1_mk_text(dh,mem,buf,parent);");
6317         }
6318         {
6319             data1_handle * argp;
6320             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6321                 SWIG_croak("Type error in argument 1 of data1_mk_text. Expected _p_data1_handle");
6322             }
6323             arg1 = *argp;
6324         }
6325         {
6326             NMEM * argp;
6327             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6328                 SWIG_croak("Type error in argument 2 of data1_mk_text. Expected _p_NMEM");
6329             }
6330             arg2 = *argp;
6331         }
6332         if (!SvOK((SV*) ST(2))) arg3 = 0;
6333         else arg3 = (char *) SvPV(ST(2), PL_na);
6334         {
6335             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
6336                 SWIG_croak("Type error in argument 4 of data1_mk_text. Expected _p_data1_node");
6337             }
6338         }
6339         result = (data1_node *)data1_mk_text(arg1,arg2,(char const *)arg3,arg4);
6340
6341         ST(argvi) = sv_newmortal();
6342         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6343         XSRETURN(argvi);
6344         fail:
6345         (void) _swigerr;
6346     }
6347     croak(_swigerr);
6348 }
6349
6350
6351 XS(_wrap_data1_mk_comment_n) {
6352     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6353     const char *_swigerr = _swigmsg;
6354     {
6355         data1_handle arg1 ;
6356         NMEM arg2 ;
6357         char *arg3 ;
6358         size_t arg4 ;
6359         data1_node *arg5 ;
6360         data1_node *result;
6361         int argvi = 0;
6362         dXSARGS;
6363
6364         if ((items < 5) || (items > 5)) {
6365             SWIG_croak("Usage: data1_mk_comment_n(dh,mem,buf,len,parent);");
6366         }
6367         {
6368             data1_handle * argp;
6369             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6370                 SWIG_croak("Type error in argument 1 of data1_mk_comment_n. Expected _p_data1_handle");
6371             }
6372             arg1 = *argp;
6373         }
6374         {
6375             NMEM * argp;
6376             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6377                 SWIG_croak("Type error in argument 2 of data1_mk_comment_n. Expected _p_NMEM");
6378             }
6379             arg2 = *argp;
6380         }
6381         if (!SvOK((SV*) ST(2))) arg3 = 0;
6382         else arg3 = (char *) SvPV(ST(2), PL_na);
6383         arg4 = (size_t) SvUV(ST(3));
6384         {
6385             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6386                 SWIG_croak("Type error in argument 5 of data1_mk_comment_n. Expected _p_data1_node");
6387             }
6388         }
6389         result = (data1_node *)data1_mk_comment_n(arg1,arg2,(char const *)arg3,arg4,arg5);
6390
6391         ST(argvi) = sv_newmortal();
6392         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6393         XSRETURN(argvi);
6394         fail:
6395         (void) _swigerr;
6396     }
6397     croak(_swigerr);
6398 }
6399
6400
6401 XS(_wrap_data1_mk_comment) {
6402     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6403     const char *_swigerr = _swigmsg;
6404     {
6405         data1_handle arg1 ;
6406         NMEM arg2 ;
6407         char *arg3 ;
6408         data1_node *arg4 ;
6409         data1_node *result;
6410         int argvi = 0;
6411         dXSARGS;
6412
6413         if ((items < 4) || (items > 4)) {
6414             SWIG_croak("Usage: data1_mk_comment(dh,mem,buf,parent);");
6415         }
6416         {
6417             data1_handle * argp;
6418             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6419                 SWIG_croak("Type error in argument 1 of data1_mk_comment. Expected _p_data1_handle");
6420             }
6421             arg1 = *argp;
6422         }
6423         {
6424             NMEM * argp;
6425             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6426                 SWIG_croak("Type error in argument 2 of data1_mk_comment. Expected _p_NMEM");
6427             }
6428             arg2 = *argp;
6429         }
6430         if (!SvOK((SV*) ST(2))) arg3 = 0;
6431         else arg3 = (char *) SvPV(ST(2), PL_na);
6432         {
6433             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
6434                 SWIG_croak("Type error in argument 4 of data1_mk_comment. Expected _p_data1_node");
6435             }
6436         }
6437         result = (data1_node *)data1_mk_comment(arg1,arg2,(char const *)arg3,arg4);
6438
6439         ST(argvi) = sv_newmortal();
6440         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6441         XSRETURN(argvi);
6442         fail:
6443         (void) _swigerr;
6444     }
6445     croak(_swigerr);
6446 }
6447
6448
6449 XS(_wrap_data1_mk_preprocess) {
6450     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6451     const char *_swigerr = _swigmsg;
6452     {
6453         data1_handle arg1 ;
6454         NMEM arg2 ;
6455         char *arg3 ;
6456         char **arg4 ;
6457         data1_node *arg5 ;
6458         data1_node *result;
6459         int argvi = 0;
6460         dXSARGS;
6461
6462         if ((items < 5) || (items > 5)) {
6463             SWIG_croak("Usage: data1_mk_preprocess(dh,nmem,target,attr,at);");
6464         }
6465         {
6466             data1_handle * argp;
6467             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6468                 SWIG_croak("Type error in argument 1 of data1_mk_preprocess. Expected _p_data1_handle");
6469             }
6470             arg1 = *argp;
6471         }
6472         {
6473             NMEM * argp;
6474             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6475                 SWIG_croak("Type error in argument 2 of data1_mk_preprocess. Expected _p_NMEM");
6476             }
6477             arg2 = *argp;
6478         }
6479         if (!SvOK((SV*) ST(2))) arg3 = 0;
6480         else arg3 = (char *) SvPV(ST(2), PL_na);
6481         {
6482             AV *tempav;
6483             I32 len;
6484             int i;
6485             SV  **tv;
6486             STRLEN na;
6487             if (!SvROK(ST(3)))
6488             croak("Argument 4 is not a reference.");
6489             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
6490             croak("Argument 4 is not an array.");
6491             tempav = (AV*)SvRV(ST(3));
6492             len = av_len(tempav);
6493             arg4 = (char **) malloc((len+2)*sizeof(char *));
6494             for (i = 0; i <= len; i++) {
6495                 tv = av_fetch(tempav, i, 0);
6496                 arg4[i] = (char *) SvPV(*tv,na);
6497             }
6498             arg4[i] = NULL;
6499         }
6500         {
6501             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6502                 SWIG_croak("Type error in argument 5 of data1_mk_preprocess. Expected _p_data1_node");
6503             }
6504         }
6505         result = (data1_node *)data1_mk_preprocess(arg1,arg2,(char const *)arg3,(char const **)arg4,arg5);
6506
6507         ST(argvi) = sv_newmortal();
6508         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6509         {
6510             free(arg4);
6511         }
6512         XSRETURN(argvi);
6513         fail:
6514         {
6515             free(arg4);
6516         }
6517         (void) _swigerr;
6518     }
6519     croak(_swigerr);
6520 }
6521
6522
6523 XS(_wrap_data1_mk_root) {
6524     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6525     const char *_swigerr = _swigmsg;
6526     {
6527         data1_handle arg1 ;
6528         NMEM arg2 ;
6529         char *arg3 ;
6530         data1_node *result;
6531         int argvi = 0;
6532         dXSARGS;
6533
6534         if ((items < 3) || (items > 3)) {
6535             SWIG_croak("Usage: data1_mk_root(dh,nmem,name);");
6536         }
6537         {
6538             data1_handle * argp;
6539             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6540                 SWIG_croak("Type error in argument 1 of data1_mk_root. Expected _p_data1_handle");
6541             }
6542             arg1 = *argp;
6543         }
6544         {
6545             NMEM * argp;
6546             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6547                 SWIG_croak("Type error in argument 2 of data1_mk_root. Expected _p_NMEM");
6548             }
6549             arg2 = *argp;
6550         }
6551         if (!SvOK((SV*) ST(2))) arg3 = 0;
6552         else arg3 = (char *) SvPV(ST(2), PL_na);
6553         result = (data1_node *)data1_mk_root(arg1,arg2,(char const *)arg3);
6554
6555         ST(argvi) = sv_newmortal();
6556         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6557         XSRETURN(argvi);
6558         fail:
6559         (void) _swigerr;
6560     }
6561     croak(_swigerr);
6562 }
6563
6564
6565 XS(_wrap_data1_set_root) {
6566     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6567     const char *_swigerr = _swigmsg;
6568     {
6569         data1_handle arg1 ;
6570         data1_node *arg2 ;
6571         NMEM arg3 ;
6572         char *arg4 ;
6573         int argvi = 0;
6574         dXSARGS;
6575
6576         if ((items < 4) || (items > 4)) {
6577             SWIG_croak("Usage: data1_set_root(dh,res,nmem,name);");
6578         }
6579         {
6580             data1_handle * argp;
6581             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6582                 SWIG_croak("Type error in argument 1 of data1_set_root. Expected _p_data1_handle");
6583             }
6584             arg1 = *argp;
6585         }
6586         {
6587             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6588                 SWIG_croak("Type error in argument 2 of data1_set_root. Expected _p_data1_node");
6589             }
6590         }
6591         {
6592             NMEM * argp;
6593             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6594                 SWIG_croak("Type error in argument 3 of data1_set_root. Expected _p_NMEM");
6595             }
6596             arg3 = *argp;
6597         }
6598         if (!SvOK((SV*) ST(3))) arg4 = 0;
6599         else arg4 = (char *) SvPV(ST(3), PL_na);
6600         data1_set_root(arg1,arg2,arg3,(char const *)arg4);
6601
6602
6603         XSRETURN(argvi);
6604         fail:
6605         (void) _swigerr;
6606     }
6607     croak(_swigerr);
6608 }
6609
6610
6611 XS(_wrap_data1_mk_tag_data_int) {
6612     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6613     const char *_swigerr = _swigmsg;
6614     {
6615         data1_handle arg1 ;
6616         data1_node *arg2 ;
6617         char *arg3 ;
6618         int arg4 ;
6619         NMEM arg5 ;
6620         data1_node *result;
6621         int argvi = 0;
6622         dXSARGS;
6623
6624         if ((items < 5) || (items > 5)) {
6625             SWIG_croak("Usage: data1_mk_tag_data_int(dh,at,tag,num,nmem);");
6626         }
6627         {
6628             data1_handle * argp;
6629             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6630                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_int. Expected _p_data1_handle");
6631             }
6632             arg1 = *argp;
6633         }
6634         {
6635             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6636                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_int. Expected _p_data1_node");
6637             }
6638         }
6639         if (!SvOK((SV*) ST(2))) arg3 = 0;
6640         else arg3 = (char *) SvPV(ST(2), PL_na);
6641         arg4 = (int) SvIV(ST(3));
6642         {
6643             NMEM * argp;
6644             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6645                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_int. Expected _p_NMEM");
6646             }
6647             arg5 = *argp;
6648         }
6649         result = (data1_node *)data1_mk_tag_data_int(arg1,arg2,(char const *)arg3,arg4,arg5);
6650
6651         ST(argvi) = sv_newmortal();
6652         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6653         XSRETURN(argvi);
6654         fail:
6655         (void) _swigerr;
6656     }
6657     croak(_swigerr);
6658 }
6659
6660
6661 XS(_wrap_data1_mk_tag_data_oid) {
6662     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6663     const char *_swigerr = _swigmsg;
6664     {
6665         data1_handle arg1 ;
6666         data1_node *arg2 ;
6667         char *arg3 ;
6668         Odr_oid *arg4 ;
6669         NMEM arg5 ;
6670         data1_node *result;
6671         int argvi = 0;
6672         dXSARGS;
6673
6674         if ((items < 5) || (items > 5)) {
6675             SWIG_croak("Usage: data1_mk_tag_data_oid(dh,at,tag,oid,nmem);");
6676         }
6677         {
6678             data1_handle * argp;
6679             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6680                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_oid. Expected _p_data1_handle");
6681             }
6682             arg1 = *argp;
6683         }
6684         {
6685             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6686                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_oid. Expected _p_data1_node");
6687             }
6688         }
6689         if (!SvOK((SV*) ST(2))) arg3 = 0;
6690         else arg3 = (char *) SvPV(ST(2), PL_na);
6691         {
6692             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_Odr_oid,0) < 0) {
6693                 SWIG_croak("Type error in argument 4 of data1_mk_tag_data_oid. Expected _p_Odr_oid");
6694             }
6695         }
6696         {
6697             NMEM * argp;
6698             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6699                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_oid. Expected _p_NMEM");
6700             }
6701             arg5 = *argp;
6702         }
6703         result = (data1_node *)data1_mk_tag_data_oid(arg1,arg2,(char const *)arg3,arg4,arg5);
6704
6705         ST(argvi) = sv_newmortal();
6706         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6707         XSRETURN(argvi);
6708         fail:
6709         (void) _swigerr;
6710     }
6711     croak(_swigerr);
6712 }
6713
6714
6715 XS(_wrap_data1_mk_tag_data_text) {
6716     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6717     const char *_swigerr = _swigmsg;
6718     {
6719         data1_handle arg1 ;
6720         data1_node *arg2 ;
6721         char *arg3 ;
6722         char *arg4 ;
6723         NMEM arg5 ;
6724         data1_node *result;
6725         int argvi = 0;
6726         dXSARGS;
6727
6728         if ((items < 5) || (items > 5)) {
6729             SWIG_croak("Usage: data1_mk_tag_data_text(dh,at,tag,str,nmem);");
6730         }
6731         {
6732             data1_handle * argp;
6733             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6734                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_text. Expected _p_data1_handle");
6735             }
6736             arg1 = *argp;
6737         }
6738         {
6739             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6740                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_text. Expected _p_data1_node");
6741             }
6742         }
6743         if (!SvOK((SV*) ST(2))) arg3 = 0;
6744         else arg3 = (char *) SvPV(ST(2), PL_na);
6745         if (!SvOK((SV*) ST(3))) arg4 = 0;
6746         else arg4 = (char *) SvPV(ST(3), PL_na);
6747         {
6748             NMEM * argp;
6749             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6750                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_text. Expected _p_NMEM");
6751             }
6752             arg5 = *argp;
6753         }
6754         result = (data1_node *)data1_mk_tag_data_text(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
6755
6756         ST(argvi) = sv_newmortal();
6757         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6758         XSRETURN(argvi);
6759         fail:
6760         (void) _swigerr;
6761     }
6762     croak(_swigerr);
6763 }
6764
6765
6766 XS(_wrap_data1_mk_tag_data_text_uni) {
6767     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6768     const char *_swigerr = _swigmsg;
6769     {
6770         data1_handle arg1 ;
6771         data1_node *arg2 ;
6772         char *arg3 ;
6773         char *arg4 ;
6774         NMEM arg5 ;
6775         data1_node *result;
6776         int argvi = 0;
6777         dXSARGS;
6778
6779         if ((items < 5) || (items > 5)) {
6780             SWIG_croak("Usage: data1_mk_tag_data_text_uni(dh,at,tag,str,nmem);");
6781         }
6782         {
6783             data1_handle * argp;
6784             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6785                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_text_uni. Expected _p_data1_handle");
6786             }
6787             arg1 = *argp;
6788         }
6789         {
6790             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6791                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_text_uni. Expected _p_data1_node");
6792             }
6793         }
6794         if (!SvOK((SV*) ST(2))) arg3 = 0;
6795         else arg3 = (char *) SvPV(ST(2), PL_na);
6796         if (!SvOK((SV*) ST(3))) arg4 = 0;
6797         else arg4 = (char *) SvPV(ST(3), PL_na);
6798         {
6799             NMEM * argp;
6800             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6801                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_text_uni. Expected _p_NMEM");
6802             }
6803             arg5 = *argp;
6804         }
6805         result = (data1_node *)data1_mk_tag_data_text_uni(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
6806
6807         ST(argvi) = sv_newmortal();
6808         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6809         XSRETURN(argvi);
6810         fail:
6811         (void) _swigerr;
6812     }
6813     croak(_swigerr);
6814 }
6815
6816
6817 XS(_wrap_data1_get_absyn) {
6818     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6819     const char *_swigerr = _swigmsg;
6820     {
6821         data1_handle arg1 ;
6822         char *arg2 ;
6823         data1_absyn *result;
6824         int argvi = 0;
6825         dXSARGS;
6826
6827         if ((items < 2) || (items > 2)) {
6828             SWIG_croak("Usage: data1_get_absyn(dh,name);");
6829         }
6830         {
6831             data1_handle * argp;
6832             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6833                 SWIG_croak("Type error in argument 1 of data1_get_absyn. Expected _p_data1_handle");
6834             }
6835             arg1 = *argp;
6836         }
6837         if (!SvOK((SV*) ST(1))) arg2 = 0;
6838         else arg2 = (char *) SvPV(ST(1), PL_na);
6839         result = (data1_absyn *)data1_get_absyn(arg1,(char const *)arg2);
6840
6841         ST(argvi) = sv_newmortal();
6842         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_absyn,0);
6843         XSRETURN(argvi);
6844         fail:
6845         (void) _swigerr;
6846     }
6847     croak(_swigerr);
6848 }
6849
6850
6851 XS(_wrap_data1_search_tag) {
6852     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6853     const char *_swigerr = _swigmsg;
6854     {
6855         data1_handle arg1 ;
6856         data1_node *arg2 ;
6857         char *arg3 ;
6858         data1_node *result;
6859         int argvi = 0;
6860         dXSARGS;
6861
6862         if ((items < 3) || (items > 3)) {
6863             SWIG_croak("Usage: data1_search_tag(dh,n,tag);");
6864         }
6865         {
6866             data1_handle * argp;
6867             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6868                 SWIG_croak("Type error in argument 1 of data1_search_tag. Expected _p_data1_handle");
6869             }
6870             arg1 = *argp;
6871         }
6872         {
6873             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6874                 SWIG_croak("Type error in argument 2 of data1_search_tag. Expected _p_data1_node");
6875             }
6876         }
6877         if (!SvOK((SV*) ST(2))) arg3 = 0;
6878         else arg3 = (char *) SvPV(ST(2), PL_na);
6879         result = (data1_node *)data1_search_tag(arg1,arg2,(char const *)arg3);
6880
6881         ST(argvi) = sv_newmortal();
6882         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6883         XSRETURN(argvi);
6884         fail:
6885         (void) _swigerr;
6886     }
6887     croak(_swigerr);
6888 }
6889
6890
6891 XS(_wrap_data1_mk_tag_uni) {
6892     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6893     const char *_swigerr = _swigmsg;
6894     {
6895         data1_handle arg1 ;
6896         NMEM arg2 ;
6897         char *arg3 ;
6898         data1_node *arg4 ;
6899         data1_node *result;
6900         int argvi = 0;
6901         dXSARGS;
6902
6903         if ((items < 4) || (items > 4)) {
6904             SWIG_croak("Usage: data1_mk_tag_uni(dh,nmem,tag,at);");
6905         }
6906         {
6907             data1_handle * argp;
6908             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6909                 SWIG_croak("Type error in argument 1 of data1_mk_tag_uni. Expected _p_data1_handle");
6910             }
6911             arg1 = *argp;
6912         }
6913         {
6914             NMEM * argp;
6915             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6916                 SWIG_croak("Type error in argument 2 of data1_mk_tag_uni. Expected _p_NMEM");
6917             }
6918             arg2 = *argp;
6919         }
6920         if (!SvOK((SV*) ST(2))) arg3 = 0;
6921         else arg3 = (char *) SvPV(ST(2), PL_na);
6922         {
6923             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
6924                 SWIG_croak("Type error in argument 4 of data1_mk_tag_uni. Expected _p_data1_node");
6925             }
6926         }
6927         result = (data1_node *)data1_mk_tag_uni(arg1,arg2,(char const *)arg3,arg4);
6928
6929         ST(argvi) = sv_newmortal();
6930         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6931         XSRETURN(argvi);
6932         fail:
6933         (void) _swigerr;
6934     }
6935     croak(_swigerr);
6936 }
6937
6938
6939 XS(_wrap_data1_get_attset) {
6940     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6941     const char *_swigerr = _swigmsg;
6942     {
6943         data1_handle arg1 ;
6944         char *arg2 ;
6945         data1_attset *result;
6946         int argvi = 0;
6947         dXSARGS;
6948
6949         if ((items < 2) || (items > 2)) {
6950             SWIG_croak("Usage: data1_get_attset(dh,name);");
6951         }
6952         {
6953             data1_handle * argp;
6954             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6955                 SWIG_croak("Type error in argument 1 of data1_get_attset. Expected _p_data1_handle");
6956             }
6957             arg1 = *argp;
6958         }
6959         if (!SvOK((SV*) ST(1))) arg2 = 0;
6960         else arg2 = (char *) SvPV(ST(1), PL_na);
6961         result = (data1_attset *)data1_get_attset(arg1,(char const *)arg2);
6962
6963         ST(argvi) = sv_newmortal();
6964         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_attset,0);
6965         XSRETURN(argvi);
6966         fail:
6967         (void) _swigerr;
6968     }
6969     croak(_swigerr);
6970 }
6971
6972
6973 XS(_wrap_data1_read_maptab) {
6974     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6975     const char *_swigerr = _swigmsg;
6976     {
6977         data1_handle arg1 ;
6978         char *arg2 ;
6979         data1_maptab *result;
6980         int argvi = 0;
6981         dXSARGS;
6982
6983         if ((items < 2) || (items > 2)) {
6984             SWIG_croak("Usage: data1_read_maptab(dh,file);");
6985         }
6986         {
6987             data1_handle * argp;
6988             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6989                 SWIG_croak("Type error in argument 1 of data1_read_maptab. Expected _p_data1_handle");
6990             }
6991             arg1 = *argp;
6992         }
6993         if (!SvOK((SV*) ST(1))) arg2 = 0;
6994         else arg2 = (char *) SvPV(ST(1), PL_na);
6995         result = (data1_maptab *)data1_read_maptab(arg1,(char const *)arg2);
6996
6997         ST(argvi) = sv_newmortal();
6998         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_maptab,0);
6999         XSRETURN(argvi);
7000         fail:
7001         (void) _swigerr;
7002     }
7003     croak(_swigerr);
7004 }
7005
7006
7007 XS(_wrap_data1_map_record) {
7008     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7009     const char *_swigerr = _swigmsg;
7010     {
7011         data1_handle arg1 ;
7012         data1_node *arg2 ;
7013         data1_maptab *arg3 ;
7014         NMEM arg4 ;
7015         data1_node *result;
7016         int argvi = 0;
7017         dXSARGS;
7018
7019         if ((items < 4) || (items > 4)) {
7020             SWIG_croak("Usage: data1_map_record(dh,n,map,m);");
7021         }
7022         {
7023             data1_handle * argp;
7024             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7025                 SWIG_croak("Type error in argument 1 of data1_map_record. Expected _p_data1_handle");
7026             }
7027             arg1 = *argp;
7028         }
7029         {
7030             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7031                 SWIG_croak("Type error in argument 2 of data1_map_record. Expected _p_data1_node");
7032             }
7033         }
7034         {
7035             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_maptab,0) < 0) {
7036                 SWIG_croak("Type error in argument 3 of data1_map_record. Expected _p_data1_maptab");
7037             }
7038         }
7039         {
7040             NMEM * argp;
7041             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
7042                 SWIG_croak("Type error in argument 4 of data1_map_record. Expected _p_NMEM");
7043             }
7044             arg4 = *argp;
7045         }
7046         result = (data1_node *)data1_map_record(arg1,arg2,arg3,arg4);
7047
7048         ST(argvi) = sv_newmortal();
7049         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
7050         XSRETURN(argvi);
7051         fail:
7052         (void) _swigerr;
7053     }
7054     croak(_swigerr);
7055 }
7056
7057
7058 XS(_wrap_data1_read_marctab) {
7059     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7060     const char *_swigerr = _swigmsg;
7061     {
7062         data1_handle arg1 ;
7063         char *arg2 ;
7064         data1_marctab *result;
7065         int argvi = 0;
7066         dXSARGS;
7067
7068         if ((items < 2) || (items > 2)) {
7069             SWIG_croak("Usage: data1_read_marctab(dh,file);");
7070         }
7071         {
7072             data1_handle * argp;
7073             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7074                 SWIG_croak("Type error in argument 1 of data1_read_marctab. Expected _p_data1_handle");
7075             }
7076             arg1 = *argp;
7077         }
7078         if (!SvOK((SV*) ST(1))) arg2 = 0;
7079         else arg2 = (char *) SvPV(ST(1), PL_na);
7080         result = (data1_marctab *)data1_read_marctab(arg1,(char const *)arg2);
7081
7082         ST(argvi) = sv_newmortal();
7083         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_marctab,0);
7084         XSRETURN(argvi);
7085         fail:
7086         (void) _swigerr;
7087     }
7088     croak(_swigerr);
7089 }
7090
7091
7092 XS(_wrap_data1_nodetomarc) {
7093     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7094     const char *_swigerr = _swigmsg;
7095     {
7096         data1_handle arg1 ;
7097         data1_marctab *arg2 ;
7098         data1_node *arg3 ;
7099         int arg4 ;
7100         int *arg5 ;
7101         char *result;
7102         int argvi = 0;
7103         dXSARGS;
7104
7105         if ((items < 5) || (items > 5)) {
7106             SWIG_croak("Usage: data1_nodetomarc(dh,p,n,selected,len);");
7107         }
7108         {
7109             data1_handle * argp;
7110             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7111                 SWIG_croak("Type error in argument 1 of data1_nodetomarc. Expected _p_data1_handle");
7112             }
7113             arg1 = *argp;
7114         }
7115         {
7116             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_marctab,0) < 0) {
7117                 SWIG_croak("Type error in argument 2 of data1_nodetomarc. Expected _p_data1_marctab");
7118             }
7119         }
7120         {
7121             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_node,0) < 0) {
7122                 SWIG_croak("Type error in argument 3 of data1_nodetomarc. Expected _p_data1_node");
7123             }
7124         }
7125         arg4 = (int) SvIV(ST(3));
7126         {
7127             int i;
7128             if (!SvIOK(ST(4)))
7129             croak("Argument 5 is not an integer.");
7130             i = SvIV(ST(4));
7131             arg5 = &i;
7132         }
7133         result = (char *)data1_nodetomarc(arg1,arg2,arg3,arg4,arg5);
7134
7135         ST(argvi) = sv_newmortal();
7136         if (result) {
7137             sv_setpv((SV*)ST(argvi++), (char *) result);
7138         }else {
7139             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7140         }
7141         XSRETURN(argvi);
7142         fail:
7143         (void) _swigerr;
7144     }
7145     croak(_swigerr);
7146 }
7147
7148
7149 XS(_wrap_data1_nodetoidsgml) {
7150     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7151     const char *_swigerr = _swigmsg;
7152     {
7153         data1_handle arg1 ;
7154         data1_node *arg2 ;
7155         int arg3 ;
7156         int *arg4 ;
7157         char *result;
7158         int argvi = 0;
7159         dXSARGS;
7160
7161         if ((items < 4) || (items > 4)) {
7162             SWIG_croak("Usage: data1_nodetoidsgml(dh,n,select,len);");
7163         }
7164         {
7165             data1_handle * argp;
7166             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7167                 SWIG_croak("Type error in argument 1 of data1_nodetoidsgml. Expected _p_data1_handle");
7168             }
7169             arg1 = *argp;
7170         }
7171         {
7172             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7173                 SWIG_croak("Type error in argument 2 of data1_nodetoidsgml. Expected _p_data1_node");
7174             }
7175         }
7176         arg3 = (int) SvIV(ST(2));
7177         {
7178             int i;
7179             if (!SvIOK(ST(3)))
7180             croak("Argument 4 is not an integer.");
7181             i = SvIV(ST(3));
7182             arg4 = &i;
7183         }
7184         result = (char *)data1_nodetoidsgml(arg1,arg2,arg3,arg4);
7185
7186         ST(argvi) = sv_newmortal();
7187         if (result) {
7188             sv_setpv((SV*)ST(argvi++), (char *) result);
7189         }else {
7190             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7191         }
7192         XSRETURN(argvi);
7193         fail:
7194         (void) _swigerr;
7195     }
7196     croak(_swigerr);
7197 }
7198
7199
7200 XS(_wrap_data1_nodetoexplain) {
7201     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7202     const char *_swigerr = _swigmsg;
7203     {
7204         data1_handle arg1 ;
7205         data1_node *arg2 ;
7206         int arg3 ;
7207         ODR arg4 ;
7208         Z_ExplainRecord *result;
7209         int argvi = 0;
7210         dXSARGS;
7211
7212         if ((items < 4) || (items > 4)) {
7213             SWIG_croak("Usage: data1_nodetoexplain(dh,n,select,o);");
7214         }
7215         {
7216             data1_handle * argp;
7217             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7218                 SWIG_croak("Type error in argument 1 of data1_nodetoexplain. Expected _p_data1_handle");
7219             }
7220             arg1 = *argp;
7221         }
7222         {
7223             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7224                 SWIG_croak("Type error in argument 2 of data1_nodetoexplain. Expected _p_data1_node");
7225             }
7226         }
7227         arg3 = (int) SvIV(ST(2));
7228         {
7229             ODR * argp;
7230             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
7231                 SWIG_croak("Type error in argument 4 of data1_nodetoexplain. Expected _p_ODR");
7232             }
7233             arg4 = *argp;
7234         }
7235         result = (Z_ExplainRecord *)data1_nodetoexplain(arg1,arg2,arg3,arg4);
7236
7237         ST(argvi) = sv_newmortal();
7238         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_ExplainRecord,0);
7239         XSRETURN(argvi);
7240         fail:
7241         (void) _swigerr;
7242     }
7243     croak(_swigerr);
7244 }
7245
7246
7247 XS(_wrap_data1_nodetosummary) {
7248     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7249     const char *_swigerr = _swigmsg;
7250     {
7251         data1_handle arg1 ;
7252         data1_node *arg2 ;
7253         int arg3 ;
7254         ODR arg4 ;
7255         Z_BriefBib *result;
7256         int argvi = 0;
7257         dXSARGS;
7258
7259         if ((items < 4) || (items > 4)) {
7260             SWIG_croak("Usage: data1_nodetosummary(dh,n,select,o);");
7261         }
7262         {
7263             data1_handle * argp;
7264             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7265                 SWIG_croak("Type error in argument 1 of data1_nodetosummary. Expected _p_data1_handle");
7266             }
7267             arg1 = *argp;
7268         }
7269         {
7270             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7271                 SWIG_croak("Type error in argument 2 of data1_nodetosummary. Expected _p_data1_node");
7272             }
7273         }
7274         arg3 = (int) SvIV(ST(2));
7275         {
7276             ODR * argp;
7277             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
7278                 SWIG_croak("Type error in argument 4 of data1_nodetosummary. Expected _p_ODR");
7279             }
7280             arg4 = *argp;
7281         }
7282         result = (Z_BriefBib *)data1_nodetosummary(arg1,arg2,arg3,arg4);
7283
7284         ST(argvi) = sv_newmortal();
7285         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_BriefBib,0);
7286         XSRETURN(argvi);
7287         fail:
7288         (void) _swigerr;
7289     }
7290     croak(_swigerr);
7291 }
7292
7293
7294 XS(_wrap_data1_nodetosoif) {
7295     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7296     const char *_swigerr = _swigmsg;
7297     {
7298         data1_handle arg1 ;
7299         data1_node *arg2 ;
7300         int arg3 ;
7301         int *arg4 ;
7302         char *result;
7303         int argvi = 0;
7304         dXSARGS;
7305
7306         if ((items < 4) || (items > 4)) {
7307             SWIG_croak("Usage: data1_nodetosoif(dh,n,select,len);");
7308         }
7309         {
7310             data1_handle * argp;
7311             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7312                 SWIG_croak("Type error in argument 1 of data1_nodetosoif. Expected _p_data1_handle");
7313             }
7314             arg1 = *argp;
7315         }
7316         {
7317             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7318                 SWIG_croak("Type error in argument 2 of data1_nodetosoif. Expected _p_data1_node");
7319             }
7320         }
7321         arg3 = (int) SvIV(ST(2));
7322         {
7323             int i;
7324             if (!SvIOK(ST(3)))
7325             croak("Argument 4 is not an integer.");
7326             i = SvIV(ST(3));
7327             arg4 = &i;
7328         }
7329         result = (char *)data1_nodetosoif(arg1,arg2,arg3,arg4);
7330
7331         ST(argvi) = sv_newmortal();
7332         if (result) {
7333             sv_setpv((SV*)ST(argvi++), (char *) result);
7334         }else {
7335             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7336         }
7337         XSRETURN(argvi);
7338         fail:
7339         (void) _swigerr;
7340     }
7341     croak(_swigerr);
7342 }
7343
7344
7345 XS(_wrap_data1_get_wrbuf) {
7346     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7347     const char *_swigerr = _swigmsg;
7348     {
7349         data1_handle arg1 ;
7350         WRBUF result;
7351         int argvi = 0;
7352         dXSARGS;
7353
7354         if ((items < 1) || (items > 1)) {
7355             SWIG_croak("Usage: data1_get_wrbuf(dp);");
7356         }
7357         {
7358             data1_handle * argp;
7359             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7360                 SWIG_croak("Type error in argument 1 of data1_get_wrbuf. Expected _p_data1_handle");
7361             }
7362             arg1 = *argp;
7363         }
7364         result = data1_get_wrbuf(arg1);
7365
7366         {
7367             WRBUF * resultobj = (WRBUF *) malloc(sizeof(WRBUF));
7368             memmove(resultobj, &result, sizeof(WRBUF));
7369             ST(argvi) = sv_newmortal();
7370             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_WRBUF,0);
7371         }
7372         XSRETURN(argvi);
7373         fail:
7374         (void) _swigerr;
7375     }
7376     croak(_swigerr);
7377 }
7378
7379
7380 XS(_wrap_data1_get_read_buf) {
7381     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7382     const char *_swigerr = _swigmsg;
7383     {
7384         data1_handle arg1 ;
7385         int **arg2 ;
7386         char **result;
7387         int argvi = 0;
7388         dXSARGS;
7389
7390         if ((items < 2) || (items > 2)) {
7391             SWIG_croak("Usage: data1_get_read_buf(dp,lenp);");
7392         }
7393         {
7394             data1_handle * argp;
7395             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7396                 SWIG_croak("Type error in argument 1 of data1_get_read_buf. Expected _p_data1_handle");
7397             }
7398             arg1 = *argp;
7399         }
7400         {
7401             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_p_int,0) < 0) {
7402                 SWIG_croak("Type error in argument 2 of data1_get_read_buf. Expected _p_p_int");
7403             }
7404         }
7405         result = (char **)data1_get_read_buf(arg1,arg2);
7406
7407         {
7408             AV *myav;
7409             SV **svs;
7410             int i = 0,len = 0;
7411             /* Figure out how many elements we have */
7412             while (result[len])
7413             len++;
7414             svs = (SV **) malloc(len*sizeof(SV *));
7415             for (i = 0; i < len ; i++) {
7416                 svs[i] = sv_newmortal();
7417                 sv_setpv((SV*)svs[i],result[i]);
7418             };
7419             myav =  av_make(len,svs);
7420             free(svs);
7421             ST(argvi) = newRV((SV*)myav);
7422             sv_2mortal(ST(argvi));
7423             argvi++;
7424         }
7425         XSRETURN(argvi);
7426         fail:
7427         (void) _swigerr;
7428     }
7429     croak(_swigerr);
7430 }
7431
7432
7433 XS(_wrap_data1_get_map_buf) {
7434     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7435     const char *_swigerr = _swigmsg;
7436     {
7437         data1_handle arg1 ;
7438         int **arg2 ;
7439         char **result;
7440         int argvi = 0;
7441         dXSARGS;
7442
7443         if ((items < 2) || (items > 2)) {
7444             SWIG_croak("Usage: data1_get_map_buf(dp,lenp);");
7445         }
7446         {
7447             data1_handle * argp;
7448             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7449                 SWIG_croak("Type error in argument 1 of data1_get_map_buf. Expected _p_data1_handle");
7450             }
7451             arg1 = *argp;
7452         }
7453         {
7454             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_p_int,0) < 0) {
7455                 SWIG_croak("Type error in argument 2 of data1_get_map_buf. Expected _p_p_int");
7456             }
7457         }
7458         result = (char **)data1_get_map_buf(arg1,arg2);
7459
7460         {
7461             AV *myav;
7462             SV **svs;
7463             int i = 0,len = 0;
7464             /* Figure out how many elements we have */
7465             while (result[len])
7466             len++;
7467             svs = (SV **) malloc(len*sizeof(SV *));
7468             for (i = 0; i < len ; i++) {
7469                 svs[i] = sv_newmortal();
7470                 sv_setpv((SV*)svs[i],result[i]);
7471             };
7472             myav =  av_make(len,svs);
7473             free(svs);
7474             ST(argvi) = newRV((SV*)myav);
7475             sv_2mortal(ST(argvi));
7476             argvi++;
7477         }
7478         XSRETURN(argvi);
7479         fail:
7480         (void) _swigerr;
7481     }
7482     croak(_swigerr);
7483 }
7484
7485
7486 XS(_wrap_data1_absyn_cache_get) {
7487     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7488     const char *_swigerr = _swigmsg;
7489     {
7490         data1_handle arg1 ;
7491         data1_absyn_cache *result;
7492         int argvi = 0;
7493         dXSARGS;
7494
7495         if ((items < 1) || (items > 1)) {
7496             SWIG_croak("Usage: data1_absyn_cache_get(dh);");
7497         }
7498         {
7499             data1_handle * argp;
7500             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7501                 SWIG_croak("Type error in argument 1 of data1_absyn_cache_get. Expected _p_data1_handle");
7502             }
7503             arg1 = *argp;
7504         }
7505         result = (data1_absyn_cache *)data1_absyn_cache_get(arg1);
7506
7507         ST(argvi) = sv_newmortal();
7508         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_absyn_cache,0);
7509         XSRETURN(argvi);
7510         fail:
7511         (void) _swigerr;
7512     }
7513     croak(_swigerr);
7514 }
7515
7516
7517 XS(_wrap_data1_attset_cache_get) {
7518     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7519     const char *_swigerr = _swigmsg;
7520     {
7521         data1_handle arg1 ;
7522         data1_attset_cache *result;
7523         int argvi = 0;
7524         dXSARGS;
7525
7526         if ((items < 1) || (items > 1)) {
7527             SWIG_croak("Usage: data1_attset_cache_get(dh);");
7528         }
7529         {
7530             data1_handle * argp;
7531             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7532                 SWIG_croak("Type error in argument 1 of data1_attset_cache_get. Expected _p_data1_handle");
7533             }
7534             arg1 = *argp;
7535         }
7536         result = (data1_attset_cache *)data1_attset_cache_get(arg1);
7537
7538         ST(argvi) = sv_newmortal();
7539         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_attset_cache,0);
7540         XSRETURN(argvi);
7541         fail:
7542         (void) _swigerr;
7543     }
7544     croak(_swigerr);
7545 }
7546
7547
7548 XS(_wrap_data1_nmem_get) {
7549     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7550     const char *_swigerr = _swigmsg;
7551     {
7552         data1_handle arg1 ;
7553         NMEM result;
7554         int argvi = 0;
7555         dXSARGS;
7556
7557         if ((items < 1) || (items > 1)) {
7558             SWIG_croak("Usage: data1_nmem_get(dh);");
7559         }
7560         {
7561             data1_handle * argp;
7562             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7563                 SWIG_croak("Type error in argument 1 of data1_nmem_get. Expected _p_data1_handle");
7564             }
7565             arg1 = *argp;
7566         }
7567         result = data1_nmem_get(arg1);
7568
7569         {
7570             NMEM * resultobj = (NMEM *) malloc(sizeof(NMEM));
7571             memmove(resultobj, &result, sizeof(NMEM));
7572             ST(argvi) = sv_newmortal();
7573             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_NMEM,0);
7574         }
7575         XSRETURN(argvi);
7576         fail:
7577         (void) _swigerr;
7578     }
7579     croak(_swigerr);
7580 }
7581
7582
7583 XS(_wrap_data1_pr_tree) {
7584     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7585     const char *_swigerr = _swigmsg;
7586     {
7587         data1_handle arg1 ;
7588         data1_node *arg2 ;
7589         FILE *arg3 ;
7590         int argvi = 0;
7591         dXSARGS;
7592
7593         if ((items < 3) || (items > 3)) {
7594             SWIG_croak("Usage: data1_pr_tree(dh,n,out);");
7595         }
7596         {
7597             data1_handle * argp;
7598             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7599                 SWIG_croak("Type error in argument 1 of data1_pr_tree. Expected _p_data1_handle");
7600             }
7601             arg1 = *argp;
7602         }
7603         {
7604             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7605                 SWIG_croak("Type error in argument 2 of data1_pr_tree. Expected _p_data1_node");
7606             }
7607         }
7608         {
7609             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_FILE,0) < 0) {
7610                 SWIG_croak("Type error in argument 3 of data1_pr_tree. Expected _p_FILE");
7611             }
7612         }
7613         data1_pr_tree(arg1,arg2,arg3);
7614
7615
7616         XSRETURN(argvi);
7617         fail:
7618         (void) _swigerr;
7619     }
7620     croak(_swigerr);
7621 }
7622
7623
7624 XS(_wrap_data1_print_tree) {
7625     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7626     const char *_swigerr = _swigmsg;
7627     {
7628         data1_handle arg1 ;
7629         data1_node *arg2 ;
7630         int argvi = 0;
7631         dXSARGS;
7632
7633         if ((items < 2) || (items > 2)) {
7634             SWIG_croak("Usage: data1_print_tree(dh,n);");
7635         }
7636         {
7637             data1_handle * argp;
7638             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7639                 SWIG_croak("Type error in argument 1 of data1_print_tree. Expected _p_data1_handle");
7640             }
7641             arg1 = *argp;
7642         }
7643         {
7644             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7645                 SWIG_croak("Type error in argument 2 of data1_print_tree. Expected _p_data1_node");
7646             }
7647         }
7648         data1_print_tree(arg1,arg2);
7649
7650
7651         XSRETURN(argvi);
7652         fail:
7653         (void) _swigerr;
7654     }
7655     croak(_swigerr);
7656 }
7657
7658
7659 XS(_wrap_data1_insert_string) {
7660     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7661     const char *_swigerr = _swigmsg;
7662     {
7663         data1_handle arg1 ;
7664         data1_node *arg2 ;
7665         NMEM arg3 ;
7666         char *arg4 ;
7667         char *result;
7668         int argvi = 0;
7669         dXSARGS;
7670
7671         if ((items < 4) || (items > 4)) {
7672             SWIG_croak("Usage: data1_insert_string(dh,res,m,str);");
7673         }
7674         {
7675             data1_handle * argp;
7676             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7677                 SWIG_croak("Type error in argument 1 of data1_insert_string. Expected _p_data1_handle");
7678             }
7679             arg1 = *argp;
7680         }
7681         {
7682             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7683                 SWIG_croak("Type error in argument 2 of data1_insert_string. Expected _p_data1_node");
7684             }
7685         }
7686         {
7687             NMEM * argp;
7688             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
7689                 SWIG_croak("Type error in argument 3 of data1_insert_string. Expected _p_NMEM");
7690             }
7691             arg3 = *argp;
7692         }
7693         if (!SvOK((SV*) ST(3))) arg4 = 0;
7694         else arg4 = (char *) SvPV(ST(3), PL_na);
7695         result = (char *)data1_insert_string(arg1,arg2,arg3,(char const *)arg4);
7696
7697         ST(argvi) = sv_newmortal();
7698         if (result) {
7699             sv_setpv((SV*)ST(argvi++), (char *) result);
7700         }else {
7701             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7702         }
7703         XSRETURN(argvi);
7704         fail:
7705         (void) _swigerr;
7706     }
7707     croak(_swigerr);
7708 }
7709
7710
7711 XS(_wrap_data1_insert_string_n) {
7712     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7713     const char *_swigerr = _swigmsg;
7714     {
7715         data1_handle arg1 ;
7716         data1_node *arg2 ;
7717         NMEM arg3 ;
7718         char *arg4 ;
7719         size_t arg5 ;
7720         char *result;
7721         int argvi = 0;
7722         dXSARGS;
7723
7724         if ((items < 5) || (items > 5)) {
7725             SWIG_croak("Usage: data1_insert_string_n(dh,res,m,str,len);");
7726         }
7727         {
7728             data1_handle * argp;
7729             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7730                 SWIG_croak("Type error in argument 1 of data1_insert_string_n. Expected _p_data1_handle");
7731             }
7732             arg1 = *argp;
7733         }
7734         {
7735             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7736                 SWIG_croak("Type error in argument 2 of data1_insert_string_n. Expected _p_data1_node");
7737             }
7738         }
7739         {
7740             NMEM * argp;
7741             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
7742                 SWIG_croak("Type error in argument 3 of data1_insert_string_n. Expected _p_NMEM");
7743             }
7744             arg3 = *argp;
7745         }
7746         if (!SvOK((SV*) ST(3))) arg4 = 0;
7747         else arg4 = (char *) SvPV(ST(3), PL_na);
7748         arg5 = (size_t) SvUV(ST(4));
7749         result = (char *)data1_insert_string_n(arg1,arg2,arg3,(char const *)arg4,arg5);
7750
7751         ST(argvi) = sv_newmortal();
7752         if (result) {
7753             sv_setpv((SV*)ST(argvi++), (char *) result);
7754         }else {
7755             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7756         }
7757         XSRETURN(argvi);
7758         fail:
7759         (void) _swigerr;
7760     }
7761     croak(_swigerr);
7762 }
7763
7764
7765 XS(_wrap_data1_read_sgml) {
7766     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7767     const char *_swigerr = _swigmsg;
7768     {
7769         data1_handle arg1 ;
7770         NMEM arg2 ;
7771         char *arg3 ;
7772         data1_node *result;
7773         int argvi = 0;
7774         dXSARGS;
7775
7776         if ((items < 3) || (items > 3)) {
7777             SWIG_croak("Usage: data1_read_sgml(dh,m,buf);");
7778         }
7779         {
7780             data1_handle * argp;
7781             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7782                 SWIG_croak("Type error in argument 1 of data1_read_sgml. Expected _p_data1_handle");
7783             }
7784             arg1 = *argp;
7785         }
7786         {
7787             NMEM * argp;
7788             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
7789                 SWIG_croak("Type error in argument 2 of data1_read_sgml. Expected _p_NMEM");
7790             }
7791             arg2 = *argp;
7792         }
7793         if (!SvOK((SV*) ST(2))) arg3 = 0;
7794         else arg3 = (char *) SvPV(ST(2), PL_na);
7795         result = (data1_node *)data1_read_sgml(arg1,arg2,(char const *)arg3);
7796
7797         ST(argvi) = sv_newmortal();
7798         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
7799         XSRETURN(argvi);
7800         fail:
7801         (void) _swigerr;
7802     }
7803     croak(_swigerr);
7804 }
7805
7806
7807 XS(_wrap_data1_absyn_trav) {
7808     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7809     const char *_swigerr = _swigmsg;
7810     {
7811         data1_handle arg1 ;
7812         void *arg2 ;
7813         void (*arg3)(data1_handle,void *,data1_absyn *) ;
7814         int argvi = 0;
7815         dXSARGS;
7816
7817         if ((items < 3) || (items > 3)) {
7818             SWIG_croak("Usage: data1_absyn_trav(dh,handle,fh);");
7819         }
7820         {
7821             data1_handle * argp;
7822             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7823                 SWIG_croak("Type error in argument 1 of data1_absyn_trav. Expected _p_data1_handle");
7824             }
7825             arg1 = *argp;
7826         }
7827         {
7828             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, 0,0) < 0) {
7829                 SWIG_croak("Type error in argument 2 of data1_absyn_trav. Expected _p_void");
7830             }
7831         }
7832         {
7833             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_f_data1_handle_p_void_p_data1_absyn__void,0) < 0) {
7834                 SWIG_croak("Type error in argument 3 of data1_absyn_trav. Expected _p_f_data1_handle_p_void_p_data1_absyn__void");
7835             }
7836         }
7837         data1_absyn_trav(arg1,arg2,arg3);
7838
7839
7840         XSRETURN(argvi);
7841         fail:
7842         (void) _swigerr;
7843     }
7844     croak(_swigerr);
7845 }
7846
7847
7848 XS(_wrap_data1_attset_search_id) {
7849     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7850     const char *_swigerr = _swigmsg;
7851     {
7852         data1_handle arg1 ;
7853         int arg2 ;
7854         data1_attset *result;
7855         int argvi = 0;
7856         dXSARGS;
7857
7858         if ((items < 2) || (items > 2)) {
7859             SWIG_croak("Usage: data1_attset_search_id(dh,id);");
7860         }
7861         {
7862             data1_handle * argp;
7863             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7864                 SWIG_croak("Type error in argument 1 of data1_attset_search_id. Expected _p_data1_handle");
7865             }
7866             arg1 = *argp;
7867         }
7868         arg2 = (int) SvIV(ST(1));
7869         result = (data1_attset *)data1_attset_search_id(arg1,arg2);
7870
7871         ST(argvi) = sv_newmortal();
7872         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_attset,0);
7873         XSRETURN(argvi);
7874         fail:
7875         (void) _swigerr;
7876     }
7877     croak(_swigerr);
7878 }
7879
7880
7881 XS(_wrap_data1_getNodeValue) {
7882     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7883     const char *_swigerr = _swigmsg;
7884     {
7885         data1_node *arg1 ;
7886         char *arg2 ;
7887         char *result;
7888         int argvi = 0;
7889         dXSARGS;
7890
7891         if ((items < 2) || (items > 2)) {
7892             SWIG_croak("Usage: data1_getNodeValue(node,pTagPath);");
7893         }
7894         {
7895             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_data1_node,0) < 0) {
7896                 SWIG_croak("Type error in argument 1 of data1_getNodeValue. Expected _p_data1_node");
7897             }
7898         }
7899         if (!SvOK((SV*) ST(1))) arg2 = 0;
7900         else arg2 = (char *) SvPV(ST(1), PL_na);
7901         result = (char *)data1_getNodeValue(arg1,arg2);
7902
7903         ST(argvi) = sv_newmortal();
7904         if (result) {
7905             sv_setpv((SV*)ST(argvi++), (char *) result);
7906         }else {
7907             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7908         }
7909         XSRETURN(argvi);
7910         fail:
7911         (void) _swigerr;
7912     }
7913     croak(_swigerr);
7914 }
7915
7916
7917 XS(_wrap_data1_LookupNode) {
7918     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7919     const char *_swigerr = _swigmsg;
7920     {
7921         data1_node *arg1 ;
7922         char *arg2 ;
7923         data1_node *result;
7924         int argvi = 0;
7925         dXSARGS;
7926
7927         if ((items < 2) || (items > 2)) {
7928             SWIG_croak("Usage: data1_LookupNode(node,pTagPath);");
7929         }
7930         {
7931             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_data1_node,0) < 0) {
7932                 SWIG_croak("Type error in argument 1 of data1_LookupNode. Expected _p_data1_node");
7933             }
7934         }
7935         if (!SvOK((SV*) ST(1))) arg2 = 0;
7936         else arg2 = (char *) SvPV(ST(1), PL_na);
7937         result = (data1_node *)data1_LookupNode(arg1,arg2);
7938
7939         ST(argvi) = sv_newmortal();
7940         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
7941         XSRETURN(argvi);
7942         fail:
7943         (void) _swigerr;
7944     }
7945     croak(_swigerr);
7946 }
7947
7948
7949 XS(_wrap_data1_CountOccurences) {
7950     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7951     const char *_swigerr = _swigmsg;
7952     {
7953         data1_node *arg1 ;
7954         char *arg2 ;
7955         int result;
7956         int argvi = 0;
7957         dXSARGS;
7958
7959         if ((items < 2) || (items > 2)) {
7960             SWIG_croak("Usage: data1_CountOccurences(node,pTagPath);");
7961         }
7962         {
7963             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_data1_node,0) < 0) {
7964                 SWIG_croak("Type error in argument 1 of data1_CountOccurences. Expected _p_data1_node");
7965             }
7966         }
7967         if (!SvOK((SV*) ST(1))) arg2 = 0;
7968         else arg2 = (char *) SvPV(ST(1), PL_na);
7969         result = (int)data1_CountOccurences(arg1,arg2);
7970
7971         ST(argvi) = sv_newmortal();
7972         sv_setiv(ST(argvi++), (IV) result);
7973         XSRETURN(argvi);
7974         fail:
7975         (void) _swigerr;
7976     }
7977     croak(_swigerr);
7978 }
7979
7980
7981 XS(_wrap_data1_path_fopen) {
7982     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7983     const char *_swigerr = _swigmsg;
7984     {
7985         data1_handle arg1 ;
7986         char *arg2 ;
7987         char *arg3 ;
7988         FILE *result;
7989         int argvi = 0;
7990         dXSARGS;
7991
7992         if ((items < 3) || (items > 3)) {
7993             SWIG_croak("Usage: data1_path_fopen(dh,file,mode);");
7994         }
7995         {
7996             data1_handle * argp;
7997             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7998                 SWIG_croak("Type error in argument 1 of data1_path_fopen. Expected _p_data1_handle");
7999             }
8000             arg1 = *argp;
8001         }
8002         if (!SvOK((SV*) ST(1))) arg2 = 0;
8003         else arg2 = (char *) SvPV(ST(1), PL_na);
8004         if (!SvOK((SV*) ST(2))) arg3 = 0;
8005         else arg3 = (char *) SvPV(ST(2), PL_na);
8006         result = (FILE *)data1_path_fopen(arg1,(char const *)arg2,(char const *)arg3);
8007
8008         ST(argvi) = sv_newmortal();
8009         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_FILE,0);
8010         XSRETURN(argvi);
8011         fail:
8012         (void) _swigerr;
8013     }
8014     croak(_swigerr);
8015 }
8016
8017
8018 XS(_wrap_data1_set_tabpath) {
8019     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8020     const char *_swigerr = _swigmsg;
8021     {
8022         data1_handle arg1 ;
8023         char *arg2 ;
8024         int argvi = 0;
8025         dXSARGS;
8026
8027         if ((items < 2) || (items > 2)) {
8028             SWIG_croak("Usage: data1_set_tabpath(dh,path);");
8029         }
8030         {
8031             data1_handle * argp;
8032             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
8033                 SWIG_croak("Type error in argument 1 of data1_set_tabpath. Expected _p_data1_handle");
8034             }
8035             arg1 = *argp;
8036         }
8037         if (!SvOK((SV*) ST(1))) arg2 = 0;
8038         else arg2 = (char *) SvPV(ST(1), PL_na);
8039         data1_set_tabpath(arg1,(char const *)arg2);
8040
8041
8042         XSRETURN(argvi);
8043         fail:
8044         (void) _swigerr;
8045     }
8046     croak(_swigerr);
8047 }
8048
8049
8050 XS(_wrap_data1_set_tabroot) {
8051     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8052     const char *_swigerr = _swigmsg;
8053     {
8054         data1_handle arg1 ;
8055         char *arg2 ;
8056         int argvi = 0;
8057         dXSARGS;
8058
8059         if ((items < 2) || (items > 2)) {
8060             SWIG_croak("Usage: data1_set_tabroot(dp,p);");
8061         }
8062         {
8063             data1_handle * argp;
8064             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
8065                 SWIG_croak("Type error in argument 1 of data1_set_tabroot. Expected _p_data1_handle");
8066             }
8067             arg1 = *argp;
8068         }
8069         if (!SvOK((SV*) ST(1))) arg2 = 0;
8070         else arg2 = (char *) SvPV(ST(1), PL_na);
8071         data1_set_tabroot(arg1,(char const *)arg2);
8072
8073
8074         XSRETURN(argvi);
8075         fail:
8076         (void) _swigerr;
8077     }
8078     croak(_swigerr);
8079 }
8080
8081
8082 XS(_wrap_data1_get_tabpath) {
8083     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8084     const char *_swigerr = _swigmsg;
8085     {
8086         data1_handle arg1 ;
8087         char *result;
8088         int argvi = 0;
8089         dXSARGS;
8090
8091         if ((items < 1) || (items > 1)) {
8092             SWIG_croak("Usage: data1_get_tabpath(dh);");
8093         }
8094         {
8095             data1_handle * argp;
8096             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
8097                 SWIG_croak("Type error in argument 1 of data1_get_tabpath. Expected _p_data1_handle");
8098             }
8099             arg1 = *argp;
8100         }
8101         result = (char *)data1_get_tabpath(arg1);
8102
8103         ST(argvi) = sv_newmortal();
8104         if (result) {
8105             sv_setpv((SV*)ST(argvi++), (char *) result);
8106         }else {
8107             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
8108         }
8109         XSRETURN(argvi);
8110         fail:
8111         (void) _swigerr;
8112     }
8113     croak(_swigerr);
8114 }
8115
8116
8117 XS(_wrap_data1_get_tabroot) {
8118     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8119     const char *_swigerr = _swigmsg;
8120     {
8121         data1_handle arg1 ;
8122         char *result;
8123         int argvi = 0;
8124         dXSARGS;
8125
8126         if ((items < 1) || (items > 1)) {
8127             SWIG_croak("Usage: data1_get_tabroot(dh);");
8128         }
8129         {
8130             data1_handle * argp;
8131             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
8132                 SWIG_croak("Type error in argument 1 of data1_get_tabroot. Expected _p_data1_handle");
8133             }
8134             arg1 = *argp;
8135         }
8136         result = (char *)data1_get_tabroot(arg1);
8137
8138         ST(argvi) = sv_newmortal();
8139         if (result) {
8140             sv_setpv((SV*)ST(argvi++), (char *) result);
8141         }else {
8142             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
8143         }
8144         XSRETURN(argvi);
8145         fail:
8146         (void) _swigerr;
8147     }
8148     croak(_swigerr);
8149 }
8150
8151
8152 XS(_wrap_grs_perl_readf) {
8153     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8154     const char *_swigerr = _swigmsg;
8155     {
8156         struct perl_context *arg1 ;
8157         size_t arg2 ;
8158         int result;
8159         int argvi = 0;
8160         dXSARGS;
8161
8162         if ((items < 2) || (items > 2)) {
8163             SWIG_croak("Usage: grs_perl_readf(context,len);");
8164         }
8165         {
8166             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8167                 SWIG_croak("Type error in argument 1 of grs_perl_readf. Expected _p_perl_context");
8168             }
8169         }
8170         arg2 = (size_t) SvUV(ST(1));
8171         result = (int)grs_perl_readf(arg1,arg2);
8172
8173         ST(argvi) = sv_newmortal();
8174         sv_setiv(ST(argvi++), (IV) result);
8175         XSRETURN(argvi);
8176         fail:
8177         (void) _swigerr;
8178     }
8179     croak(_swigerr);
8180 }
8181
8182
8183 XS(_wrap_grs_perl_readline) {
8184     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8185     const char *_swigerr = _swigmsg;
8186     {
8187         struct perl_context *arg1 ;
8188         int result;
8189         int argvi = 0;
8190         dXSARGS;
8191
8192         if ((items < 1) || (items > 1)) {
8193             SWIG_croak("Usage: grs_perl_readline(context);");
8194         }
8195         {
8196             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8197                 SWIG_croak("Type error in argument 1 of grs_perl_readline. Expected _p_perl_context");
8198             }
8199         }
8200         result = (int)grs_perl_readline(arg1);
8201
8202         ST(argvi) = sv_newmortal();
8203         sv_setiv(ST(argvi++), (IV) result);
8204         XSRETURN(argvi);
8205         fail:
8206         (void) _swigerr;
8207     }
8208     croak(_swigerr);
8209 }
8210
8211
8212 XS(_wrap_grs_perl_getc) {
8213     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8214     const char *_swigerr = _swigmsg;
8215     {
8216         struct perl_context *arg1 ;
8217         char result;
8218         int argvi = 0;
8219         dXSARGS;
8220
8221         if ((items < 1) || (items > 1)) {
8222             SWIG_croak("Usage: grs_perl_getc(context);");
8223         }
8224         {
8225             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8226                 SWIG_croak("Type error in argument 1 of grs_perl_getc. Expected _p_perl_context");
8227             }
8228         }
8229         result = (char)grs_perl_getc(arg1);
8230
8231         ST(argvi) = sv_newmortal();
8232         sv_setpvn((SV*)ST(argvi++), &result, 1);
8233         XSRETURN(argvi);
8234         fail:
8235         (void) _swigerr;
8236     }
8237     croak(_swigerr);
8238 }
8239
8240
8241 XS(_wrap_grs_perl_seekf) {
8242     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8243     const char *_swigerr = _swigmsg;
8244     {
8245         struct perl_context *arg1 ;
8246         off_t arg2 ;
8247         off_t result;
8248         int argvi = 0;
8249         dXSARGS;
8250
8251         if ((items < 2) || (items > 2)) {
8252             SWIG_croak("Usage: grs_perl_seekf(context,offset);");
8253         }
8254         {
8255             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8256                 SWIG_croak("Type error in argument 1 of grs_perl_seekf. Expected _p_perl_context");
8257             }
8258         }
8259         {
8260             off_t * argp;
8261             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_off_t,0) < 0) {
8262                 SWIG_croak("Type error in argument 2 of grs_perl_seekf. Expected _p_off_t");
8263             }
8264             arg2 = *argp;
8265         }
8266         result = grs_perl_seekf(arg1,arg2);
8267
8268         {
8269             off_t * resultobj = (off_t *) malloc(sizeof(off_t));
8270             memmove(resultobj, &result, sizeof(off_t));
8271             ST(argvi) = sv_newmortal();
8272             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_off_t,0);
8273         }
8274         XSRETURN(argvi);
8275         fail:
8276         (void) _swigerr;
8277     }
8278     croak(_swigerr);
8279 }
8280
8281
8282 XS(_wrap_grs_perl_tellf) {
8283     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8284     const char *_swigerr = _swigmsg;
8285     {
8286         struct perl_context *arg1 ;
8287         off_t result;
8288         int argvi = 0;
8289         dXSARGS;
8290
8291         if ((items < 1) || (items > 1)) {
8292             SWIG_croak("Usage: grs_perl_tellf(context);");
8293         }
8294         {
8295             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8296                 SWIG_croak("Type error in argument 1 of grs_perl_tellf. Expected _p_perl_context");
8297             }
8298         }
8299         result = grs_perl_tellf(arg1);
8300
8301         {
8302             off_t * resultobj = (off_t *) malloc(sizeof(off_t));
8303             memmove(resultobj, &result, sizeof(off_t));
8304             ST(argvi) = sv_newmortal();
8305             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_off_t,0);
8306         }
8307         XSRETURN(argvi);
8308         fail:
8309         (void) _swigerr;
8310     }
8311     croak(_swigerr);
8312 }
8313
8314
8315 XS(_wrap_grs_perl_endf) {
8316     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8317     const char *_swigerr = _swigmsg;
8318     {
8319         struct perl_context *arg1 ;
8320         off_t arg2 ;
8321         int argvi = 0;
8322         dXSARGS;
8323
8324         if ((items < 2) || (items > 2)) {
8325             SWIG_croak("Usage: grs_perl_endf(context,offset);");
8326         }
8327         {
8328             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8329                 SWIG_croak("Type error in argument 1 of grs_perl_endf. Expected _p_perl_context");
8330             }
8331         }
8332         {
8333             off_t * argp;
8334             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_off_t,0) < 0) {
8335                 SWIG_croak("Type error in argument 2 of grs_perl_endf. Expected _p_off_t");
8336             }
8337             arg2 = *argp;
8338         }
8339         grs_perl_endf(arg1,arg2);
8340
8341
8342         XSRETURN(argvi);
8343         fail:
8344         (void) _swigerr;
8345     }
8346     croak(_swigerr);
8347 }
8348
8349
8350 XS(_wrap_grs_perl_get_dh) {
8351     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8352     const char *_swigerr = _swigmsg;
8353     {
8354         struct perl_context *arg1 ;
8355         data1_handle *result;
8356         int argvi = 0;
8357         dXSARGS;
8358
8359         if ((items < 1) || (items > 1)) {
8360             SWIG_croak("Usage: grs_perl_get_dh(context);");
8361         }
8362         {
8363             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8364                 SWIG_croak("Type error in argument 1 of grs_perl_get_dh. Expected _p_perl_context");
8365             }
8366         }
8367         result = (data1_handle *)grs_perl_get_dh(arg1);
8368
8369         ST(argvi) = sv_newmortal();
8370         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_handle,0);
8371         XSRETURN(argvi);
8372         fail:
8373         (void) _swigerr;
8374     }
8375     croak(_swigerr);
8376 }
8377
8378
8379 XS(_wrap_grs_perl_get_mem) {
8380     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8381     const char *_swigerr = _swigmsg;
8382     {
8383         struct perl_context *arg1 ;
8384         NMEM *result;
8385         int argvi = 0;
8386         dXSARGS;
8387
8388         if ((items < 1) || (items > 1)) {
8389             SWIG_croak("Usage: grs_perl_get_mem(context);");
8390         }
8391         {
8392             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8393                 SWIG_croak("Type error in argument 1 of grs_perl_get_mem. Expected _p_perl_context");
8394             }
8395         }
8396         result = (NMEM *)grs_perl_get_mem(arg1);
8397
8398         ST(argvi) = sv_newmortal();
8399         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_NMEM,0);
8400         XSRETURN(argvi);
8401         fail:
8402         (void) _swigerr;
8403     }
8404     croak(_swigerr);
8405 }
8406
8407
8408 XS(_wrap_grs_perl_set_res) {
8409     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8410     const char *_swigerr = _swigmsg;
8411     {
8412         struct perl_context *arg1 ;
8413         data1_node *arg2 ;
8414         int argvi = 0;
8415         dXSARGS;
8416
8417         if ((items < 2) || (items > 2)) {
8418             SWIG_croak("Usage: grs_perl_set_res(context,n);");
8419         }
8420         {
8421             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8422                 SWIG_croak("Type error in argument 1 of grs_perl_set_res. Expected _p_perl_context");
8423             }
8424         }
8425         {
8426             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
8427                 SWIG_croak("Type error in argument 2 of grs_perl_set_res. Expected _p_data1_node");
8428             }
8429         }
8430         grs_perl_set_res(arg1,arg2);
8431
8432
8433         XSRETURN(argvi);
8434         fail:
8435         (void) _swigerr;
8436     }
8437     croak(_swigerr);
8438 }
8439
8440
8441
8442 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
8443
8444 static swig_type_info _swigt__p_ZebraService[] = {{"_p_ZebraService", 0, "ZebraService *", 0},{"_p_ZebraService"},{0}};
8445 static swig_type_info _swigt__p_cql_transform_t[] = {{"_p_cql_transform_t", 0, "cql_transform_t *", 0},{"_p_cql_transform_t"},{0}};
8446 static swig_type_info _swigt__p_data1_esetname[] = {{"_p_data1_esetname", 0, "data1_esetname *", 0},{"_p_data1_esetname"},{0}};
8447 static swig_type_info _swigt__p_data1_maptab[] = {{"_p_data1_maptab", 0, "data1_maptab *", 0},{"_p_data1_maptab"},{0}};
8448 static swig_type_info _swigt__p_ODR[] = {{"_p_ODR", 0, "ODR *", 0},{"_p_ODR"},{0}};
8449 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}};
8450 static swig_type_info _swigt__p_p_char[] = {{"_p_p_char", 0, "char **", 0},{"_p_p_char"},{0}};
8451 static swig_type_info _swigt__p_data1_absyn[] = {{"_p_data1_absyn", 0, "data1_absyn *", 0},{"_p_data1_absyn"},{0}};
8452 static swig_type_info _swigt__p_ZebraHandle[] = {{"_p_ZebraHandle", 0, "ZebraHandle *", 0},{"_p_ZebraHandle"},{0}};
8453 static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0},{"_p_void"},{0}};
8454 static swig_type_info _swigt__p_data1_attset[] = {{"_p_data1_attset", 0, "data1_attset *", 0},{"_p_data1_attset"},{0}};
8455 static swig_type_info _swigt__p_size_t[] = {{"_p_size_t", 0, "size_t *", 0},{"_p_size_t"},{0}};
8456 static swig_type_info _swigt__p_WRBUF[] = {{"_p_WRBUF", 0, "WRBUF *", 0},{"_p_WRBUF"},{0}};
8457 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}};
8458 static swig_type_info _swigt__p_Z_Espec1[] = {{"_p_Z_Espec1", 0, "Z_Espec1 *", 0},{"_p_Z_Espec1"},{0}};
8459 static swig_type_info _swigt__p_off_t[] = {{"_p_off_t", 0, "off_t *", 0},{"_p_off_t"},{0}};
8460 static swig_type_info _swigt__p_Odr_oid[] = {{"_p_Odr_oid", 0, "Odr_oid *", 0},{"_p_Odr_oid"},{0}};
8461 static swig_type_info _swigt__p_data1_varset[] = {{"_p_data1_varset", 0, "data1_varset *", 0},{"_p_data1_varset"},{0}};
8462 static swig_type_info _swigt__p_RetrievalRecordBuf[] = {{"IDZebra::RetrievalRecordBuf", 0, "RetrievalRecordBuf *", 0},{"IDZebra::RetrievalRecordBuf"},{0}};
8463 static swig_type_info _swigt__p_perl_context[] = {{"_p_perl_context", 0, "struct perl_context *", 0},{"_p_perl_context"},{0}};
8464 static swig_type_info _swigt__p_data1_node[] = {{"_p_data1_node", 0, "data1_node *", 0},{"_p_data1_node"},{0}};
8465 static swig_type_info _swigt__p_ScanObj[] = {{"IDZebra::ScanObj", 0, "ScanObj *", 0},{"IDZebra::ScanObj"},{0}};
8466 static swig_type_info _swigt__p_RetrievalObj[] = {{"IDZebra::RetrievalObj", 0, "RetrievalObj *", 0},{"IDZebra::RetrievalObj"},{0}};
8467 static swig_type_info _swigt__p_data1_tagset[] = {{"_p_data1_tagset", 0, "data1_tagset *", 0},{"_p_data1_tagset"},{0}};
8468 static swig_type_info _swigt__p_data1_tag[] = {{"_p_data1_tag", 0, "data1_tag *", 0},{"_p_data1_tag"},{0}};
8469 static swig_type_info _swigt__p_ZebraRetrievalRecord[] = {{"_p_ZebraRetrievalRecord", 0, "ZebraRetrievalRecord *", 0},{"_p_ZebraRetrievalRecord"},{0}};
8470 static swig_type_info _swigt__p_RetrievalRecord[] = {{"IDZebra::RetrievalRecord", 0, "RetrievalRecord *", 0},{"IDZebra::RetrievalRecord"},{0}};
8471 static swig_type_info _swigt__p_NMEM[] = {{"_p_NMEM", 0, "NMEM *", 0},{"_p_NMEM"},{0}};
8472 static swig_type_info _swigt__p_Z_ExplainRecord[] = {{"_p_Z_ExplainRecord", 0, "Z_ExplainRecord *", 0},{"_p_Z_ExplainRecord"},{0}};
8473 static swig_type_info _swigt__p_data1_marctab[] = {{"_p_data1_marctab", 0, "data1_marctab *", 0},{"_p_data1_marctab"},{0}};
8474 static swig_type_info _swigt__p_ZebraTransactionStatus[] = {{"IDZebra::ZebraTransactionStatus", 0, "ZebraTransactionStatus *", 0},{"IDZebra::ZebraTransactionStatus"},{0}};
8475 static swig_type_info _swigt__p_Z_BriefBib[] = {{"_p_Z_BriefBib", 0, "Z_BriefBib *", 0},{"_p_Z_BriefBib"},{0}};
8476 static swig_type_info _swigt__p_scanEntry[] = {{"IDZebra::scanEntry", 0, "scanEntry *", 0},{"IDZebra::scanEntry"},{0}};
8477 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}};
8478 static swig_type_info _swigt__p_FILE[] = {{"_p_FILE", 0, "FILE *", 0},{"_p_FILE"},{0}};
8479 static swig_type_info _swigt__p_data1_element[] = {{"_p_data1_element", 0, "data1_element *", 0},{"_p_data1_element"},{0}};
8480 static swig_type_info _swigt__p_recordGroup[] = {{"IDZebra::recordGroup", 0, "recordGroup *", 0},{"IDZebra::recordGroup"},{0}};
8481 static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0},{"_p_int"},{0}};
8482 static swig_type_info _swigt__p_data1_handle[] = {{"_p_data1_handle", 0, "data1_handle *", 0},{"_p_data1_handle"},{0}};
8483 static swig_type_info _swigt__p_p_int[] = {{"_p_p_int", 0, "int **", 0},{"_p_p_int"},{0}};
8484 static swig_type_info _swigt__p_data1_absyn_cache[] = {{"_p_data1_absyn_cache", 0, "data1_absyn_cache *", 0},{"_p_data1_absyn_cache"},{0}};
8485 static swig_type_info _swigt__p_data1_attset_cache[] = {{"_p_data1_attset_cache", 0, "data1_attset_cache *", 0},{"_p_data1_attset_cache"},{0}};
8486 static swig_type_info _swigt__p_Z_GenericRecord[] = {{"_p_Z_GenericRecord", 0, "Z_GenericRecord *", 0},{"_p_Z_GenericRecord"},{0}};
8487 static swig_type_info _swigt__p_data1_vartype[] = {{"_p_data1_vartype", 0, "data1_vartype *", 0},{"_p_data1_vartype"},{0}};
8488
8489 static swig_type_info *swig_types_initial[] = {
8490 _swigt__p_ZebraService,
8491 _swigt__p_cql_transform_t,
8492 _swigt__p_data1_esetname,
8493 _swigt__p_data1_maptab,
8494 _swigt__p_ODR,
8495 _swigt__p_f_p_void__int,
8496 _swigt__p_p_char,
8497 _swigt__p_data1_absyn,
8498 _swigt__p_ZebraHandle,
8499 _swigt__p_void,
8500 _swigt__p_data1_attset,
8501 _swigt__p_size_t,
8502 _swigt__p_WRBUF,
8503 _swigt__p_f_data1_handle_p_void_p_data1_absyn__void,
8504 _swigt__p_Z_Espec1,
8505 _swigt__p_off_t,
8506 _swigt__p_Odr_oid,
8507 _swigt__p_data1_varset,
8508 _swigt__p_RetrievalRecordBuf,
8509 _swigt__p_perl_context,
8510 _swigt__p_data1_node,
8511 _swigt__p_ScanObj,
8512 _swigt__p_RetrievalObj,
8513 _swigt__p_data1_tagset,
8514 _swigt__p_data1_tag,
8515 _swigt__p_ZebraRetrievalRecord,
8516 _swigt__p_RetrievalRecord,
8517 _swigt__p_NMEM,
8518 _swigt__p_Z_ExplainRecord,
8519 _swigt__p_data1_marctab,
8520 _swigt__p_ZebraTransactionStatus,
8521 _swigt__p_Z_BriefBib,
8522 _swigt__p_scanEntry,
8523 _swigt__p_f_p_void_p_char_size_t__int,
8524 _swigt__p_FILE,
8525 _swigt__p_data1_element,
8526 _swigt__p_recordGroup,
8527 _swigt__p_int,
8528 _swigt__p_data1_handle,
8529 _swigt__p_p_int,
8530 _swigt__p_data1_absyn_cache,
8531 _swigt__p_data1_attset_cache,
8532 _swigt__p_Z_GenericRecord,
8533 _swigt__p_data1_vartype,
8534 0
8535 };
8536
8537
8538 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
8539
8540 static swig_constant_info swig_constants[] = {
8541 { SWIG_INT,     (char *) SWIG_prefix "LOG_FATAL", (long) 0x0001, 0, 0, 0},
8542 { SWIG_INT,     (char *) SWIG_prefix "LOG_DEBUG", (long) 0x0002, 0, 0, 0},
8543 { SWIG_INT,     (char *) SWIG_prefix "LOG_WARN", (long) 0x0004, 0, 0, 0},
8544 { SWIG_INT,     (char *) SWIG_prefix "LOG_LOG", (long) 0x0008, 0, 0, 0},
8545 { SWIG_INT,     (char *) SWIG_prefix "LOG_ERRNO", (long) 0x0010, 0, 0, 0},
8546 { SWIG_INT,     (char *) SWIG_prefix "LOG_FILE", (long) 0x0020, 0, 0, 0},
8547 { SWIG_INT,     (char *) SWIG_prefix "LOG_APP", (long) 0x0040, 0, 0, 0},
8548 { SWIG_INT,     (char *) SWIG_prefix "LOG_MALLOC", (long) 0x0080, 0, 0, 0},
8549 { SWIG_INT,     (char *) SWIG_prefix "LOG_ALL", (long) 0xff7f, 0, 0, 0},
8550 { SWIG_INT,     (char *) SWIG_prefix "LOG_DEFAULT_LEVEL", (long) (0x0001|0x0010|0x0008|0x0004), 0, 0, 0},
8551 { SWIG_INT,     (char *) SWIG_prefix "ODR_DECODE", (long) 0, 0, 0, 0},
8552 { SWIG_INT,     (char *) SWIG_prefix "ODR_ENCODE", (long) 1, 0, 0, 0},
8553 { SWIG_INT,     (char *) SWIG_prefix "ODR_PRINT", (long) 2, 0, 0, 0},
8554 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_unknown", (long) DATA1K_unknown, 0, 0, 0},
8555 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_structured", (long) DATA1K_structured, 0, 0, 0},
8556 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_string", (long) DATA1K_string, 0, 0, 0},
8557 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_numeric", (long) DATA1K_numeric, 0, 0, 0},
8558 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_bool", (long) DATA1K_bool, 0, 0, 0},
8559 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_oid", (long) DATA1K_oid, 0, 0, 0},
8560 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_generalizedtime", (long) DATA1K_generalizedtime, 0, 0, 0},
8561 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_intunit", (long) DATA1K_intunit, 0, 0, 0},
8562 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_int", (long) DATA1K_int, 0, 0, 0},
8563 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_octetstring", (long) DATA1K_octetstring, 0, 0, 0},
8564 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_null", (long) DATA1K_null, 0, 0, 0},
8565 { SWIG_INT,     (char *) SWIG_prefix "DATA1T_numeric", (long) 1, 0, 0, 0},
8566 { SWIG_INT,     (char *) SWIG_prefix "DATA1T_string", (long) 2, 0, 0, 0},
8567 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_root", (long) 1, 0, 0, 0},
8568 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_tag", (long) 2, 0, 0, 0},
8569 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_data", (long) 3, 0, 0, 0},
8570 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_variant", (long) 4, 0, 0, 0},
8571 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_comment", (long) 5, 0, 0, 0},
8572 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_preprocess", (long) 6, 0, 0, 0},
8573 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_inctxt", (long) 1, 0, 0, 0},
8574 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_incbin", (long) 2, 0, 0, 0},
8575 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_text", (long) 3, 0, 0, 0},
8576 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_num", (long) 4, 0, 0, 0},
8577 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_oid", (long) 5, 0, 0, 0},
8578 { SWIG_INT,     (char *) SWIG_prefix "DATA1_LOCALDATA", (long) 12, 0, 0, 0},
8579 { SWIG_INT,     (char *) SWIG_prefix "DATA1_FLAG_XML", (long) 1, 0, 0, 0},
8580 {0}
8581 };
8582 #ifdef __cplusplus
8583 }
8584 #endif
8585 static swig_variable_info swig_variables[] = {
8586 {0}
8587 };
8588 static swig_command_info swig_commands[] = {
8589 {"IDZebrac::recordGroup_groupName_set", _wrap_recordGroup_groupName_set},
8590 {"IDZebrac::recordGroup_groupName_get", _wrap_recordGroup_groupName_get},
8591 {"IDZebrac::recordGroup_databaseName_set", _wrap_recordGroup_databaseName_set},
8592 {"IDZebrac::recordGroup_databaseName_get", _wrap_recordGroup_databaseName_get},
8593 {"IDZebrac::recordGroup_path_set", _wrap_recordGroup_path_set},
8594 {"IDZebrac::recordGroup_path_get", _wrap_recordGroup_path_get},
8595 {"IDZebrac::recordGroup_recordId_set", _wrap_recordGroup_recordId_set},
8596 {"IDZebrac::recordGroup_recordId_get", _wrap_recordGroup_recordId_get},
8597 {"IDZebrac::recordGroup_recordType_set", _wrap_recordGroup_recordType_set},
8598 {"IDZebrac::recordGroup_recordType_get", _wrap_recordGroup_recordType_get},
8599 {"IDZebrac::recordGroup_flagStoreData_set", _wrap_recordGroup_flagStoreData_set},
8600 {"IDZebrac::recordGroup_flagStoreData_get", _wrap_recordGroup_flagStoreData_get},
8601 {"IDZebrac::recordGroup_flagStoreKeys_set", _wrap_recordGroup_flagStoreKeys_set},
8602 {"IDZebrac::recordGroup_flagStoreKeys_get", _wrap_recordGroup_flagStoreKeys_get},
8603 {"IDZebrac::recordGroup_flagRw_set", _wrap_recordGroup_flagRw_set},
8604 {"IDZebrac::recordGroup_flagRw_get", _wrap_recordGroup_flagRw_get},
8605 {"IDZebrac::recordGroup_fileVerboseLimit_set", _wrap_recordGroup_fileVerboseLimit_set},
8606 {"IDZebrac::recordGroup_fileVerboseLimit_get", _wrap_recordGroup_fileVerboseLimit_get},
8607 {"IDZebrac::recordGroup_databaseNamePath_set", _wrap_recordGroup_databaseNamePath_set},
8608 {"IDZebrac::recordGroup_databaseNamePath_get", _wrap_recordGroup_databaseNamePath_get},
8609 {"IDZebrac::recordGroup_explainDatabase_set", _wrap_recordGroup_explainDatabase_set},
8610 {"IDZebrac::recordGroup_explainDatabase_get", _wrap_recordGroup_explainDatabase_get},
8611 {"IDZebrac::recordGroup_followLinks_set", _wrap_recordGroup_followLinks_set},
8612 {"IDZebrac::recordGroup_followLinks_get", _wrap_recordGroup_followLinks_get},
8613 {"IDZebrac::new_recordGroup", _wrap_new_recordGroup},
8614 {"IDZebrac::delete_recordGroup", _wrap_delete_recordGroup},
8615 {"IDZebrac::RetrievalObj_noOfRecords_set", _wrap_RetrievalObj_noOfRecords_set},
8616 {"IDZebrac::RetrievalObj_noOfRecords_get", _wrap_RetrievalObj_noOfRecords_get},
8617 {"IDZebrac::RetrievalObj_records_set", _wrap_RetrievalObj_records_set},
8618 {"IDZebrac::RetrievalObj_records_get", _wrap_RetrievalObj_records_get},
8619 {"IDZebrac::new_RetrievalObj", _wrap_new_RetrievalObj},
8620 {"IDZebrac::delete_RetrievalObj", _wrap_delete_RetrievalObj},
8621 {"IDZebrac::RetrievalRecordBuf_buf_set", _wrap_RetrievalRecordBuf_buf_set},
8622 {"IDZebrac::RetrievalRecordBuf_buf_get", _wrap_RetrievalRecordBuf_buf_get},
8623 {"IDZebrac::RetrievalRecordBuf_len_set", _wrap_RetrievalRecordBuf_len_set},
8624 {"IDZebrac::RetrievalRecordBuf_len_get", _wrap_RetrievalRecordBuf_len_get},
8625 {"IDZebrac::new_RetrievalRecordBuf", _wrap_new_RetrievalRecordBuf},
8626 {"IDZebrac::delete_RetrievalRecordBuf", _wrap_delete_RetrievalRecordBuf},
8627 {"IDZebrac::RetrievalRecord_errCode_set", _wrap_RetrievalRecord_errCode_set},
8628 {"IDZebrac::RetrievalRecord_errCode_get", _wrap_RetrievalRecord_errCode_get},
8629 {"IDZebrac::RetrievalRecord_errString_set", _wrap_RetrievalRecord_errString_set},
8630 {"IDZebrac::RetrievalRecord_errString_get", _wrap_RetrievalRecord_errString_get},
8631 {"IDZebrac::RetrievalRecord_position_set", _wrap_RetrievalRecord_position_set},
8632 {"IDZebrac::RetrievalRecord_position_get", _wrap_RetrievalRecord_position_get},
8633 {"IDZebrac::RetrievalRecord_base_set", _wrap_RetrievalRecord_base_set},
8634 {"IDZebrac::RetrievalRecord_base_get", _wrap_RetrievalRecord_base_get},
8635 {"IDZebrac::RetrievalRecord_sysno_set", _wrap_RetrievalRecord_sysno_set},
8636 {"IDZebrac::RetrievalRecord_sysno_get", _wrap_RetrievalRecord_sysno_get},
8637 {"IDZebrac::RetrievalRecord_score_set", _wrap_RetrievalRecord_score_set},
8638 {"IDZebrac::RetrievalRecord_score_get", _wrap_RetrievalRecord_score_get},
8639 {"IDZebrac::RetrievalRecord_format_set", _wrap_RetrievalRecord_format_set},
8640 {"IDZebrac::RetrievalRecord_format_get", _wrap_RetrievalRecord_format_get},
8641 {"IDZebrac::RetrievalRecord_buf_set", _wrap_RetrievalRecord_buf_set},
8642 {"IDZebrac::RetrievalRecord_buf_get", _wrap_RetrievalRecord_buf_get},
8643 {"IDZebrac::new_RetrievalRecord", _wrap_new_RetrievalRecord},
8644 {"IDZebrac::delete_RetrievalRecord", _wrap_delete_RetrievalRecord},
8645 {"IDZebrac::scanEntry_occurrences_set", _wrap_scanEntry_occurrences_set},
8646 {"IDZebrac::scanEntry_occurrences_get", _wrap_scanEntry_occurrences_get},
8647 {"IDZebrac::scanEntry_term_set", _wrap_scanEntry_term_set},
8648 {"IDZebrac::scanEntry_term_get", _wrap_scanEntry_term_get},
8649 {"IDZebrac::new_scanEntry", _wrap_new_scanEntry},
8650 {"IDZebrac::delete_scanEntry", _wrap_delete_scanEntry},
8651 {"IDZebrac::ScanObj_num_entries_set", _wrap_ScanObj_num_entries_set},
8652 {"IDZebrac::ScanObj_num_entries_get", _wrap_ScanObj_num_entries_get},
8653 {"IDZebrac::ScanObj_position_set", _wrap_ScanObj_position_set},
8654 {"IDZebrac::ScanObj_position_get", _wrap_ScanObj_position_get},
8655 {"IDZebrac::ScanObj_is_partial_set", _wrap_ScanObj_is_partial_set},
8656 {"IDZebrac::ScanObj_is_partial_get", _wrap_ScanObj_is_partial_get},
8657 {"IDZebrac::ScanObj_entries_set", _wrap_ScanObj_entries_set},
8658 {"IDZebrac::ScanObj_entries_get", _wrap_ScanObj_entries_get},
8659 {"IDZebrac::new_ScanObj", _wrap_new_ScanObj},
8660 {"IDZebrac::delete_ScanObj", _wrap_delete_ScanObj},
8661 {"IDZebrac::ZebraTransactionStatus_processed_set", _wrap_ZebraTransactionStatus_processed_set},
8662 {"IDZebrac::ZebraTransactionStatus_processed_get", _wrap_ZebraTransactionStatus_processed_get},
8663 {"IDZebrac::ZebraTransactionStatus_inserted_set", _wrap_ZebraTransactionStatus_inserted_set},
8664 {"IDZebrac::ZebraTransactionStatus_inserted_get", _wrap_ZebraTransactionStatus_inserted_get},
8665 {"IDZebrac::ZebraTransactionStatus_updated_set", _wrap_ZebraTransactionStatus_updated_set},
8666 {"IDZebrac::ZebraTransactionStatus_updated_get", _wrap_ZebraTransactionStatus_updated_get},
8667 {"IDZebrac::ZebraTransactionStatus_deleted_set", _wrap_ZebraTransactionStatus_deleted_set},
8668 {"IDZebrac::ZebraTransactionStatus_deleted_get", _wrap_ZebraTransactionStatus_deleted_get},
8669 {"IDZebrac::ZebraTransactionStatus_utime_set", _wrap_ZebraTransactionStatus_utime_set},
8670 {"IDZebrac::ZebraTransactionStatus_utime_get", _wrap_ZebraTransactionStatus_utime_get},
8671 {"IDZebrac::ZebraTransactionStatus_stime_set", _wrap_ZebraTransactionStatus_stime_set},
8672 {"IDZebrac::ZebraTransactionStatus_stime_get", _wrap_ZebraTransactionStatus_stime_get},
8673 {"IDZebrac::new_ZebraTransactionStatus", _wrap_new_ZebraTransactionStatus},
8674 {"IDZebrac::delete_ZebraTransactionStatus", _wrap_delete_ZebraTransactionStatus},
8675 {"IDZebrac::DESTROY", _wrap_DESTROY},
8676 {"IDZebrac::logLevel", _wrap_logLevel},
8677 {"IDZebrac::logFile", _wrap_logFile},
8678 {"IDZebrac::logMsg", _wrap_logMsg},
8679 {"IDZebrac::odr_createmem", _wrap_odr_createmem},
8680 {"IDZebrac::odr_reset", _wrap_odr_reset},
8681 {"IDZebrac::odr_destroy", _wrap_odr_destroy},
8682 {"IDZebrac::odr_malloc", _wrap_odr_malloc},
8683 {"IDZebrac::start", _wrap_start},
8684 {"IDZebrac::open", _wrap_open},
8685 {"IDZebrac::close", _wrap_close},
8686 {"IDZebrac::stop", _wrap_stop},
8687 {"IDZebrac::errCode", _wrap_errCode},
8688 {"IDZebrac::errString", _wrap_errString},
8689 {"IDZebrac::errAdd", _wrap_errAdd},
8690 {"IDZebrac::init_recordGroup", _wrap_init_recordGroup},
8691 {"IDZebrac::res_get_recordGroup", _wrap_res_get_recordGroup},
8692 {"IDZebrac::set_group", _wrap_set_group},
8693 {"IDZebrac::select_database", _wrap_select_database},
8694 {"IDZebrac::select_databases", _wrap_select_databases},
8695 {"IDZebrac::begin_trans", _wrap_begin_trans},
8696 {"IDZebrac::end_trans", _wrap_end_trans},
8697 {"IDZebrac::trans_no", _wrap_trans_no},
8698 {"IDZebrac::begin_read", _wrap_begin_read},
8699 {"IDZebrac::end_read", _wrap_end_read},
8700 {"IDZebrac::commit", _wrap_commit},
8701 {"IDZebrac::get_shadow_enable", _wrap_get_shadow_enable},
8702 {"IDZebrac::set_shadow_enable", _wrap_set_shadow_enable},
8703 {"IDZebrac::init", _wrap_init},
8704 {"IDZebrac::compact", _wrap_compact},
8705 {"IDZebrac::repository_update", _wrap_repository_update},
8706 {"IDZebrac::repository_delete", _wrap_repository_delete},
8707 {"IDZebrac::repository_show", _wrap_repository_show},
8708 {"IDZebrac::update_record", _wrap_update_record},
8709 {"IDZebrac::delete_record", _wrap_delete_record},
8710 {"IDZebrac::search_PQF", _wrap_search_PQF},
8711 {"IDZebrac::cql_transform_open_fname", _wrap_cql_transform_open_fname},
8712 {"IDZebrac::cql_transform_close", _wrap_cql_transform_close},
8713 {"IDZebrac::cql_transform_error", _wrap_cql_transform_error},
8714 {"IDZebrac::cql2pqf", _wrap_cql2pqf},
8715 {"IDZebrac::records_retrieve", _wrap_records_retrieve},
8716 {"IDZebrac::record_retrieve", _wrap_record_retrieve},
8717 {"IDZebrac::deleteResultSet", _wrap_deleteResultSet},
8718 {"IDZebrac::sort", _wrap_sort},
8719 {"IDZebrac::scan_PQF", _wrap_scan_PQF},
8720 {"IDZebrac::getScanEntry", _wrap_getScanEntry},
8721 {"IDZebrac::nmem_create", _wrap_nmem_create},
8722 {"IDZebrac::nmem_destroy", _wrap_nmem_destroy},
8723 {"IDZebrac::data1_create", _wrap_data1_create},
8724 {"IDZebrac::data1_createx", _wrap_data1_createx},
8725 {"IDZebrac::data1_destroy", _wrap_data1_destroy},
8726 {"IDZebrac::get_parent_tag", _wrap_get_parent_tag},
8727 {"IDZebrac::data1_read_node", _wrap_data1_read_node},
8728 {"IDZebrac::data1_read_nodex", _wrap_data1_read_nodex},
8729 {"IDZebrac::data1_read_record", _wrap_data1_read_record},
8730 {"IDZebrac::data1_read_absyn", _wrap_data1_read_absyn},
8731 {"IDZebrac::data1_gettagbynum", _wrap_data1_gettagbynum},
8732 {"IDZebrac::data1_empty_tagset", _wrap_data1_empty_tagset},
8733 {"IDZebrac::data1_read_tagset", _wrap_data1_read_tagset},
8734 {"IDZebrac::data1_getelementbytagname", _wrap_data1_getelementbytagname},
8735 {"IDZebrac::data1_nodetogr", _wrap_data1_nodetogr},
8736 {"IDZebrac::data1_gettagbyname", _wrap_data1_gettagbyname},
8737 {"IDZebrac::data1_free_tree", _wrap_data1_free_tree},
8738 {"IDZebrac::data1_nodetobuf", _wrap_data1_nodetobuf},
8739 {"IDZebrac::data1_mk_tag_data_wd", _wrap_data1_mk_tag_data_wd},
8740 {"IDZebrac::data1_mk_tag_data", _wrap_data1_mk_tag_data},
8741 {"IDZebrac::data1_maptype", _wrap_data1_maptype},
8742 {"IDZebrac::data1_read_varset", _wrap_data1_read_varset},
8743 {"IDZebrac::data1_getvartypebyct", _wrap_data1_getvartypebyct},
8744 {"IDZebrac::data1_read_espec1", _wrap_data1_read_espec1},
8745 {"IDZebrac::data1_doespec1", _wrap_data1_doespec1},
8746 {"IDZebrac::data1_getesetbyname", _wrap_data1_getesetbyname},
8747 {"IDZebrac::data1_getelementbyname", _wrap_data1_getelementbyname},
8748 {"IDZebrac::data1_mk_node2", _wrap_data1_mk_node2},
8749 {"IDZebrac::data1_mk_tag", _wrap_data1_mk_tag},
8750 {"IDZebrac::data1_mk_tag_n", _wrap_data1_mk_tag_n},
8751 {"IDZebrac::data1_tag_add_attr", _wrap_data1_tag_add_attr},
8752 {"IDZebrac::data1_mk_text_n", _wrap_data1_mk_text_n},
8753 {"IDZebrac::data1_mk_text_nf", _wrap_data1_mk_text_nf},
8754 {"IDZebrac::data1_mk_text", _wrap_data1_mk_text},
8755 {"IDZebrac::data1_mk_comment_n", _wrap_data1_mk_comment_n},
8756 {"IDZebrac::data1_mk_comment", _wrap_data1_mk_comment},
8757 {"IDZebrac::data1_mk_preprocess", _wrap_data1_mk_preprocess},
8758 {"IDZebrac::data1_mk_root", _wrap_data1_mk_root},
8759 {"IDZebrac::data1_set_root", _wrap_data1_set_root},
8760 {"IDZebrac::data1_mk_tag_data_int", _wrap_data1_mk_tag_data_int},
8761 {"IDZebrac::data1_mk_tag_data_oid", _wrap_data1_mk_tag_data_oid},
8762 {"IDZebrac::data1_mk_tag_data_text", _wrap_data1_mk_tag_data_text},
8763 {"IDZebrac::data1_mk_tag_data_text_uni", _wrap_data1_mk_tag_data_text_uni},
8764 {"IDZebrac::data1_get_absyn", _wrap_data1_get_absyn},
8765 {"IDZebrac::data1_search_tag", _wrap_data1_search_tag},
8766 {"IDZebrac::data1_mk_tag_uni", _wrap_data1_mk_tag_uni},
8767 {"IDZebrac::data1_get_attset", _wrap_data1_get_attset},
8768 {"IDZebrac::data1_read_maptab", _wrap_data1_read_maptab},
8769 {"IDZebrac::data1_map_record", _wrap_data1_map_record},
8770 {"IDZebrac::data1_read_marctab", _wrap_data1_read_marctab},
8771 {"IDZebrac::data1_nodetomarc", _wrap_data1_nodetomarc},
8772 {"IDZebrac::data1_nodetoidsgml", _wrap_data1_nodetoidsgml},
8773 {"IDZebrac::data1_nodetoexplain", _wrap_data1_nodetoexplain},
8774 {"IDZebrac::data1_nodetosummary", _wrap_data1_nodetosummary},
8775 {"IDZebrac::data1_nodetosoif", _wrap_data1_nodetosoif},
8776 {"IDZebrac::data1_get_wrbuf", _wrap_data1_get_wrbuf},
8777 {"IDZebrac::data1_get_read_buf", _wrap_data1_get_read_buf},
8778 {"IDZebrac::data1_get_map_buf", _wrap_data1_get_map_buf},
8779 {"IDZebrac::data1_absyn_cache_get", _wrap_data1_absyn_cache_get},
8780 {"IDZebrac::data1_attset_cache_get", _wrap_data1_attset_cache_get},
8781 {"IDZebrac::data1_nmem_get", _wrap_data1_nmem_get},
8782 {"IDZebrac::data1_pr_tree", _wrap_data1_pr_tree},
8783 {"IDZebrac::data1_print_tree", _wrap_data1_print_tree},
8784 {"IDZebrac::data1_insert_string", _wrap_data1_insert_string},
8785 {"IDZebrac::data1_insert_string_n", _wrap_data1_insert_string_n},
8786 {"IDZebrac::data1_read_sgml", _wrap_data1_read_sgml},
8787 {"IDZebrac::data1_absyn_trav", _wrap_data1_absyn_trav},
8788 {"IDZebrac::data1_attset_search_id", _wrap_data1_attset_search_id},
8789 {"IDZebrac::data1_getNodeValue", _wrap_data1_getNodeValue},
8790 {"IDZebrac::data1_LookupNode", _wrap_data1_LookupNode},
8791 {"IDZebrac::data1_CountOccurences", _wrap_data1_CountOccurences},
8792 {"IDZebrac::data1_path_fopen", _wrap_data1_path_fopen},
8793 {"IDZebrac::data1_set_tabpath", _wrap_data1_set_tabpath},
8794 {"IDZebrac::data1_set_tabroot", _wrap_data1_set_tabroot},
8795 {"IDZebrac::data1_get_tabpath", _wrap_data1_get_tabpath},
8796 {"IDZebrac::data1_get_tabroot", _wrap_data1_get_tabroot},
8797 {"IDZebrac::grs_perl_readf", _wrap_grs_perl_readf},
8798 {"IDZebrac::grs_perl_readline", _wrap_grs_perl_readline},
8799 {"IDZebrac::grs_perl_getc", _wrap_grs_perl_getc},
8800 {"IDZebrac::grs_perl_seekf", _wrap_grs_perl_seekf},
8801 {"IDZebrac::grs_perl_tellf", _wrap_grs_perl_tellf},
8802 {"IDZebrac::grs_perl_endf", _wrap_grs_perl_endf},
8803 {"IDZebrac::grs_perl_get_dh", _wrap_grs_perl_get_dh},
8804 {"IDZebrac::grs_perl_get_mem", _wrap_grs_perl_get_mem},
8805 {"IDZebrac::grs_perl_set_res", _wrap_grs_perl_set_res},
8806 {0,0}
8807 };
8808
8809 #ifdef __cplusplus
8810 extern "C"
8811 #endif
8812
8813 XS(SWIG_init) {
8814     dXSARGS;
8815     int i;
8816     static int _init = 0;
8817     if (!_init) {
8818         for (i = 0; swig_types_initial[i]; i++) {
8819             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
8820         }
8821         _init = 1;
8822     }
8823
8824     /* Install commands */
8825     for (i = 0; swig_commands[i].name; i++) {
8826         newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
8827     }
8828
8829     /* Install variables */
8830     for (i = 0; swig_variables[i].name; i++) {
8831         SV *sv;
8832         sv = perl_get_sv((char*) swig_variables[i].name, TRUE | 0x2);
8833         if (swig_variables[i].type) {
8834             SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
8835         }else {
8836             sv_setiv(sv,(IV) 0);
8837         }
8838         swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
8839     }
8840
8841     /* Install constant */
8842     for (i = 0; swig_constants[i].type; i++) {
8843         SV *sv;
8844         sv = perl_get_sv((char*)swig_constants[i].name, TRUE | 0x2);
8845         switch(swig_constants[i].type) {
8846             case SWIG_INT:
8847             sv_setiv(sv, (IV) swig_constants[i].lvalue);
8848             break;
8849             case SWIG_FLOAT:
8850             sv_setnv(sv, (double) swig_constants[i].dvalue);
8851             break;
8852             case SWIG_STRING:
8853             sv_setpv(sv, (char *) swig_constants[i].pvalue);
8854             break;
8855             case SWIG_POINTER:
8856             SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
8857             break;
8858             case SWIG_BINARY:
8859             /*      obj = SWIG_NewPackedObj(swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype)); */
8860             break;
8861             default:
8862             break;
8863         }
8864         SvREADONLY_on(sv);
8865     }
8866
8867     SWIG_TypeClientData(SWIGTYPE_p_recordGroup, (void*) "IDZebra::recordGroup");
8868     SWIG_TypeClientData(SWIGTYPE_p_RetrievalObj, (void*) "IDZebra::RetrievalObj");
8869     SWIG_TypeClientData(SWIGTYPE_p_RetrievalRecordBuf, (void*) "IDZebra::RetrievalRecordBuf");
8870     SWIG_TypeClientData(SWIGTYPE_p_RetrievalRecord, (void*) "IDZebra::RetrievalRecord");
8871     SWIG_TypeClientData(SWIGTYPE_p_scanEntry, (void*) "IDZebra::scanEntry");
8872     SWIG_TypeClientData(SWIGTYPE_p_ScanObj, (void*) "IDZebra::ScanObj");
8873     SWIG_TypeClientData(SWIGTYPE_p_ZebraTransactionStatus, (void*) "IDZebra::ZebraTransactionStatus");
8874     ST(0) = &PL_sv_yes;
8875     XSRETURN(1);
8876 }
8877