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