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