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