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