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