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.8 2003-03-03 00:47:58 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_sort) {
4480     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4481     const char *_swigerr = _swigmsg;
4482     {
4483         ZebraHandle arg1 ;
4484         ODR arg2 ;
4485         char *arg3 ;
4486         char *arg4 ;
4487         char **arg5 ;
4488         int result;
4489         int argvi = 0;
4490         dXSARGS;
4491
4492         if ((items < 5) || (items > 5)) {
4493             SWIG_croak("Usage: sort(zh,stream,sort_spec,output_setname,input_setnames);");
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 sort. Expected _p_ZebraHandle");
4499             }
4500             arg1 = *argp;
4501         }
4502         {
4503             ODR * argp;
4504             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4505                 SWIG_croak("Type error in argument 2 of sort. Expected _p_ODR");
4506             }
4507             arg2 = *argp;
4508         }
4509         if (!SvOK((SV*) ST(2))) arg3 = 0;
4510         else arg3 = (char *) SvPV(ST(2), PL_na);
4511         if (!SvOK((SV*) ST(3))) arg4 = 0;
4512         else arg4 = (char *) SvPV(ST(3), PL_na);
4513         {
4514             AV *tempav;
4515             I32 len;
4516             int i;
4517             SV  **tv;
4518             STRLEN na;
4519             if (!SvROK(ST(4)))
4520             croak("Argument 5 is not a reference.");
4521             if (SvTYPE(SvRV(ST(4))) != SVt_PVAV)
4522             croak("Argument 5 is not an array.");
4523             tempav = (AV*)SvRV(ST(4));
4524             len = av_len(tempav);
4525             arg5 = (char **) malloc((len+2)*sizeof(char *));
4526             for (i = 0; i <= len; i++) {
4527                 tv = av_fetch(tempav, i, 0);
4528                 arg5[i] = (char *) SvPV(*tv,na);
4529             }
4530             arg5[i] = NULL;
4531         }
4532         result = (int)sort(arg1,arg2,(char const *)arg3,(char const *)arg4,(char const **)arg5);
4533
4534         ST(argvi) = sv_newmortal();
4535         sv_setiv(ST(argvi++), (IV) result);
4536         {
4537             free(arg5);
4538         }
4539         XSRETURN(argvi);
4540         fail:
4541         {
4542             free(arg5);
4543         }
4544         (void) _swigerr;
4545     }
4546     croak(_swigerr);
4547 }
4548
4549
4550 XS(_wrap_scan_PQF) {
4551     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4552     const char *_swigerr = _swigmsg;
4553     {
4554         ZebraHandle arg1 ;
4555         ScanObj *arg2 ;
4556         ODR arg3 ;
4557         char *arg4 ;
4558         int argvi = 0;
4559         dXSARGS;
4560
4561         if ((items < 4) || (items > 4)) {
4562             SWIG_croak("Usage: scan_PQF(zh,so,stream,pqf_query);");
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 scan_PQF. Expected _p_ZebraHandle");
4568             }
4569             arg1 = *argp;
4570         }
4571         {
4572             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ScanObj,0) < 0) {
4573                 SWIG_croak("Type error in argument 2 of scan_PQF. Expected _p_ScanObj");
4574             }
4575         }
4576         {
4577             ODR * argp;
4578             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
4579                 SWIG_croak("Type error in argument 3 of scan_PQF. Expected _p_ODR");
4580             }
4581             arg3 = *argp;
4582         }
4583         if (!SvOK((SV*) ST(3))) arg4 = 0;
4584         else arg4 = (char *) SvPV(ST(3), PL_na);
4585         zebra_scan_PQF(arg1,arg2,arg3,(char const *)arg4);
4586
4587
4588         XSRETURN(argvi);
4589         fail:
4590         (void) _swigerr;
4591     }
4592     croak(_swigerr);
4593 }
4594
4595
4596 XS(_wrap_getScanEntry) {
4597     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4598     const char *_swigerr = _swigmsg;
4599     {
4600         ScanObj *arg1 ;
4601         int arg2 ;
4602         ScanEntry *result;
4603         int argvi = 0;
4604         dXSARGS;
4605
4606         if ((items < 2) || (items > 2)) {
4607             SWIG_croak("Usage: getScanEntry(so,pos);");
4608         }
4609         {
4610             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) {
4611                 SWIG_croak("Type error in argument 1 of getScanEntry. Expected _p_ScanObj");
4612             }
4613         }
4614         arg2 = (int) SvIV(ST(1));
4615         result = (ScanEntry *)getScanEntry(arg1,arg2);
4616
4617         ST(argvi) = sv_newmortal();
4618         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ScanEntry,0);
4619         XSRETURN(argvi);
4620         fail:
4621         (void) _swigerr;
4622     }
4623     croak(_swigerr);
4624 }
4625
4626
4627 XS(_wrap_nmem_create) {
4628     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4629     const char *_swigerr = _swigmsg;
4630     {
4631         NMEM result;
4632         int argvi = 0;
4633         dXSARGS;
4634
4635         if ((items < 0) || (items > 0)) {
4636             SWIG_croak("Usage: nmem_create();");
4637         }
4638         result = nmem_create();
4639
4640         {
4641             NMEM * resultobj = (NMEM *) malloc(sizeof(NMEM));
4642             memmove(resultobj, &result, sizeof(NMEM));
4643             ST(argvi) = sv_newmortal();
4644             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_NMEM,0);
4645         }
4646         XSRETURN(argvi);
4647         fail:
4648         (void) _swigerr;
4649     }
4650     croak(_swigerr);
4651 }
4652
4653
4654 XS(_wrap_nmem_destroy) {
4655     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4656     const char *_swigerr = _swigmsg;
4657     {
4658         NMEM arg1 ;
4659         int argvi = 0;
4660         dXSARGS;
4661
4662         if ((items < 1) || (items > 1)) {
4663             SWIG_croak("Usage: nmem_destroy(handle);");
4664         }
4665         {
4666             NMEM * argp;
4667             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
4668                 SWIG_croak("Type error in argument 1 of nmem_destroy. Expected _p_NMEM");
4669             }
4670             arg1 = *argp;
4671         }
4672         nmem_destroy(arg1);
4673
4674
4675         XSRETURN(argvi);
4676         fail:
4677         (void) _swigerr;
4678     }
4679     croak(_swigerr);
4680 }
4681
4682
4683 XS(_wrap_data1_create) {
4684     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4685     const char *_swigerr = _swigmsg;
4686     {
4687         data1_handle result;
4688         int argvi = 0;
4689         dXSARGS;
4690
4691         if ((items < 0) || (items > 0)) {
4692             SWIG_croak("Usage: data1_create();");
4693         }
4694         result = data1_create();
4695
4696         {
4697             data1_handle * resultobj = (data1_handle *) malloc(sizeof(data1_handle));
4698             memmove(resultobj, &result, sizeof(data1_handle));
4699             ST(argvi) = sv_newmortal();
4700             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_data1_handle,0);
4701         }
4702         XSRETURN(argvi);
4703         fail:
4704         (void) _swigerr;
4705     }
4706     croak(_swigerr);
4707 }
4708
4709
4710 XS(_wrap_data1_createx) {
4711     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4712     const char *_swigerr = _swigmsg;
4713     {
4714         int arg1 ;
4715         data1_handle result;
4716         int argvi = 0;
4717         dXSARGS;
4718
4719         if ((items < 1) || (items > 1)) {
4720             SWIG_croak("Usage: data1_createx(flags);");
4721         }
4722         arg1 = (int) SvIV(ST(0));
4723         result = data1_createx(arg1);
4724
4725         {
4726             data1_handle * resultobj = (data1_handle *) malloc(sizeof(data1_handle));
4727             memmove(resultobj, &result, sizeof(data1_handle));
4728             ST(argvi) = sv_newmortal();
4729             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_data1_handle,0);
4730         }
4731         XSRETURN(argvi);
4732         fail:
4733         (void) _swigerr;
4734     }
4735     croak(_swigerr);
4736 }
4737
4738
4739 XS(_wrap_data1_destroy) {
4740     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4741     const char *_swigerr = _swigmsg;
4742     {
4743         data1_handle arg1 ;
4744         int argvi = 0;
4745         dXSARGS;
4746
4747         if ((items < 1) || (items > 1)) {
4748             SWIG_croak("Usage: data1_destroy(dh);");
4749         }
4750         {
4751             data1_handle * argp;
4752             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4753                 SWIG_croak("Type error in argument 1 of data1_destroy. Expected _p_data1_handle");
4754             }
4755             arg1 = *argp;
4756         }
4757         data1_destroy(arg1);
4758
4759
4760         XSRETURN(argvi);
4761         fail:
4762         (void) _swigerr;
4763     }
4764     croak(_swigerr);
4765 }
4766
4767
4768 XS(_wrap_get_parent_tag) {
4769     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4770     const char *_swigerr = _swigmsg;
4771     {
4772         data1_handle arg1 ;
4773         data1_node *arg2 ;
4774         data1_node *result;
4775         int argvi = 0;
4776         dXSARGS;
4777
4778         if ((items < 2) || (items > 2)) {
4779             SWIG_croak("Usage: get_parent_tag(dh,n);");
4780         }
4781         {
4782             data1_handle * argp;
4783             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4784                 SWIG_croak("Type error in argument 1 of get_parent_tag. Expected _p_data1_handle");
4785             }
4786             arg1 = *argp;
4787         }
4788         {
4789             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
4790                 SWIG_croak("Type error in argument 2 of get_parent_tag. Expected _p_data1_node");
4791             }
4792         }
4793         result = (data1_node *)get_parent_tag(arg1,arg2);
4794
4795         ST(argvi) = sv_newmortal();
4796         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
4797         XSRETURN(argvi);
4798         fail:
4799         (void) _swigerr;
4800     }
4801     croak(_swigerr);
4802 }
4803
4804
4805 XS(_wrap_data1_read_node) {
4806     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4807     const char *_swigerr = _swigmsg;
4808     {
4809         data1_handle arg1 ;
4810         char **arg2 ;
4811         NMEM arg3 ;
4812         data1_node *result;
4813         int argvi = 0;
4814         dXSARGS;
4815
4816         if ((items < 3) || (items > 3)) {
4817             SWIG_croak("Usage: data1_read_node(dh,buf,m);");
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_read_node. Expected _p_data1_handle");
4823             }
4824             arg1 = *argp;
4825         }
4826         {
4827             AV *tempav;
4828             I32 len;
4829             int i;
4830             SV  **tv;
4831             STRLEN na;
4832             if (!SvROK(ST(1)))
4833             croak("Argument 2 is not a reference.");
4834             if (SvTYPE(SvRV(ST(1))) != SVt_PVAV)
4835             croak("Argument 2 is not an array.");
4836             tempav = (AV*)SvRV(ST(1));
4837             len = av_len(tempav);
4838             arg2 = (char **) malloc((len+2)*sizeof(char *));
4839             for (i = 0; i <= len; i++) {
4840                 tv = av_fetch(tempav, i, 0);
4841                 arg2[i] = (char *) SvPV(*tv,na);
4842             }
4843             arg2[i] = NULL;
4844         }
4845         {
4846             NMEM * argp;
4847             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
4848                 SWIG_croak("Type error in argument 3 of data1_read_node. Expected _p_NMEM");
4849             }
4850             arg3 = *argp;
4851         }
4852         result = (data1_node *)data1_read_node(arg1,(char const **)arg2,arg3);
4853
4854         ST(argvi) = sv_newmortal();
4855         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
4856         {
4857             free(arg2);
4858         }
4859         XSRETURN(argvi);
4860         fail:
4861         {
4862             free(arg2);
4863         }
4864         (void) _swigerr;
4865     }
4866     croak(_swigerr);
4867 }
4868
4869
4870 XS(_wrap_data1_read_nodex) {
4871     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4872     const char *_swigerr = _swigmsg;
4873     {
4874         data1_handle arg1 ;
4875         NMEM arg2 ;
4876         int (*arg3)(void *) ;
4877         void *arg4 ;
4878         WRBUF arg5 ;
4879         data1_node *result;
4880         int argvi = 0;
4881         dXSARGS;
4882
4883         if ((items < 5) || (items > 5)) {
4884             SWIG_croak("Usage: data1_read_nodex(dh,m,get_byte,fh,wrbuf);");
4885         }
4886         {
4887             data1_handle * argp;
4888             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4889                 SWIG_croak("Type error in argument 1 of data1_read_nodex. Expected _p_data1_handle");
4890             }
4891             arg1 = *argp;
4892         }
4893         {
4894             NMEM * argp;
4895             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
4896                 SWIG_croak("Type error in argument 2 of data1_read_nodex. Expected _p_NMEM");
4897             }
4898             arg2 = *argp;
4899         }
4900         {
4901             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_f_p_void__int,0) < 0) {
4902                 SWIG_croak("Type error in argument 3 of data1_read_nodex. Expected _p_f_p_void__int");
4903             }
4904         }
4905         {
4906             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, 0,0) < 0) {
4907                 SWIG_croak("Type error in argument 4 of data1_read_nodex. Expected _p_void");
4908             }
4909         }
4910         {
4911             WRBUF * argp;
4912             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_WRBUF,0) < 0) {
4913                 SWIG_croak("Type error in argument 5 of data1_read_nodex. Expected _p_WRBUF");
4914             }
4915             arg5 = *argp;
4916         }
4917         result = (data1_node *)data1_read_nodex(arg1,arg2,arg3,arg4,arg5);
4918
4919         ST(argvi) = sv_newmortal();
4920         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
4921         XSRETURN(argvi);
4922         fail:
4923         (void) _swigerr;
4924     }
4925     croak(_swigerr);
4926 }
4927
4928
4929 XS(_wrap_data1_read_record) {
4930     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4931     const char *_swigerr = _swigmsg;
4932     {
4933         data1_handle arg1 ;
4934         int (*arg2)(void *,char *,size_t) ;
4935         void *arg3 ;
4936         NMEM arg4 ;
4937         data1_node *result;
4938         int argvi = 0;
4939         dXSARGS;
4940
4941         if ((items < 4) || (items > 4)) {
4942             SWIG_croak("Usage: data1_read_record(dh,rf,fh,m);");
4943         }
4944         {
4945             data1_handle * argp;
4946             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4947                 SWIG_croak("Type error in argument 1 of data1_read_record. Expected _p_data1_handle");
4948             }
4949             arg1 = *argp;
4950         }
4951         {
4952             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_f_p_void_p_char_size_t__int,0) < 0) {
4953                 SWIG_croak("Type error in argument 2 of data1_read_record. Expected _p_f_p_void_p_char_size_t__int");
4954             }
4955         }
4956         {
4957             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, 0,0) < 0) {
4958                 SWIG_croak("Type error in argument 3 of data1_read_record. Expected _p_void");
4959             }
4960         }
4961         {
4962             NMEM * argp;
4963             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
4964                 SWIG_croak("Type error in argument 4 of data1_read_record. Expected _p_NMEM");
4965             }
4966             arg4 = *argp;
4967         }
4968         result = (data1_node *)data1_read_record(arg1,arg2,arg3,arg4);
4969
4970         ST(argvi) = sv_newmortal();
4971         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
4972         XSRETURN(argvi);
4973         fail:
4974         (void) _swigerr;
4975     }
4976     croak(_swigerr);
4977 }
4978
4979
4980 XS(_wrap_data1_read_absyn) {
4981     char _swigmsg[SWIG_MAX_ERRMSG] = "";
4982     const char *_swigerr = _swigmsg;
4983     {
4984         data1_handle arg1 ;
4985         char *arg2 ;
4986         int arg3 ;
4987         data1_absyn *result;
4988         int argvi = 0;
4989         dXSARGS;
4990
4991         if ((items < 3) || (items > 3)) {
4992             SWIG_croak("Usage: data1_read_absyn(dh,file,file_must_exist);");
4993         }
4994         {
4995             data1_handle * argp;
4996             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
4997                 SWIG_croak("Type error in argument 1 of data1_read_absyn. Expected _p_data1_handle");
4998             }
4999             arg1 = *argp;
5000         }
5001         if (!SvOK((SV*) ST(1))) arg2 = 0;
5002         else arg2 = (char *) SvPV(ST(1), PL_na);
5003         arg3 = (int) SvIV(ST(2));
5004         result = (data1_absyn *)data1_read_absyn(arg1,(char const *)arg2,arg3);
5005
5006         ST(argvi) = sv_newmortal();
5007         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_absyn,0);
5008         XSRETURN(argvi);
5009         fail:
5010         (void) _swigerr;
5011     }
5012     croak(_swigerr);
5013 }
5014
5015
5016 XS(_wrap_data1_gettagbynum) {
5017     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5018     const char *_swigerr = _swigmsg;
5019     {
5020         data1_handle arg1 ;
5021         data1_tagset *arg2 ;
5022         int arg3 ;
5023         int arg4 ;
5024         data1_tag *result;
5025         int argvi = 0;
5026         dXSARGS;
5027
5028         if ((items < 4) || (items > 4)) {
5029             SWIG_croak("Usage: data1_gettagbynum(dh,s,type,value);");
5030         }
5031         {
5032             data1_handle * argp;
5033             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5034                 SWIG_croak("Type error in argument 1 of data1_gettagbynum. Expected _p_data1_handle");
5035             }
5036             arg1 = *argp;
5037         }
5038         {
5039             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_tagset,0) < 0) {
5040                 SWIG_croak("Type error in argument 2 of data1_gettagbynum. Expected _p_data1_tagset");
5041             }
5042         }
5043         arg3 = (int) SvIV(ST(2));
5044         arg4 = (int) SvIV(ST(3));
5045         result = (data1_tag *)data1_gettagbynum(arg1,arg2,arg3,arg4);
5046
5047         ST(argvi) = sv_newmortal();
5048         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tag,0);
5049         XSRETURN(argvi);
5050         fail:
5051         (void) _swigerr;
5052     }
5053     croak(_swigerr);
5054 }
5055
5056
5057 XS(_wrap_data1_empty_tagset) {
5058     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5059     const char *_swigerr = _swigmsg;
5060     {
5061         data1_handle arg1 ;
5062         data1_tagset *result;
5063         int argvi = 0;
5064         dXSARGS;
5065
5066         if ((items < 1) || (items > 1)) {
5067             SWIG_croak("Usage: data1_empty_tagset(dh);");
5068         }
5069         {
5070             data1_handle * argp;
5071             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5072                 SWIG_croak("Type error in argument 1 of data1_empty_tagset. Expected _p_data1_handle");
5073             }
5074             arg1 = *argp;
5075         }
5076         result = (data1_tagset *)data1_empty_tagset(arg1);
5077
5078         ST(argvi) = sv_newmortal();
5079         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tagset,0);
5080         XSRETURN(argvi);
5081         fail:
5082         (void) _swigerr;
5083     }
5084     croak(_swigerr);
5085 }
5086
5087
5088 XS(_wrap_data1_read_tagset) {
5089     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5090     const char *_swigerr = _swigmsg;
5091     {
5092         data1_handle arg1 ;
5093         char *arg2 ;
5094         int arg3 ;
5095         data1_tagset *result;
5096         int argvi = 0;
5097         dXSARGS;
5098
5099         if ((items < 3) || (items > 3)) {
5100             SWIG_croak("Usage: data1_read_tagset(dh,file,type);");
5101         }
5102         {
5103             data1_handle * argp;
5104             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5105                 SWIG_croak("Type error in argument 1 of data1_read_tagset. Expected _p_data1_handle");
5106             }
5107             arg1 = *argp;
5108         }
5109         if (!SvOK((SV*) ST(1))) arg2 = 0;
5110         else arg2 = (char *) SvPV(ST(1), PL_na);
5111         arg3 = (int) SvIV(ST(2));
5112         result = (data1_tagset *)data1_read_tagset(arg1,(char const *)arg2,arg3);
5113
5114         ST(argvi) = sv_newmortal();
5115         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tagset,0);
5116         XSRETURN(argvi);
5117         fail:
5118         (void) _swigerr;
5119     }
5120     croak(_swigerr);
5121 }
5122
5123
5124 XS(_wrap_data1_getelementbytagname) {
5125     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5126     const char *_swigerr = _swigmsg;
5127     {
5128         data1_handle arg1 ;
5129         data1_absyn *arg2 ;
5130         data1_element *arg3 ;
5131         char *arg4 ;
5132         data1_element *result;
5133         int argvi = 0;
5134         dXSARGS;
5135
5136         if ((items < 4) || (items > 4)) {
5137             SWIG_croak("Usage: data1_getelementbytagname(dh,abs,parent,tagname);");
5138         }
5139         {
5140             data1_handle * argp;
5141             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5142                 SWIG_croak("Type error in argument 1 of data1_getelementbytagname. Expected _p_data1_handle");
5143             }
5144             arg1 = *argp;
5145         }
5146         {
5147             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_absyn,0) < 0) {
5148                 SWIG_croak("Type error in argument 2 of data1_getelementbytagname. Expected _p_data1_absyn");
5149             }
5150         }
5151         {
5152             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_element,0) < 0) {
5153                 SWIG_croak("Type error in argument 3 of data1_getelementbytagname. Expected _p_data1_element");
5154             }
5155         }
5156         if (!SvOK((SV*) ST(3))) arg4 = 0;
5157         else arg4 = (char *) SvPV(ST(3), PL_na);
5158         result = (data1_element *)data1_getelementbytagname(arg1,arg2,arg3,(char const *)arg4);
5159
5160         ST(argvi) = sv_newmortal();
5161         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_element,0);
5162         XSRETURN(argvi);
5163         fail:
5164         (void) _swigerr;
5165     }
5166     croak(_swigerr);
5167 }
5168
5169
5170 XS(_wrap_data1_nodetogr) {
5171     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5172     const char *_swigerr = _swigmsg;
5173     {
5174         data1_handle arg1 ;
5175         data1_node *arg2 ;
5176         int arg3 ;
5177         ODR arg4 ;
5178         int *arg5 ;
5179         Z_GenericRecord *result;
5180         int argvi = 0;
5181         dXSARGS;
5182
5183         if ((items < 5) || (items > 5)) {
5184             SWIG_croak("Usage: data1_nodetogr(dh,n,select,o,len);");
5185         }
5186         {
5187             data1_handle * argp;
5188             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5189                 SWIG_croak("Type error in argument 1 of data1_nodetogr. Expected _p_data1_handle");
5190             }
5191             arg1 = *argp;
5192         }
5193         {
5194             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5195                 SWIG_croak("Type error in argument 2 of data1_nodetogr. Expected _p_data1_node");
5196             }
5197         }
5198         arg3 = (int) SvIV(ST(2));
5199         {
5200             ODR * argp;
5201             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
5202                 SWIG_croak("Type error in argument 4 of data1_nodetogr. Expected _p_ODR");
5203             }
5204             arg4 = *argp;
5205         }
5206         {
5207             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_int,0) < 0) {
5208                 SWIG_croak("Type error in argument 5 of data1_nodetogr. Expected _p_int");
5209             }
5210         }
5211         result = (Z_GenericRecord *)data1_nodetogr(arg1,arg2,arg3,arg4,arg5);
5212
5213         ST(argvi) = sv_newmortal();
5214         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_GenericRecord,0);
5215         XSRETURN(argvi);
5216         fail:
5217         (void) _swigerr;
5218     }
5219     croak(_swigerr);
5220 }
5221
5222
5223 XS(_wrap_data1_gettagbyname) {
5224     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5225     const char *_swigerr = _swigmsg;
5226     {
5227         data1_handle arg1 ;
5228         data1_tagset *arg2 ;
5229         char *arg3 ;
5230         data1_tag *result;
5231         int argvi = 0;
5232         dXSARGS;
5233
5234         if ((items < 3) || (items > 3)) {
5235             SWIG_croak("Usage: data1_gettagbyname(dh,s,name);");
5236         }
5237         {
5238             data1_handle * argp;
5239             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5240                 SWIG_croak("Type error in argument 1 of data1_gettagbyname. Expected _p_data1_handle");
5241             }
5242             arg1 = *argp;
5243         }
5244         {
5245             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_tagset,0) < 0) {
5246                 SWIG_croak("Type error in argument 2 of data1_gettagbyname. Expected _p_data1_tagset");
5247             }
5248         }
5249         if (!SvOK((SV*) ST(2))) arg3 = 0;
5250         else arg3 = (char *) SvPV(ST(2), PL_na);
5251         result = (data1_tag *)data1_gettagbyname(arg1,arg2,(char const *)arg3);
5252
5253         ST(argvi) = sv_newmortal();
5254         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_tag,0);
5255         XSRETURN(argvi);
5256         fail:
5257         (void) _swigerr;
5258     }
5259     croak(_swigerr);
5260 }
5261
5262
5263 XS(_wrap_data1_free_tree) {
5264     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5265     const char *_swigerr = _swigmsg;
5266     {
5267         data1_handle arg1 ;
5268         data1_node *arg2 ;
5269         int argvi = 0;
5270         dXSARGS;
5271
5272         if ((items < 2) || (items > 2)) {
5273             SWIG_croak("Usage: data1_free_tree(dh,t);");
5274         }
5275         {
5276             data1_handle * argp;
5277             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5278                 SWIG_croak("Type error in argument 1 of data1_free_tree. Expected _p_data1_handle");
5279             }
5280             arg1 = *argp;
5281         }
5282         {
5283             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5284                 SWIG_croak("Type error in argument 2 of data1_free_tree. Expected _p_data1_node");
5285             }
5286         }
5287         data1_free_tree(arg1,arg2);
5288
5289
5290         XSRETURN(argvi);
5291         fail:
5292         (void) _swigerr;
5293     }
5294     croak(_swigerr);
5295 }
5296
5297
5298 XS(_wrap_data1_nodetobuf) {
5299     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5300     const char *_swigerr = _swigmsg;
5301     {
5302         data1_handle arg1 ;
5303         data1_node *arg2 ;
5304         int arg3 ;
5305         int *arg4 ;
5306         char *result;
5307         int argvi = 0;
5308         dXSARGS;
5309
5310         if ((items < 4) || (items > 4)) {
5311             SWIG_croak("Usage: data1_nodetobuf(dh,n,select,len);");
5312         }
5313         {
5314             data1_handle * argp;
5315             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5316                 SWIG_croak("Type error in argument 1 of data1_nodetobuf. Expected _p_data1_handle");
5317             }
5318             arg1 = *argp;
5319         }
5320         {
5321             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5322                 SWIG_croak("Type error in argument 2 of data1_nodetobuf. Expected _p_data1_node");
5323             }
5324         }
5325         arg3 = (int) SvIV(ST(2));
5326         {
5327             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_int,0) < 0) {
5328                 SWIG_croak("Type error in argument 4 of data1_nodetobuf. Expected _p_int");
5329             }
5330         }
5331         result = (char *)data1_nodetobuf(arg1,arg2,arg3,arg4);
5332
5333         ST(argvi) = sv_newmortal();
5334         if (result) {
5335             sv_setpv((SV*)ST(argvi++), (char *) result);
5336         }else {
5337             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
5338         }
5339         XSRETURN(argvi);
5340         fail:
5341         (void) _swigerr;
5342     }
5343     croak(_swigerr);
5344 }
5345
5346
5347 XS(_wrap_data1_mk_tag_data_wd) {
5348     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5349     const char *_swigerr = _swigmsg;
5350     {
5351         data1_handle arg1 ;
5352         data1_node *arg2 ;
5353         char *arg3 ;
5354         NMEM arg4 ;
5355         data1_node *result;
5356         int argvi = 0;
5357         dXSARGS;
5358
5359         if ((items < 4) || (items > 4)) {
5360             SWIG_croak("Usage: data1_mk_tag_data_wd(dh,at,tagname,m);");
5361         }
5362         {
5363             data1_handle * argp;
5364             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5365                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_wd. Expected _p_data1_handle");
5366             }
5367             arg1 = *argp;
5368         }
5369         {
5370             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5371                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_wd. Expected _p_data1_node");
5372             }
5373         }
5374         if (!SvOK((SV*) ST(2))) arg3 = 0;
5375         else arg3 = (char *) SvPV(ST(2), PL_na);
5376         {
5377             NMEM * argp;
5378             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5379                 SWIG_croak("Type error in argument 4 of data1_mk_tag_data_wd. Expected _p_NMEM");
5380             }
5381             arg4 = *argp;
5382         }
5383         result = (data1_node *)data1_mk_tag_data_wd(arg1,arg2,(char const *)arg3,arg4);
5384
5385         ST(argvi) = sv_newmortal();
5386         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5387         XSRETURN(argvi);
5388         fail:
5389         (void) _swigerr;
5390     }
5391     croak(_swigerr);
5392 }
5393
5394
5395 XS(_wrap_data1_mk_tag_data) {
5396     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5397     const char *_swigerr = _swigmsg;
5398     {
5399         data1_handle arg1 ;
5400         data1_node *arg2 ;
5401         char *arg3 ;
5402         NMEM arg4 ;
5403         data1_node *result;
5404         int argvi = 0;
5405         dXSARGS;
5406
5407         if ((items < 4) || (items > 4)) {
5408             SWIG_croak("Usage: data1_mk_tag_data(dh,at,tagname,m);");
5409         }
5410         {
5411             data1_handle * argp;
5412             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5413                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data. Expected _p_data1_handle");
5414             }
5415             arg1 = *argp;
5416         }
5417         {
5418             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5419                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data. Expected _p_data1_node");
5420             }
5421         }
5422         if (!SvOK((SV*) ST(2))) arg3 = 0;
5423         else arg3 = (char *) SvPV(ST(2), PL_na);
5424         {
5425             NMEM * argp;
5426             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5427                 SWIG_croak("Type error in argument 4 of data1_mk_tag_data. Expected _p_NMEM");
5428             }
5429             arg4 = *argp;
5430         }
5431         result = (data1_node *)data1_mk_tag_data(arg1,arg2,(char const *)arg3,arg4);
5432
5433         ST(argvi) = sv_newmortal();
5434         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5435         XSRETURN(argvi);
5436         fail:
5437         (void) _swigerr;
5438     }
5439     croak(_swigerr);
5440 }
5441
5442
5443 XS(_wrap_data1_maptype) {
5444     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5445     const char *_swigerr = _swigmsg;
5446     {
5447         data1_handle arg1 ;
5448         char *arg2 ;
5449         int result;
5450         int argvi = 0;
5451         dXSARGS;
5452
5453         if ((items < 2) || (items > 2)) {
5454             SWIG_croak("Usage: data1_maptype(dh,t);");
5455         }
5456         {
5457             data1_handle * argp;
5458             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5459                 SWIG_croak("Type error in argument 1 of data1_maptype. Expected _p_data1_handle");
5460             }
5461             arg1 = *argp;
5462         }
5463         if (!SvOK((SV*) ST(1))) arg2 = 0;
5464         else arg2 = (char *) SvPV(ST(1), PL_na);
5465         result = (int)data1_maptype(arg1,arg2);
5466
5467         ST(argvi) = sv_newmortal();
5468         sv_setiv(ST(argvi++), (IV) result);
5469         XSRETURN(argvi);
5470         fail:
5471         (void) _swigerr;
5472     }
5473     croak(_swigerr);
5474 }
5475
5476
5477 XS(_wrap_data1_read_varset) {
5478     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5479     const char *_swigerr = _swigmsg;
5480     {
5481         data1_handle arg1 ;
5482         char *arg2 ;
5483         data1_varset *result;
5484         int argvi = 0;
5485         dXSARGS;
5486
5487         if ((items < 2) || (items > 2)) {
5488             SWIG_croak("Usage: data1_read_varset(dh,file);");
5489         }
5490         {
5491             data1_handle * argp;
5492             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5493                 SWIG_croak("Type error in argument 1 of data1_read_varset. Expected _p_data1_handle");
5494             }
5495             arg1 = *argp;
5496         }
5497         if (!SvOK((SV*) ST(1))) arg2 = 0;
5498         else arg2 = (char *) SvPV(ST(1), PL_na);
5499         result = (data1_varset *)data1_read_varset(arg1,(char const *)arg2);
5500
5501         ST(argvi) = sv_newmortal();
5502         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_varset,0);
5503         XSRETURN(argvi);
5504         fail:
5505         (void) _swigerr;
5506     }
5507     croak(_swigerr);
5508 }
5509
5510
5511 XS(_wrap_data1_getvartypebyct) {
5512     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5513     const char *_swigerr = _swigmsg;
5514     {
5515         data1_handle arg1 ;
5516         data1_varset *arg2 ;
5517         char *arg3 ;
5518         char *arg4 ;
5519         data1_vartype *result;
5520         int argvi = 0;
5521         dXSARGS;
5522
5523         if ((items < 4) || (items > 4)) {
5524             SWIG_croak("Usage: data1_getvartypebyct(dh,set,zclass,type);");
5525         }
5526         {
5527             data1_handle * argp;
5528             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5529                 SWIG_croak("Type error in argument 1 of data1_getvartypebyct. Expected _p_data1_handle");
5530             }
5531             arg1 = *argp;
5532         }
5533         {
5534             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_varset,0) < 0) {
5535                 SWIG_croak("Type error in argument 2 of data1_getvartypebyct. Expected _p_data1_varset");
5536             }
5537         }
5538         if (!SvOK((SV*) ST(2))) arg3 = 0;
5539         else arg3 = (char *) SvPV(ST(2), PL_na);
5540         if (!SvOK((SV*) ST(3))) arg4 = 0;
5541         else arg4 = (char *) SvPV(ST(3), PL_na);
5542         result = (data1_vartype *)data1_getvartypebyct(arg1,arg2,arg3,arg4);
5543
5544         ST(argvi) = sv_newmortal();
5545         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_vartype,0);
5546         XSRETURN(argvi);
5547         fail:
5548         (void) _swigerr;
5549     }
5550     croak(_swigerr);
5551 }
5552
5553
5554 XS(_wrap_data1_read_espec1) {
5555     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5556     const char *_swigerr = _swigmsg;
5557     {
5558         data1_handle arg1 ;
5559         char *arg2 ;
5560         Z_Espec1 *result;
5561         int argvi = 0;
5562         dXSARGS;
5563
5564         if ((items < 2) || (items > 2)) {
5565             SWIG_croak("Usage: data1_read_espec1(dh,file);");
5566         }
5567         {
5568             data1_handle * argp;
5569             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5570                 SWIG_croak("Type error in argument 1 of data1_read_espec1. Expected _p_data1_handle");
5571             }
5572             arg1 = *argp;
5573         }
5574         if (!SvOK((SV*) ST(1))) arg2 = 0;
5575         else arg2 = (char *) SvPV(ST(1), PL_na);
5576         result = (Z_Espec1 *)data1_read_espec1(arg1,(char const *)arg2);
5577
5578         ST(argvi) = sv_newmortal();
5579         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_Espec1,0);
5580         XSRETURN(argvi);
5581         fail:
5582         (void) _swigerr;
5583     }
5584     croak(_swigerr);
5585 }
5586
5587
5588 XS(_wrap_data1_doespec1) {
5589     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5590     const char *_swigerr = _swigmsg;
5591     {
5592         data1_handle arg1 ;
5593         data1_node *arg2 ;
5594         Z_Espec1 *arg3 ;
5595         int result;
5596         int argvi = 0;
5597         dXSARGS;
5598
5599         if ((items < 3) || (items > 3)) {
5600             SWIG_croak("Usage: data1_doespec1(dh,n,e);");
5601         }
5602         {
5603             data1_handle * argp;
5604             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5605                 SWIG_croak("Type error in argument 1 of data1_doespec1. Expected _p_data1_handle");
5606             }
5607             arg1 = *argp;
5608         }
5609         {
5610             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
5611                 SWIG_croak("Type error in argument 2 of data1_doespec1. Expected _p_data1_node");
5612             }
5613         }
5614         {
5615             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_Z_Espec1,0) < 0) {
5616                 SWIG_croak("Type error in argument 3 of data1_doespec1. Expected _p_Z_Espec1");
5617             }
5618         }
5619         result = (int)data1_doespec1(arg1,arg2,arg3);
5620
5621         ST(argvi) = sv_newmortal();
5622         sv_setiv(ST(argvi++), (IV) result);
5623         XSRETURN(argvi);
5624         fail:
5625         (void) _swigerr;
5626     }
5627     croak(_swigerr);
5628 }
5629
5630
5631 XS(_wrap_data1_getesetbyname) {
5632     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5633     const char *_swigerr = _swigmsg;
5634     {
5635         data1_handle arg1 ;
5636         data1_absyn *arg2 ;
5637         char *arg3 ;
5638         data1_esetname *result;
5639         int argvi = 0;
5640         dXSARGS;
5641
5642         if ((items < 3) || (items > 3)) {
5643             SWIG_croak("Usage: data1_getesetbyname(dh,a,name);");
5644         }
5645         {
5646             data1_handle * argp;
5647             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5648                 SWIG_croak("Type error in argument 1 of data1_getesetbyname. Expected _p_data1_handle");
5649             }
5650             arg1 = *argp;
5651         }
5652         {
5653             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_absyn,0) < 0) {
5654                 SWIG_croak("Type error in argument 2 of data1_getesetbyname. Expected _p_data1_absyn");
5655             }
5656         }
5657         if (!SvOK((SV*) ST(2))) arg3 = 0;
5658         else arg3 = (char *) SvPV(ST(2), PL_na);
5659         result = (data1_esetname *)data1_getesetbyname(arg1,arg2,(char const *)arg3);
5660
5661         ST(argvi) = sv_newmortal();
5662         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_esetname,0);
5663         XSRETURN(argvi);
5664         fail:
5665         (void) _swigerr;
5666     }
5667     croak(_swigerr);
5668 }
5669
5670
5671 XS(_wrap_data1_getelementbyname) {
5672     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5673     const char *_swigerr = _swigmsg;
5674     {
5675         data1_handle arg1 ;
5676         data1_absyn *arg2 ;
5677         char *arg3 ;
5678         data1_element *result;
5679         int argvi = 0;
5680         dXSARGS;
5681
5682         if ((items < 3) || (items > 3)) {
5683             SWIG_croak("Usage: data1_getelementbyname(dh,absyn,name);");
5684         }
5685         {
5686             data1_handle * argp;
5687             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5688                 SWIG_croak("Type error in argument 1 of data1_getelementbyname. Expected _p_data1_handle");
5689             }
5690             arg1 = *argp;
5691         }
5692         {
5693             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_absyn,0) < 0) {
5694                 SWIG_croak("Type error in argument 2 of data1_getelementbyname. Expected _p_data1_absyn");
5695             }
5696         }
5697         if (!SvOK((SV*) ST(2))) arg3 = 0;
5698         else arg3 = (char *) SvPV(ST(2), PL_na);
5699         result = (data1_element *)data1_getelementbyname(arg1,arg2,(char const *)arg3);
5700
5701         ST(argvi) = sv_newmortal();
5702         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_element,0);
5703         XSRETURN(argvi);
5704         fail:
5705         (void) _swigerr;
5706     }
5707     croak(_swigerr);
5708 }
5709
5710
5711 XS(_wrap_data1_mk_node2) {
5712     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5713     const char *_swigerr = _swigmsg;
5714     {
5715         data1_handle arg1 ;
5716         NMEM arg2 ;
5717         int arg3 ;
5718         data1_node *arg4 ;
5719         data1_node *result;
5720         int argvi = 0;
5721         dXSARGS;
5722
5723         if ((items < 4) || (items > 4)) {
5724             SWIG_croak("Usage: data1_mk_node2(dh,m,type,parent);");
5725         }
5726         {
5727             data1_handle * argp;
5728             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5729                 SWIG_croak("Type error in argument 1 of data1_mk_node2. Expected _p_data1_handle");
5730             }
5731             arg1 = *argp;
5732         }
5733         {
5734             NMEM * argp;
5735             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5736                 SWIG_croak("Type error in argument 2 of data1_mk_node2. Expected _p_NMEM");
5737             }
5738             arg2 = *argp;
5739         }
5740         arg3 = (int) SvIV(ST(2));
5741         {
5742             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
5743                 SWIG_croak("Type error in argument 4 of data1_mk_node2. Expected _p_data1_node");
5744             }
5745         }
5746         result = (data1_node *)data1_mk_node2(arg1,arg2,arg3,arg4);
5747
5748         ST(argvi) = sv_newmortal();
5749         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5750         XSRETURN(argvi);
5751         fail:
5752         (void) _swigerr;
5753     }
5754     croak(_swigerr);
5755 }
5756
5757
5758 XS(_wrap_data1_mk_tag) {
5759     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5760     const char *_swigerr = _swigmsg;
5761     {
5762         data1_handle arg1 ;
5763         NMEM arg2 ;
5764         char *arg3 ;
5765         char **arg4 ;
5766         data1_node *arg5 ;
5767         data1_node *result;
5768         int argvi = 0;
5769         dXSARGS;
5770
5771         if ((items < 5) || (items > 5)) {
5772             SWIG_croak("Usage: data1_mk_tag(dh,nmem,tag,attr,at);");
5773         }
5774         {
5775             data1_handle * argp;
5776             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5777                 SWIG_croak("Type error in argument 1 of data1_mk_tag. Expected _p_data1_handle");
5778             }
5779             arg1 = *argp;
5780         }
5781         {
5782             NMEM * argp;
5783             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5784                 SWIG_croak("Type error in argument 2 of data1_mk_tag. Expected _p_NMEM");
5785             }
5786             arg2 = *argp;
5787         }
5788         if (!SvOK((SV*) ST(2))) arg3 = 0;
5789         else arg3 = (char *) SvPV(ST(2), PL_na);
5790         {
5791             AV *tempav;
5792             I32 len;
5793             int i;
5794             SV  **tv;
5795             STRLEN na;
5796             if (!SvROK(ST(3)))
5797             croak("Argument 4 is not a reference.");
5798             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
5799             croak("Argument 4 is not an array.");
5800             tempav = (AV*)SvRV(ST(3));
5801             len = av_len(tempav);
5802             arg4 = (char **) malloc((len+2)*sizeof(char *));
5803             for (i = 0; i <= len; i++) {
5804                 tv = av_fetch(tempav, i, 0);
5805                 arg4[i] = (char *) SvPV(*tv,na);
5806             }
5807             arg4[i] = NULL;
5808         }
5809         {
5810             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
5811                 SWIG_croak("Type error in argument 5 of data1_mk_tag. Expected _p_data1_node");
5812             }
5813         }
5814         result = (data1_node *)data1_mk_tag(arg1,arg2,(char const *)arg3,(char const **)arg4,arg5);
5815
5816         ST(argvi) = sv_newmortal();
5817         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5818         {
5819             free(arg4);
5820         }
5821         XSRETURN(argvi);
5822         fail:
5823         {
5824             free(arg4);
5825         }
5826         (void) _swigerr;
5827     }
5828     croak(_swigerr);
5829 }
5830
5831
5832 XS(_wrap_data1_mk_tag_n) {
5833     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5834     const char *_swigerr = _swigmsg;
5835     {
5836         data1_handle arg1 ;
5837         NMEM arg2 ;
5838         char *arg3 ;
5839         size_t arg4 ;
5840         char **arg5 ;
5841         data1_node *arg6 ;
5842         data1_node *result;
5843         int argvi = 0;
5844         dXSARGS;
5845
5846         if ((items < 6) || (items > 6)) {
5847             SWIG_croak("Usage: data1_mk_tag_n(dh,nmem,tag,len,attr,at);");
5848         }
5849         {
5850             data1_handle * argp;
5851             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5852                 SWIG_croak("Type error in argument 1 of data1_mk_tag_n. Expected _p_data1_handle");
5853             }
5854             arg1 = *argp;
5855         }
5856         {
5857             NMEM * argp;
5858             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
5859                 SWIG_croak("Type error in argument 2 of data1_mk_tag_n. Expected _p_NMEM");
5860             }
5861             arg2 = *argp;
5862         }
5863         if (!SvOK((SV*) ST(2))) arg3 = 0;
5864         else arg3 = (char *) SvPV(ST(2), PL_na);
5865         arg4 = (size_t) SvUV(ST(3));
5866         {
5867             AV *tempav;
5868             I32 len;
5869             int i;
5870             SV  **tv;
5871             STRLEN na;
5872             if (!SvROK(ST(4)))
5873             croak("Argument 5 is not a reference.");
5874             if (SvTYPE(SvRV(ST(4))) != SVt_PVAV)
5875             croak("Argument 5 is not an array.");
5876             tempav = (AV*)SvRV(ST(4));
5877             len = av_len(tempav);
5878             arg5 = (char **) malloc((len+2)*sizeof(char *));
5879             for (i = 0; i <= len; i++) {
5880                 tv = av_fetch(tempav, i, 0);
5881                 arg5[i] = (char *) SvPV(*tv,na);
5882             }
5883             arg5[i] = NULL;
5884         }
5885         {
5886             if (SWIG_ConvertPtr(ST(5), (void **) &arg6, SWIGTYPE_p_data1_node,0) < 0) {
5887                 SWIG_croak("Type error in argument 6 of data1_mk_tag_n. Expected _p_data1_node");
5888             }
5889         }
5890         result = (data1_node *)data1_mk_tag_n(arg1,arg2,(char const *)arg3,arg4,(char const **)arg5,arg6);
5891
5892         ST(argvi) = sv_newmortal();
5893         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
5894         {
5895             free(arg5);
5896         }
5897         XSRETURN(argvi);
5898         fail:
5899         {
5900             free(arg5);
5901         }
5902         (void) _swigerr;
5903     }
5904     croak(_swigerr);
5905 }
5906
5907
5908 XS(_wrap_data1_tag_add_attr) {
5909     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5910     const char *_swigerr = _swigmsg;
5911     {
5912         data1_handle arg1 ;
5913         NMEM arg2 ;
5914         data1_node *arg3 ;
5915         char **arg4 ;
5916         int argvi = 0;
5917         dXSARGS;
5918
5919         if ((items < 4) || (items > 4)) {
5920             SWIG_croak("Usage: data1_tag_add_attr(dh,nmem,res,attr);");
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_tag_add_attr. 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_tag_add_attr. Expected _p_NMEM");
5933             }
5934             arg2 = *argp;
5935         }
5936         {
5937             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_node,0) < 0) {
5938                 SWIG_croak("Type error in argument 3 of data1_tag_add_attr. Expected _p_data1_node");
5939             }
5940         }
5941         {
5942             AV *tempav;
5943             I32 len;
5944             int i;
5945             SV  **tv;
5946             STRLEN na;
5947             if (!SvROK(ST(3)))
5948             croak("Argument 4 is not a reference.");
5949             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
5950             croak("Argument 4 is not an array.");
5951             tempav = (AV*)SvRV(ST(3));
5952             len = av_len(tempav);
5953             arg4 = (char **) malloc((len+2)*sizeof(char *));
5954             for (i = 0; i <= len; i++) {
5955                 tv = av_fetch(tempav, i, 0);
5956                 arg4[i] = (char *) SvPV(*tv,na);
5957             }
5958             arg4[i] = NULL;
5959         }
5960         data1_tag_add_attr(arg1,arg2,arg3,(char const **)arg4);
5961
5962
5963         {
5964             free(arg4);
5965         }
5966         XSRETURN(argvi);
5967         fail:
5968         {
5969             free(arg4);
5970         }
5971         (void) _swigerr;
5972     }
5973     croak(_swigerr);
5974 }
5975
5976
5977 XS(_wrap_data1_mk_text_n) {
5978     char _swigmsg[SWIG_MAX_ERRMSG] = "";
5979     const char *_swigerr = _swigmsg;
5980     {
5981         data1_handle arg1 ;
5982         NMEM arg2 ;
5983         char *arg3 ;
5984         size_t arg4 ;
5985         data1_node *arg5 ;
5986         data1_node *result;
5987         int argvi = 0;
5988         dXSARGS;
5989
5990         if ((items < 5) || (items > 5)) {
5991             SWIG_croak("Usage: data1_mk_text_n(dh,mem,buf,len,parent);");
5992         }
5993         {
5994             data1_handle * argp;
5995             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
5996                 SWIG_croak("Type error in argument 1 of data1_mk_text_n. Expected _p_data1_handle");
5997             }
5998             arg1 = *argp;
5999         }
6000         {
6001             NMEM * argp;
6002             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6003                 SWIG_croak("Type error in argument 2 of data1_mk_text_n. Expected _p_NMEM");
6004             }
6005             arg2 = *argp;
6006         }
6007         if (!SvOK((SV*) ST(2))) arg3 = 0;
6008         else arg3 = (char *) SvPV(ST(2), PL_na);
6009         arg4 = (size_t) SvUV(ST(3));
6010         {
6011             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6012                 SWIG_croak("Type error in argument 5 of data1_mk_text_n. Expected _p_data1_node");
6013             }
6014         }
6015         result = (data1_node *)data1_mk_text_n(arg1,arg2,(char const *)arg3,arg4,arg5);
6016
6017         ST(argvi) = sv_newmortal();
6018         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6019         XSRETURN(argvi);
6020         fail:
6021         (void) _swigerr;
6022     }
6023     croak(_swigerr);
6024 }
6025
6026
6027 XS(_wrap_data1_mk_text_nf) {
6028     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6029     const char *_swigerr = _swigmsg;
6030     {
6031         data1_handle arg1 ;
6032         NMEM arg2 ;
6033         char *arg3 ;
6034         size_t arg4 ;
6035         data1_node *arg5 ;
6036         data1_node *result;
6037         int argvi = 0;
6038         dXSARGS;
6039
6040         if ((items < 5) || (items > 5)) {
6041             SWIG_croak("Usage: data1_mk_text_nf(dh,mem,buf,len,parent);");
6042         }
6043         {
6044             data1_handle * argp;
6045             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6046                 SWIG_croak("Type error in argument 1 of data1_mk_text_nf. Expected _p_data1_handle");
6047             }
6048             arg1 = *argp;
6049         }
6050         {
6051             NMEM * argp;
6052             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6053                 SWIG_croak("Type error in argument 2 of data1_mk_text_nf. Expected _p_NMEM");
6054             }
6055             arg2 = *argp;
6056         }
6057         if (!SvOK((SV*) ST(2))) arg3 = 0;
6058         else arg3 = (char *) SvPV(ST(2), PL_na);
6059         arg4 = (size_t) SvUV(ST(3));
6060         {
6061             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6062                 SWIG_croak("Type error in argument 5 of data1_mk_text_nf. Expected _p_data1_node");
6063             }
6064         }
6065         result = (data1_node *)data1_mk_text_nf(arg1,arg2,(char const *)arg3,arg4,arg5);
6066
6067         ST(argvi) = sv_newmortal();
6068         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6069         XSRETURN(argvi);
6070         fail:
6071         (void) _swigerr;
6072     }
6073     croak(_swigerr);
6074 }
6075
6076
6077 XS(_wrap_data1_mk_text) {
6078     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6079     const char *_swigerr = _swigmsg;
6080     {
6081         data1_handle arg1 ;
6082         NMEM arg2 ;
6083         char *arg3 ;
6084         data1_node *arg4 ;
6085         data1_node *result;
6086         int argvi = 0;
6087         dXSARGS;
6088
6089         if ((items < 4) || (items > 4)) {
6090             SWIG_croak("Usage: data1_mk_text(dh,mem,buf,parent);");
6091         }
6092         {
6093             data1_handle * argp;
6094             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6095                 SWIG_croak("Type error in argument 1 of data1_mk_text. Expected _p_data1_handle");
6096             }
6097             arg1 = *argp;
6098         }
6099         {
6100             NMEM * argp;
6101             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6102                 SWIG_croak("Type error in argument 2 of data1_mk_text. Expected _p_NMEM");
6103             }
6104             arg2 = *argp;
6105         }
6106         if (!SvOK((SV*) ST(2))) arg3 = 0;
6107         else arg3 = (char *) SvPV(ST(2), PL_na);
6108         {
6109             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
6110                 SWIG_croak("Type error in argument 4 of data1_mk_text. Expected _p_data1_node");
6111             }
6112         }
6113         result = (data1_node *)data1_mk_text(arg1,arg2,(char const *)arg3,arg4);
6114
6115         ST(argvi) = sv_newmortal();
6116         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6117         XSRETURN(argvi);
6118         fail:
6119         (void) _swigerr;
6120     }
6121     croak(_swigerr);
6122 }
6123
6124
6125 XS(_wrap_data1_mk_comment_n) {
6126     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6127     const char *_swigerr = _swigmsg;
6128     {
6129         data1_handle arg1 ;
6130         NMEM arg2 ;
6131         char *arg3 ;
6132         size_t arg4 ;
6133         data1_node *arg5 ;
6134         data1_node *result;
6135         int argvi = 0;
6136         dXSARGS;
6137
6138         if ((items < 5) || (items > 5)) {
6139             SWIG_croak("Usage: data1_mk_comment_n(dh,mem,buf,len,parent);");
6140         }
6141         {
6142             data1_handle * argp;
6143             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6144                 SWIG_croak("Type error in argument 1 of data1_mk_comment_n. Expected _p_data1_handle");
6145             }
6146             arg1 = *argp;
6147         }
6148         {
6149             NMEM * argp;
6150             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6151                 SWIG_croak("Type error in argument 2 of data1_mk_comment_n. Expected _p_NMEM");
6152             }
6153             arg2 = *argp;
6154         }
6155         if (!SvOK((SV*) ST(2))) arg3 = 0;
6156         else arg3 = (char *) SvPV(ST(2), PL_na);
6157         arg4 = (size_t) SvUV(ST(3));
6158         {
6159             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6160                 SWIG_croak("Type error in argument 5 of data1_mk_comment_n. Expected _p_data1_node");
6161             }
6162         }
6163         result = (data1_node *)data1_mk_comment_n(arg1,arg2,(char const *)arg3,arg4,arg5);
6164
6165         ST(argvi) = sv_newmortal();
6166         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6167         XSRETURN(argvi);
6168         fail:
6169         (void) _swigerr;
6170     }
6171     croak(_swigerr);
6172 }
6173
6174
6175 XS(_wrap_data1_mk_comment) {
6176     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6177     const char *_swigerr = _swigmsg;
6178     {
6179         data1_handle arg1 ;
6180         NMEM arg2 ;
6181         char *arg3 ;
6182         data1_node *arg4 ;
6183         data1_node *result;
6184         int argvi = 0;
6185         dXSARGS;
6186
6187         if ((items < 4) || (items > 4)) {
6188             SWIG_croak("Usage: data1_mk_comment(dh,mem,buf,parent);");
6189         }
6190         {
6191             data1_handle * argp;
6192             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6193                 SWIG_croak("Type error in argument 1 of data1_mk_comment. Expected _p_data1_handle");
6194             }
6195             arg1 = *argp;
6196         }
6197         {
6198             NMEM * argp;
6199             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6200                 SWIG_croak("Type error in argument 2 of data1_mk_comment. Expected _p_NMEM");
6201             }
6202             arg2 = *argp;
6203         }
6204         if (!SvOK((SV*) ST(2))) arg3 = 0;
6205         else arg3 = (char *) SvPV(ST(2), PL_na);
6206         {
6207             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
6208                 SWIG_croak("Type error in argument 4 of data1_mk_comment. Expected _p_data1_node");
6209             }
6210         }
6211         result = (data1_node *)data1_mk_comment(arg1,arg2,(char const *)arg3,arg4);
6212
6213         ST(argvi) = sv_newmortal();
6214         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6215         XSRETURN(argvi);
6216         fail:
6217         (void) _swigerr;
6218     }
6219     croak(_swigerr);
6220 }
6221
6222
6223 XS(_wrap_data1_mk_preprocess) {
6224     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6225     const char *_swigerr = _swigmsg;
6226     {
6227         data1_handle arg1 ;
6228         NMEM arg2 ;
6229         char *arg3 ;
6230         char **arg4 ;
6231         data1_node *arg5 ;
6232         data1_node *result;
6233         int argvi = 0;
6234         dXSARGS;
6235
6236         if ((items < 5) || (items > 5)) {
6237             SWIG_croak("Usage: data1_mk_preprocess(dh,nmem,target,attr,at);");
6238         }
6239         {
6240             data1_handle * argp;
6241             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6242                 SWIG_croak("Type error in argument 1 of data1_mk_preprocess. Expected _p_data1_handle");
6243             }
6244             arg1 = *argp;
6245         }
6246         {
6247             NMEM * argp;
6248             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6249                 SWIG_croak("Type error in argument 2 of data1_mk_preprocess. Expected _p_NMEM");
6250             }
6251             arg2 = *argp;
6252         }
6253         if (!SvOK((SV*) ST(2))) arg3 = 0;
6254         else arg3 = (char *) SvPV(ST(2), PL_na);
6255         {
6256             AV *tempav;
6257             I32 len;
6258             int i;
6259             SV  **tv;
6260             STRLEN na;
6261             if (!SvROK(ST(3)))
6262             croak("Argument 4 is not a reference.");
6263             if (SvTYPE(SvRV(ST(3))) != SVt_PVAV)
6264             croak("Argument 4 is not an array.");
6265             tempav = (AV*)SvRV(ST(3));
6266             len = av_len(tempav);
6267             arg4 = (char **) malloc((len+2)*sizeof(char *));
6268             for (i = 0; i <= len; i++) {
6269                 tv = av_fetch(tempav, i, 0);
6270                 arg4[i] = (char *) SvPV(*tv,na);
6271             }
6272             arg4[i] = NULL;
6273         }
6274         {
6275             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_data1_node,0) < 0) {
6276                 SWIG_croak("Type error in argument 5 of data1_mk_preprocess. Expected _p_data1_node");
6277             }
6278         }
6279         result = (data1_node *)data1_mk_preprocess(arg1,arg2,(char const *)arg3,(char const **)arg4,arg5);
6280
6281         ST(argvi) = sv_newmortal();
6282         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6283         {
6284             free(arg4);
6285         }
6286         XSRETURN(argvi);
6287         fail:
6288         {
6289             free(arg4);
6290         }
6291         (void) _swigerr;
6292     }
6293     croak(_swigerr);
6294 }
6295
6296
6297 XS(_wrap_data1_mk_root) {
6298     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6299     const char *_swigerr = _swigmsg;
6300     {
6301         data1_handle arg1 ;
6302         NMEM arg2 ;
6303         char *arg3 ;
6304         data1_node *result;
6305         int argvi = 0;
6306         dXSARGS;
6307
6308         if ((items < 3) || (items > 3)) {
6309             SWIG_croak("Usage: data1_mk_root(dh,nmem,name);");
6310         }
6311         {
6312             data1_handle * argp;
6313             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6314                 SWIG_croak("Type error in argument 1 of data1_mk_root. Expected _p_data1_handle");
6315             }
6316             arg1 = *argp;
6317         }
6318         {
6319             NMEM * argp;
6320             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6321                 SWIG_croak("Type error in argument 2 of data1_mk_root. Expected _p_NMEM");
6322             }
6323             arg2 = *argp;
6324         }
6325         if (!SvOK((SV*) ST(2))) arg3 = 0;
6326         else arg3 = (char *) SvPV(ST(2), PL_na);
6327         result = (data1_node *)data1_mk_root(arg1,arg2,(char const *)arg3);
6328
6329         ST(argvi) = sv_newmortal();
6330         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6331         XSRETURN(argvi);
6332         fail:
6333         (void) _swigerr;
6334     }
6335     croak(_swigerr);
6336 }
6337
6338
6339 XS(_wrap_data1_set_root) {
6340     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6341     const char *_swigerr = _swigmsg;
6342     {
6343         data1_handle arg1 ;
6344         data1_node *arg2 ;
6345         NMEM arg3 ;
6346         char *arg4 ;
6347         int argvi = 0;
6348         dXSARGS;
6349
6350         if ((items < 4) || (items > 4)) {
6351             SWIG_croak("Usage: data1_set_root(dh,res,nmem,name);");
6352         }
6353         {
6354             data1_handle * argp;
6355             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6356                 SWIG_croak("Type error in argument 1 of data1_set_root. Expected _p_data1_handle");
6357             }
6358             arg1 = *argp;
6359         }
6360         {
6361             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6362                 SWIG_croak("Type error in argument 2 of data1_set_root. Expected _p_data1_node");
6363             }
6364         }
6365         {
6366             NMEM * argp;
6367             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6368                 SWIG_croak("Type error in argument 3 of data1_set_root. Expected _p_NMEM");
6369             }
6370             arg3 = *argp;
6371         }
6372         if (!SvOK((SV*) ST(3))) arg4 = 0;
6373         else arg4 = (char *) SvPV(ST(3), PL_na);
6374         data1_set_root(arg1,arg2,arg3,(char const *)arg4);
6375
6376
6377         XSRETURN(argvi);
6378         fail:
6379         (void) _swigerr;
6380     }
6381     croak(_swigerr);
6382 }
6383
6384
6385 XS(_wrap_data1_mk_tag_data_int) {
6386     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6387     const char *_swigerr = _swigmsg;
6388     {
6389         data1_handle arg1 ;
6390         data1_node *arg2 ;
6391         char *arg3 ;
6392         int arg4 ;
6393         NMEM arg5 ;
6394         data1_node *result;
6395         int argvi = 0;
6396         dXSARGS;
6397
6398         if ((items < 5) || (items > 5)) {
6399             SWIG_croak("Usage: data1_mk_tag_data_int(dh,at,tag,num,nmem);");
6400         }
6401         {
6402             data1_handle * argp;
6403             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6404                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_int. Expected _p_data1_handle");
6405             }
6406             arg1 = *argp;
6407         }
6408         {
6409             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6410                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_int. Expected _p_data1_node");
6411             }
6412         }
6413         if (!SvOK((SV*) ST(2))) arg3 = 0;
6414         else arg3 = (char *) SvPV(ST(2), PL_na);
6415         arg4 = (int) SvIV(ST(3));
6416         {
6417             NMEM * argp;
6418             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6419                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_int. Expected _p_NMEM");
6420             }
6421             arg5 = *argp;
6422         }
6423         result = (data1_node *)data1_mk_tag_data_int(arg1,arg2,(char const *)arg3,arg4,arg5);
6424
6425         ST(argvi) = sv_newmortal();
6426         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6427         XSRETURN(argvi);
6428         fail:
6429         (void) _swigerr;
6430     }
6431     croak(_swigerr);
6432 }
6433
6434
6435 XS(_wrap_data1_mk_tag_data_oid) {
6436     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6437     const char *_swigerr = _swigmsg;
6438     {
6439         data1_handle arg1 ;
6440         data1_node *arg2 ;
6441         char *arg3 ;
6442         Odr_oid *arg4 ;
6443         NMEM arg5 ;
6444         data1_node *result;
6445         int argvi = 0;
6446         dXSARGS;
6447
6448         if ((items < 5) || (items > 5)) {
6449             SWIG_croak("Usage: data1_mk_tag_data_oid(dh,at,tag,oid,nmem);");
6450         }
6451         {
6452             data1_handle * argp;
6453             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6454                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_oid. Expected _p_data1_handle");
6455             }
6456             arg1 = *argp;
6457         }
6458         {
6459             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6460                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_oid. Expected _p_data1_node");
6461             }
6462         }
6463         if (!SvOK((SV*) ST(2))) arg3 = 0;
6464         else arg3 = (char *) SvPV(ST(2), PL_na);
6465         {
6466             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_Odr_oid,0) < 0) {
6467                 SWIG_croak("Type error in argument 4 of data1_mk_tag_data_oid. Expected _p_Odr_oid");
6468             }
6469         }
6470         {
6471             NMEM * argp;
6472             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6473                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_oid. Expected _p_NMEM");
6474             }
6475             arg5 = *argp;
6476         }
6477         result = (data1_node *)data1_mk_tag_data_oid(arg1,arg2,(char const *)arg3,arg4,arg5);
6478
6479         ST(argvi) = sv_newmortal();
6480         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6481         XSRETURN(argvi);
6482         fail:
6483         (void) _swigerr;
6484     }
6485     croak(_swigerr);
6486 }
6487
6488
6489 XS(_wrap_data1_mk_tag_data_text) {
6490     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6491     const char *_swigerr = _swigmsg;
6492     {
6493         data1_handle arg1 ;
6494         data1_node *arg2 ;
6495         char *arg3 ;
6496         char *arg4 ;
6497         NMEM arg5 ;
6498         data1_node *result;
6499         int argvi = 0;
6500         dXSARGS;
6501
6502         if ((items < 5) || (items > 5)) {
6503             SWIG_croak("Usage: data1_mk_tag_data_text(dh,at,tag,str,nmem);");
6504         }
6505         {
6506             data1_handle * argp;
6507             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6508                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_text. Expected _p_data1_handle");
6509             }
6510             arg1 = *argp;
6511         }
6512         {
6513             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6514                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_text. Expected _p_data1_node");
6515             }
6516         }
6517         if (!SvOK((SV*) ST(2))) arg3 = 0;
6518         else arg3 = (char *) SvPV(ST(2), PL_na);
6519         if (!SvOK((SV*) ST(3))) arg4 = 0;
6520         else arg4 = (char *) SvPV(ST(3), PL_na);
6521         {
6522             NMEM * argp;
6523             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6524                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_text. Expected _p_NMEM");
6525             }
6526             arg5 = *argp;
6527         }
6528         result = (data1_node *)data1_mk_tag_data_text(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
6529
6530         ST(argvi) = sv_newmortal();
6531         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6532         XSRETURN(argvi);
6533         fail:
6534         (void) _swigerr;
6535     }
6536     croak(_swigerr);
6537 }
6538
6539
6540 XS(_wrap_data1_mk_tag_data_text_uni) {
6541     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6542     const char *_swigerr = _swigmsg;
6543     {
6544         data1_handle arg1 ;
6545         data1_node *arg2 ;
6546         char *arg3 ;
6547         char *arg4 ;
6548         NMEM arg5 ;
6549         data1_node *result;
6550         int argvi = 0;
6551         dXSARGS;
6552
6553         if ((items < 5) || (items > 5)) {
6554             SWIG_croak("Usage: data1_mk_tag_data_text_uni(dh,at,tag,str,nmem);");
6555         }
6556         {
6557             data1_handle * argp;
6558             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6559                 SWIG_croak("Type error in argument 1 of data1_mk_tag_data_text_uni. Expected _p_data1_handle");
6560             }
6561             arg1 = *argp;
6562         }
6563         {
6564             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6565                 SWIG_croak("Type error in argument 2 of data1_mk_tag_data_text_uni. Expected _p_data1_node");
6566             }
6567         }
6568         if (!SvOK((SV*) ST(2))) arg3 = 0;
6569         else arg3 = (char *) SvPV(ST(2), PL_na);
6570         if (!SvOK((SV*) ST(3))) arg4 = 0;
6571         else arg4 = (char *) SvPV(ST(3), PL_na);
6572         {
6573             NMEM * argp;
6574             if (SWIG_ConvertPtr(ST(4),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6575                 SWIG_croak("Type error in argument 5 of data1_mk_tag_data_text_uni. Expected _p_NMEM");
6576             }
6577             arg5 = *argp;
6578         }
6579         result = (data1_node *)data1_mk_tag_data_text_uni(arg1,arg2,(char const *)arg3,(char const *)arg4,arg5);
6580
6581         ST(argvi) = sv_newmortal();
6582         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6583         XSRETURN(argvi);
6584         fail:
6585         (void) _swigerr;
6586     }
6587     croak(_swigerr);
6588 }
6589
6590
6591 XS(_wrap_data1_get_absyn) {
6592     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6593     const char *_swigerr = _swigmsg;
6594     {
6595         data1_handle arg1 ;
6596         char *arg2 ;
6597         data1_absyn *result;
6598         int argvi = 0;
6599         dXSARGS;
6600
6601         if ((items < 2) || (items > 2)) {
6602             SWIG_croak("Usage: data1_get_absyn(dh,name);");
6603         }
6604         {
6605             data1_handle * argp;
6606             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6607                 SWIG_croak("Type error in argument 1 of data1_get_absyn. Expected _p_data1_handle");
6608             }
6609             arg1 = *argp;
6610         }
6611         if (!SvOK((SV*) ST(1))) arg2 = 0;
6612         else arg2 = (char *) SvPV(ST(1), PL_na);
6613         result = (data1_absyn *)data1_get_absyn(arg1,(char const *)arg2);
6614
6615         ST(argvi) = sv_newmortal();
6616         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_absyn,0);
6617         XSRETURN(argvi);
6618         fail:
6619         (void) _swigerr;
6620     }
6621     croak(_swigerr);
6622 }
6623
6624
6625 XS(_wrap_data1_search_tag) {
6626     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6627     const char *_swigerr = _swigmsg;
6628     {
6629         data1_handle arg1 ;
6630         data1_node *arg2 ;
6631         char *arg3 ;
6632         data1_node *result;
6633         int argvi = 0;
6634         dXSARGS;
6635
6636         if ((items < 3) || (items > 3)) {
6637             SWIG_croak("Usage: data1_search_tag(dh,n,tag);");
6638         }
6639         {
6640             data1_handle * argp;
6641             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6642                 SWIG_croak("Type error in argument 1 of data1_search_tag. Expected _p_data1_handle");
6643             }
6644             arg1 = *argp;
6645         }
6646         {
6647             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6648                 SWIG_croak("Type error in argument 2 of data1_search_tag. Expected _p_data1_node");
6649             }
6650         }
6651         if (!SvOK((SV*) ST(2))) arg3 = 0;
6652         else arg3 = (char *) SvPV(ST(2), PL_na);
6653         result = (data1_node *)data1_search_tag(arg1,arg2,(char const *)arg3);
6654
6655         ST(argvi) = sv_newmortal();
6656         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6657         XSRETURN(argvi);
6658         fail:
6659         (void) _swigerr;
6660     }
6661     croak(_swigerr);
6662 }
6663
6664
6665 XS(_wrap_data1_mk_tag_uni) {
6666     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6667     const char *_swigerr = _swigmsg;
6668     {
6669         data1_handle arg1 ;
6670         NMEM arg2 ;
6671         char *arg3 ;
6672         data1_node *arg4 ;
6673         data1_node *result;
6674         int argvi = 0;
6675         dXSARGS;
6676
6677         if ((items < 4) || (items > 4)) {
6678             SWIG_croak("Usage: data1_mk_tag_uni(dh,nmem,tag,at);");
6679         }
6680         {
6681             data1_handle * argp;
6682             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6683                 SWIG_croak("Type error in argument 1 of data1_mk_tag_uni. Expected _p_data1_handle");
6684             }
6685             arg1 = *argp;
6686         }
6687         {
6688             NMEM * argp;
6689             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6690                 SWIG_croak("Type error in argument 2 of data1_mk_tag_uni. Expected _p_NMEM");
6691             }
6692             arg2 = *argp;
6693         }
6694         if (!SvOK((SV*) ST(2))) arg3 = 0;
6695         else arg3 = (char *) SvPV(ST(2), PL_na);
6696         {
6697             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_data1_node,0) < 0) {
6698                 SWIG_croak("Type error in argument 4 of data1_mk_tag_uni. Expected _p_data1_node");
6699             }
6700         }
6701         result = (data1_node *)data1_mk_tag_uni(arg1,arg2,(char const *)arg3,arg4);
6702
6703         ST(argvi) = sv_newmortal();
6704         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6705         XSRETURN(argvi);
6706         fail:
6707         (void) _swigerr;
6708     }
6709     croak(_swigerr);
6710 }
6711
6712
6713 XS(_wrap_data1_get_attset) {
6714     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6715     const char *_swigerr = _swigmsg;
6716     {
6717         data1_handle arg1 ;
6718         char *arg2 ;
6719         data1_attset *result;
6720         int argvi = 0;
6721         dXSARGS;
6722
6723         if ((items < 2) || (items > 2)) {
6724             SWIG_croak("Usage: data1_get_attset(dh,name);");
6725         }
6726         {
6727             data1_handle * argp;
6728             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6729                 SWIG_croak("Type error in argument 1 of data1_get_attset. Expected _p_data1_handle");
6730             }
6731             arg1 = *argp;
6732         }
6733         if (!SvOK((SV*) ST(1))) arg2 = 0;
6734         else arg2 = (char *) SvPV(ST(1), PL_na);
6735         result = (data1_attset *)data1_get_attset(arg1,(char const *)arg2);
6736
6737         ST(argvi) = sv_newmortal();
6738         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_attset,0);
6739         XSRETURN(argvi);
6740         fail:
6741         (void) _swigerr;
6742     }
6743     croak(_swigerr);
6744 }
6745
6746
6747 XS(_wrap_data1_read_maptab) {
6748     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6749     const char *_swigerr = _swigmsg;
6750     {
6751         data1_handle arg1 ;
6752         char *arg2 ;
6753         data1_maptab *result;
6754         int argvi = 0;
6755         dXSARGS;
6756
6757         if ((items < 2) || (items > 2)) {
6758             SWIG_croak("Usage: data1_read_maptab(dh,file);");
6759         }
6760         {
6761             data1_handle * argp;
6762             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6763                 SWIG_croak("Type error in argument 1 of data1_read_maptab. Expected _p_data1_handle");
6764             }
6765             arg1 = *argp;
6766         }
6767         if (!SvOK((SV*) ST(1))) arg2 = 0;
6768         else arg2 = (char *) SvPV(ST(1), PL_na);
6769         result = (data1_maptab *)data1_read_maptab(arg1,(char const *)arg2);
6770
6771         ST(argvi) = sv_newmortal();
6772         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_maptab,0);
6773         XSRETURN(argvi);
6774         fail:
6775         (void) _swigerr;
6776     }
6777     croak(_swigerr);
6778 }
6779
6780
6781 XS(_wrap_data1_map_record) {
6782     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6783     const char *_swigerr = _swigmsg;
6784     {
6785         data1_handle arg1 ;
6786         data1_node *arg2 ;
6787         data1_maptab *arg3 ;
6788         NMEM arg4 ;
6789         data1_node *result;
6790         int argvi = 0;
6791         dXSARGS;
6792
6793         if ((items < 4) || (items > 4)) {
6794             SWIG_croak("Usage: data1_map_record(dh,n,map,m);");
6795         }
6796         {
6797             data1_handle * argp;
6798             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6799                 SWIG_croak("Type error in argument 1 of data1_map_record. Expected _p_data1_handle");
6800             }
6801             arg1 = *argp;
6802         }
6803         {
6804             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6805                 SWIG_croak("Type error in argument 2 of data1_map_record. Expected _p_data1_node");
6806             }
6807         }
6808         {
6809             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_maptab,0) < 0) {
6810                 SWIG_croak("Type error in argument 3 of data1_map_record. Expected _p_data1_maptab");
6811             }
6812         }
6813         {
6814             NMEM * argp;
6815             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
6816                 SWIG_croak("Type error in argument 4 of data1_map_record. Expected _p_NMEM");
6817             }
6818             arg4 = *argp;
6819         }
6820         result = (data1_node *)data1_map_record(arg1,arg2,arg3,arg4);
6821
6822         ST(argvi) = sv_newmortal();
6823         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
6824         XSRETURN(argvi);
6825         fail:
6826         (void) _swigerr;
6827     }
6828     croak(_swigerr);
6829 }
6830
6831
6832 XS(_wrap_data1_read_marctab) {
6833     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6834     const char *_swigerr = _swigmsg;
6835     {
6836         data1_handle arg1 ;
6837         char *arg2 ;
6838         data1_marctab *result;
6839         int argvi = 0;
6840         dXSARGS;
6841
6842         if ((items < 2) || (items > 2)) {
6843             SWIG_croak("Usage: data1_read_marctab(dh,file);");
6844         }
6845         {
6846             data1_handle * argp;
6847             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6848                 SWIG_croak("Type error in argument 1 of data1_read_marctab. Expected _p_data1_handle");
6849             }
6850             arg1 = *argp;
6851         }
6852         if (!SvOK((SV*) ST(1))) arg2 = 0;
6853         else arg2 = (char *) SvPV(ST(1), PL_na);
6854         result = (data1_marctab *)data1_read_marctab(arg1,(char const *)arg2);
6855
6856         ST(argvi) = sv_newmortal();
6857         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_marctab,0);
6858         XSRETURN(argvi);
6859         fail:
6860         (void) _swigerr;
6861     }
6862     croak(_swigerr);
6863 }
6864
6865
6866 XS(_wrap_data1_nodetomarc) {
6867     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6868     const char *_swigerr = _swigmsg;
6869     {
6870         data1_handle arg1 ;
6871         data1_marctab *arg2 ;
6872         data1_node *arg3 ;
6873         int arg4 ;
6874         int *arg5 ;
6875         char *result;
6876         int argvi = 0;
6877         dXSARGS;
6878
6879         if ((items < 5) || (items > 5)) {
6880             SWIG_croak("Usage: data1_nodetomarc(dh,p,n,selected,len);");
6881         }
6882         {
6883             data1_handle * argp;
6884             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6885                 SWIG_croak("Type error in argument 1 of data1_nodetomarc. Expected _p_data1_handle");
6886             }
6887             arg1 = *argp;
6888         }
6889         {
6890             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_marctab,0) < 0) {
6891                 SWIG_croak("Type error in argument 2 of data1_nodetomarc. Expected _p_data1_marctab");
6892             }
6893         }
6894         {
6895             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_data1_node,0) < 0) {
6896                 SWIG_croak("Type error in argument 3 of data1_nodetomarc. Expected _p_data1_node");
6897             }
6898         }
6899         arg4 = (int) SvIV(ST(3));
6900         {
6901             if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_int,0) < 0) {
6902                 SWIG_croak("Type error in argument 5 of data1_nodetomarc. Expected _p_int");
6903             }
6904         }
6905         result = (char *)data1_nodetomarc(arg1,arg2,arg3,arg4,arg5);
6906
6907         ST(argvi) = sv_newmortal();
6908         if (result) {
6909             sv_setpv((SV*)ST(argvi++), (char *) result);
6910         }else {
6911             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
6912         }
6913         XSRETURN(argvi);
6914         fail:
6915         (void) _swigerr;
6916     }
6917     croak(_swigerr);
6918 }
6919
6920
6921 XS(_wrap_data1_nodetoidsgml) {
6922     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6923     const char *_swigerr = _swigmsg;
6924     {
6925         data1_handle arg1 ;
6926         data1_node *arg2 ;
6927         int arg3 ;
6928         int *arg4 ;
6929         char *result;
6930         int argvi = 0;
6931         dXSARGS;
6932
6933         if ((items < 4) || (items > 4)) {
6934             SWIG_croak("Usage: data1_nodetoidsgml(dh,n,select,len);");
6935         }
6936         {
6937             data1_handle * argp;
6938             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6939                 SWIG_croak("Type error in argument 1 of data1_nodetoidsgml. Expected _p_data1_handle");
6940             }
6941             arg1 = *argp;
6942         }
6943         {
6944             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6945                 SWIG_croak("Type error in argument 2 of data1_nodetoidsgml. Expected _p_data1_node");
6946             }
6947         }
6948         arg3 = (int) SvIV(ST(2));
6949         {
6950             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_int,0) < 0) {
6951                 SWIG_croak("Type error in argument 4 of data1_nodetoidsgml. Expected _p_int");
6952             }
6953         }
6954         result = (char *)data1_nodetoidsgml(arg1,arg2,arg3,arg4);
6955
6956         ST(argvi) = sv_newmortal();
6957         if (result) {
6958             sv_setpv((SV*)ST(argvi++), (char *) result);
6959         }else {
6960             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
6961         }
6962         XSRETURN(argvi);
6963         fail:
6964         (void) _swigerr;
6965     }
6966     croak(_swigerr);
6967 }
6968
6969
6970 XS(_wrap_data1_nodetoexplain) {
6971     char _swigmsg[SWIG_MAX_ERRMSG] = "";
6972     const char *_swigerr = _swigmsg;
6973     {
6974         data1_handle arg1 ;
6975         data1_node *arg2 ;
6976         int arg3 ;
6977         ODR arg4 ;
6978         Z_ExplainRecord *result;
6979         int argvi = 0;
6980         dXSARGS;
6981
6982         if ((items < 4) || (items > 4)) {
6983             SWIG_croak("Usage: data1_nodetoexplain(dh,n,select,o);");
6984         }
6985         {
6986             data1_handle * argp;
6987             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
6988                 SWIG_croak("Type error in argument 1 of data1_nodetoexplain. Expected _p_data1_handle");
6989             }
6990             arg1 = *argp;
6991         }
6992         {
6993             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
6994                 SWIG_croak("Type error in argument 2 of data1_nodetoexplain. Expected _p_data1_node");
6995             }
6996         }
6997         arg3 = (int) SvIV(ST(2));
6998         {
6999             ODR * argp;
7000             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
7001                 SWIG_croak("Type error in argument 4 of data1_nodetoexplain. Expected _p_ODR");
7002             }
7003             arg4 = *argp;
7004         }
7005         result = (Z_ExplainRecord *)data1_nodetoexplain(arg1,arg2,arg3,arg4);
7006
7007         ST(argvi) = sv_newmortal();
7008         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_ExplainRecord,0);
7009         XSRETURN(argvi);
7010         fail:
7011         (void) _swigerr;
7012     }
7013     croak(_swigerr);
7014 }
7015
7016
7017 XS(_wrap_data1_nodetosummary) {
7018     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7019     const char *_swigerr = _swigmsg;
7020     {
7021         data1_handle arg1 ;
7022         data1_node *arg2 ;
7023         int arg3 ;
7024         ODR arg4 ;
7025         Z_BriefBib *result;
7026         int argvi = 0;
7027         dXSARGS;
7028
7029         if ((items < 4) || (items > 4)) {
7030             SWIG_croak("Usage: data1_nodetosummary(dh,n,select,o);");
7031         }
7032         {
7033             data1_handle * argp;
7034             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7035                 SWIG_croak("Type error in argument 1 of data1_nodetosummary. Expected _p_data1_handle");
7036             }
7037             arg1 = *argp;
7038         }
7039         {
7040             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7041                 SWIG_croak("Type error in argument 2 of data1_nodetosummary. Expected _p_data1_node");
7042             }
7043         }
7044         arg3 = (int) SvIV(ST(2));
7045         {
7046             ODR * argp;
7047             if (SWIG_ConvertPtr(ST(3),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) {
7048                 SWIG_croak("Type error in argument 4 of data1_nodetosummary. Expected _p_ODR");
7049             }
7050             arg4 = *argp;
7051         }
7052         result = (Z_BriefBib *)data1_nodetosummary(arg1,arg2,arg3,arg4);
7053
7054         ST(argvi) = sv_newmortal();
7055         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Z_BriefBib,0);
7056         XSRETURN(argvi);
7057         fail:
7058         (void) _swigerr;
7059     }
7060     croak(_swigerr);
7061 }
7062
7063
7064 XS(_wrap_data1_nodetosoif) {
7065     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7066     const char *_swigerr = _swigmsg;
7067     {
7068         data1_handle arg1 ;
7069         data1_node *arg2 ;
7070         int arg3 ;
7071         int *arg4 ;
7072         char *result;
7073         int argvi = 0;
7074         dXSARGS;
7075
7076         if ((items < 4) || (items > 4)) {
7077             SWIG_croak("Usage: data1_nodetosoif(dh,n,select,len);");
7078         }
7079         {
7080             data1_handle * argp;
7081             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7082                 SWIG_croak("Type error in argument 1 of data1_nodetosoif. Expected _p_data1_handle");
7083             }
7084             arg1 = *argp;
7085         }
7086         {
7087             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7088                 SWIG_croak("Type error in argument 2 of data1_nodetosoif. Expected _p_data1_node");
7089             }
7090         }
7091         arg3 = (int) SvIV(ST(2));
7092         {
7093             if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_int,0) < 0) {
7094                 SWIG_croak("Type error in argument 4 of data1_nodetosoif. Expected _p_int");
7095             }
7096         }
7097         result = (char *)data1_nodetosoif(arg1,arg2,arg3,arg4);
7098
7099         ST(argvi) = sv_newmortal();
7100         if (result) {
7101             sv_setpv((SV*)ST(argvi++), (char *) result);
7102         }else {
7103             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7104         }
7105         XSRETURN(argvi);
7106         fail:
7107         (void) _swigerr;
7108     }
7109     croak(_swigerr);
7110 }
7111
7112
7113 XS(_wrap_data1_get_wrbuf) {
7114     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7115     const char *_swigerr = _swigmsg;
7116     {
7117         data1_handle arg1 ;
7118         WRBUF result;
7119         int argvi = 0;
7120         dXSARGS;
7121
7122         if ((items < 1) || (items > 1)) {
7123             SWIG_croak("Usage: data1_get_wrbuf(dp);");
7124         }
7125         {
7126             data1_handle * argp;
7127             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7128                 SWIG_croak("Type error in argument 1 of data1_get_wrbuf. Expected _p_data1_handle");
7129             }
7130             arg1 = *argp;
7131         }
7132         result = data1_get_wrbuf(arg1);
7133
7134         {
7135             WRBUF * resultobj = (WRBUF *) malloc(sizeof(WRBUF));
7136             memmove(resultobj, &result, sizeof(WRBUF));
7137             ST(argvi) = sv_newmortal();
7138             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_WRBUF,0);
7139         }
7140         XSRETURN(argvi);
7141         fail:
7142         (void) _swigerr;
7143     }
7144     croak(_swigerr);
7145 }
7146
7147
7148 XS(_wrap_data1_get_read_buf) {
7149     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7150     const char *_swigerr = _swigmsg;
7151     {
7152         data1_handle arg1 ;
7153         int **arg2 ;
7154         char **result;
7155         int argvi = 0;
7156         dXSARGS;
7157
7158         if ((items < 2) || (items > 2)) {
7159             SWIG_croak("Usage: data1_get_read_buf(dp,lenp);");
7160         }
7161         {
7162             data1_handle * argp;
7163             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7164                 SWIG_croak("Type error in argument 1 of data1_get_read_buf. Expected _p_data1_handle");
7165             }
7166             arg1 = *argp;
7167         }
7168         {
7169             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_p_int,0) < 0) {
7170                 SWIG_croak("Type error in argument 2 of data1_get_read_buf. Expected _p_p_int");
7171             }
7172         }
7173         result = (char **)data1_get_read_buf(arg1,arg2);
7174
7175         {
7176             AV *myav;
7177             SV **svs;
7178             int i = 0,len = 0;
7179             /* Figure out how many elements we have */
7180             while (result[len])
7181             len++;
7182             svs = (SV **) malloc(len*sizeof(SV *));
7183             for (i = 0; i < len ; i++) {
7184                 svs[i] = sv_newmortal();
7185                 sv_setpv((SV*)svs[i],result[i]);
7186             };
7187             myav =  av_make(len,svs);
7188             free(svs);
7189             ST(argvi) = newRV((SV*)myav);
7190             sv_2mortal(ST(argvi));
7191             argvi++;
7192         }
7193         XSRETURN(argvi);
7194         fail:
7195         (void) _swigerr;
7196     }
7197     croak(_swigerr);
7198 }
7199
7200
7201 XS(_wrap_data1_get_map_buf) {
7202     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7203     const char *_swigerr = _swigmsg;
7204     {
7205         data1_handle arg1 ;
7206         int **arg2 ;
7207         char **result;
7208         int argvi = 0;
7209         dXSARGS;
7210
7211         if ((items < 2) || (items > 2)) {
7212             SWIG_croak("Usage: data1_get_map_buf(dp,lenp);");
7213         }
7214         {
7215             data1_handle * argp;
7216             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7217                 SWIG_croak("Type error in argument 1 of data1_get_map_buf. Expected _p_data1_handle");
7218             }
7219             arg1 = *argp;
7220         }
7221         {
7222             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_p_int,0) < 0) {
7223                 SWIG_croak("Type error in argument 2 of data1_get_map_buf. Expected _p_p_int");
7224             }
7225         }
7226         result = (char **)data1_get_map_buf(arg1,arg2);
7227
7228         {
7229             AV *myav;
7230             SV **svs;
7231             int i = 0,len = 0;
7232             /* Figure out how many elements we have */
7233             while (result[len])
7234             len++;
7235             svs = (SV **) malloc(len*sizeof(SV *));
7236             for (i = 0; i < len ; i++) {
7237                 svs[i] = sv_newmortal();
7238                 sv_setpv((SV*)svs[i],result[i]);
7239             };
7240             myav =  av_make(len,svs);
7241             free(svs);
7242             ST(argvi) = newRV((SV*)myav);
7243             sv_2mortal(ST(argvi));
7244             argvi++;
7245         }
7246         XSRETURN(argvi);
7247         fail:
7248         (void) _swigerr;
7249     }
7250     croak(_swigerr);
7251 }
7252
7253
7254 XS(_wrap_data1_absyn_cache_get) {
7255     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7256     const char *_swigerr = _swigmsg;
7257     {
7258         data1_handle arg1 ;
7259         data1_absyn_cache *result;
7260         int argvi = 0;
7261         dXSARGS;
7262
7263         if ((items < 1) || (items > 1)) {
7264             SWIG_croak("Usage: data1_absyn_cache_get(dh);");
7265         }
7266         {
7267             data1_handle * argp;
7268             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7269                 SWIG_croak("Type error in argument 1 of data1_absyn_cache_get. Expected _p_data1_handle");
7270             }
7271             arg1 = *argp;
7272         }
7273         result = (data1_absyn_cache *)data1_absyn_cache_get(arg1);
7274
7275         ST(argvi) = sv_newmortal();
7276         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_absyn_cache,0);
7277         XSRETURN(argvi);
7278         fail:
7279         (void) _swigerr;
7280     }
7281     croak(_swigerr);
7282 }
7283
7284
7285 XS(_wrap_data1_attset_cache_get) {
7286     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7287     const char *_swigerr = _swigmsg;
7288     {
7289         data1_handle arg1 ;
7290         data1_attset_cache *result;
7291         int argvi = 0;
7292         dXSARGS;
7293
7294         if ((items < 1) || (items > 1)) {
7295             SWIG_croak("Usage: data1_attset_cache_get(dh);");
7296         }
7297         {
7298             data1_handle * argp;
7299             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7300                 SWIG_croak("Type error in argument 1 of data1_attset_cache_get. Expected _p_data1_handle");
7301             }
7302             arg1 = *argp;
7303         }
7304         result = (data1_attset_cache *)data1_attset_cache_get(arg1);
7305
7306         ST(argvi) = sv_newmortal();
7307         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_attset_cache,0);
7308         XSRETURN(argvi);
7309         fail:
7310         (void) _swigerr;
7311     }
7312     croak(_swigerr);
7313 }
7314
7315
7316 XS(_wrap_data1_nmem_get) {
7317     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7318     const char *_swigerr = _swigmsg;
7319     {
7320         data1_handle arg1 ;
7321         NMEM result;
7322         int argvi = 0;
7323         dXSARGS;
7324
7325         if ((items < 1) || (items > 1)) {
7326             SWIG_croak("Usage: data1_nmem_get(dh);");
7327         }
7328         {
7329             data1_handle * argp;
7330             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7331                 SWIG_croak("Type error in argument 1 of data1_nmem_get. Expected _p_data1_handle");
7332             }
7333             arg1 = *argp;
7334         }
7335         result = data1_nmem_get(arg1);
7336
7337         {
7338             NMEM * resultobj = (NMEM *) malloc(sizeof(NMEM));
7339             memmove(resultobj, &result, sizeof(NMEM));
7340             ST(argvi) = sv_newmortal();
7341             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_NMEM,0);
7342         }
7343         XSRETURN(argvi);
7344         fail:
7345         (void) _swigerr;
7346     }
7347     croak(_swigerr);
7348 }
7349
7350
7351 XS(_wrap_data1_pr_tree) {
7352     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7353     const char *_swigerr = _swigmsg;
7354     {
7355         data1_handle arg1 ;
7356         data1_node *arg2 ;
7357         FILE *arg3 ;
7358         int argvi = 0;
7359         dXSARGS;
7360
7361         if ((items < 3) || (items > 3)) {
7362             SWIG_croak("Usage: data1_pr_tree(dh,n,out);");
7363         }
7364         {
7365             data1_handle * argp;
7366             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7367                 SWIG_croak("Type error in argument 1 of data1_pr_tree. Expected _p_data1_handle");
7368             }
7369             arg1 = *argp;
7370         }
7371         {
7372             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7373                 SWIG_croak("Type error in argument 2 of data1_pr_tree. Expected _p_data1_node");
7374             }
7375         }
7376         {
7377             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_FILE,0) < 0) {
7378                 SWIG_croak("Type error in argument 3 of data1_pr_tree. Expected _p_FILE");
7379             }
7380         }
7381         data1_pr_tree(arg1,arg2,arg3);
7382
7383
7384         XSRETURN(argvi);
7385         fail:
7386         (void) _swigerr;
7387     }
7388     croak(_swigerr);
7389 }
7390
7391
7392 XS(_wrap_data1_print_tree) {
7393     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7394     const char *_swigerr = _swigmsg;
7395     {
7396         data1_handle arg1 ;
7397         data1_node *arg2 ;
7398         int argvi = 0;
7399         dXSARGS;
7400
7401         if ((items < 2) || (items > 2)) {
7402             SWIG_croak("Usage: data1_print_tree(dh,n);");
7403         }
7404         {
7405             data1_handle * argp;
7406             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7407                 SWIG_croak("Type error in argument 1 of data1_print_tree. Expected _p_data1_handle");
7408             }
7409             arg1 = *argp;
7410         }
7411         {
7412             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7413                 SWIG_croak("Type error in argument 2 of data1_print_tree. Expected _p_data1_node");
7414             }
7415         }
7416         data1_print_tree(arg1,arg2);
7417
7418
7419         XSRETURN(argvi);
7420         fail:
7421         (void) _swigerr;
7422     }
7423     croak(_swigerr);
7424 }
7425
7426
7427 XS(_wrap_data1_insert_string) {
7428     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7429     const char *_swigerr = _swigmsg;
7430     {
7431         data1_handle arg1 ;
7432         data1_node *arg2 ;
7433         NMEM arg3 ;
7434         char *arg4 ;
7435         char *result;
7436         int argvi = 0;
7437         dXSARGS;
7438
7439         if ((items < 4) || (items > 4)) {
7440             SWIG_croak("Usage: data1_insert_string(dh,res,m,str);");
7441         }
7442         {
7443             data1_handle * argp;
7444             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7445                 SWIG_croak("Type error in argument 1 of data1_insert_string. Expected _p_data1_handle");
7446             }
7447             arg1 = *argp;
7448         }
7449         {
7450             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7451                 SWIG_croak("Type error in argument 2 of data1_insert_string. Expected _p_data1_node");
7452             }
7453         }
7454         {
7455             NMEM * argp;
7456             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
7457                 SWIG_croak("Type error in argument 3 of data1_insert_string. Expected _p_NMEM");
7458             }
7459             arg3 = *argp;
7460         }
7461         if (!SvOK((SV*) ST(3))) arg4 = 0;
7462         else arg4 = (char *) SvPV(ST(3), PL_na);
7463         result = (char *)data1_insert_string(arg1,arg2,arg3,(char const *)arg4);
7464
7465         ST(argvi) = sv_newmortal();
7466         if (result) {
7467             sv_setpv((SV*)ST(argvi++), (char *) result);
7468         }else {
7469             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7470         }
7471         XSRETURN(argvi);
7472         fail:
7473         (void) _swigerr;
7474     }
7475     croak(_swigerr);
7476 }
7477
7478
7479 XS(_wrap_data1_insert_string_n) {
7480     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7481     const char *_swigerr = _swigmsg;
7482     {
7483         data1_handle arg1 ;
7484         data1_node *arg2 ;
7485         NMEM arg3 ;
7486         char *arg4 ;
7487         size_t arg5 ;
7488         char *result;
7489         int argvi = 0;
7490         dXSARGS;
7491
7492         if ((items < 5) || (items > 5)) {
7493             SWIG_croak("Usage: data1_insert_string_n(dh,res,m,str,len);");
7494         }
7495         {
7496             data1_handle * argp;
7497             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7498                 SWIG_croak("Type error in argument 1 of data1_insert_string_n. Expected _p_data1_handle");
7499             }
7500             arg1 = *argp;
7501         }
7502         {
7503             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
7504                 SWIG_croak("Type error in argument 2 of data1_insert_string_n. Expected _p_data1_node");
7505             }
7506         }
7507         {
7508             NMEM * argp;
7509             if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
7510                 SWIG_croak("Type error in argument 3 of data1_insert_string_n. Expected _p_NMEM");
7511             }
7512             arg3 = *argp;
7513         }
7514         if (!SvOK((SV*) ST(3))) arg4 = 0;
7515         else arg4 = (char *) SvPV(ST(3), PL_na);
7516         arg5 = (size_t) SvUV(ST(4));
7517         result = (char *)data1_insert_string_n(arg1,arg2,arg3,(char const *)arg4,arg5);
7518
7519         ST(argvi) = sv_newmortal();
7520         if (result) {
7521             sv_setpv((SV*)ST(argvi++), (char *) result);
7522         }else {
7523             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7524         }
7525         XSRETURN(argvi);
7526         fail:
7527         (void) _swigerr;
7528     }
7529     croak(_swigerr);
7530 }
7531
7532
7533 XS(_wrap_data1_read_sgml) {
7534     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7535     const char *_swigerr = _swigmsg;
7536     {
7537         data1_handle arg1 ;
7538         NMEM arg2 ;
7539         char *arg3 ;
7540         data1_node *result;
7541         int argvi = 0;
7542         dXSARGS;
7543
7544         if ((items < 3) || (items > 3)) {
7545             SWIG_croak("Usage: data1_read_sgml(dh,m,buf);");
7546         }
7547         {
7548             data1_handle * argp;
7549             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7550                 SWIG_croak("Type error in argument 1 of data1_read_sgml. Expected _p_data1_handle");
7551             }
7552             arg1 = *argp;
7553         }
7554         {
7555             NMEM * argp;
7556             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_NMEM,0) < 0) {
7557                 SWIG_croak("Type error in argument 2 of data1_read_sgml. Expected _p_NMEM");
7558             }
7559             arg2 = *argp;
7560         }
7561         if (!SvOK((SV*) ST(2))) arg3 = 0;
7562         else arg3 = (char *) SvPV(ST(2), PL_na);
7563         result = (data1_node *)data1_read_sgml(arg1,arg2,(char const *)arg3);
7564
7565         ST(argvi) = sv_newmortal();
7566         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
7567         XSRETURN(argvi);
7568         fail:
7569         (void) _swigerr;
7570     }
7571     croak(_swigerr);
7572 }
7573
7574
7575 XS(_wrap_data1_absyn_trav) {
7576     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7577     const char *_swigerr = _swigmsg;
7578     {
7579         data1_handle arg1 ;
7580         void *arg2 ;
7581         void (*arg3)(data1_handle,void *,data1_absyn *) ;
7582         int argvi = 0;
7583         dXSARGS;
7584
7585         if ((items < 3) || (items > 3)) {
7586             SWIG_croak("Usage: data1_absyn_trav(dh,handle,fh);");
7587         }
7588         {
7589             data1_handle * argp;
7590             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7591                 SWIG_croak("Type error in argument 1 of data1_absyn_trav. Expected _p_data1_handle");
7592             }
7593             arg1 = *argp;
7594         }
7595         {
7596             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, 0,0) < 0) {
7597                 SWIG_croak("Type error in argument 2 of data1_absyn_trav. Expected _p_void");
7598             }
7599         }
7600         {
7601             if (SWIG_ConvertPtr(ST(2), (void **) &arg3, SWIGTYPE_p_f_data1_handle_p_void_p_data1_absyn__void,0) < 0) {
7602                 SWIG_croak("Type error in argument 3 of data1_absyn_trav. Expected _p_f_data1_handle_p_void_p_data1_absyn__void");
7603             }
7604         }
7605         data1_absyn_trav(arg1,arg2,arg3);
7606
7607
7608         XSRETURN(argvi);
7609         fail:
7610         (void) _swigerr;
7611     }
7612     croak(_swigerr);
7613 }
7614
7615
7616 XS(_wrap_data1_attset_search_id) {
7617     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7618     const char *_swigerr = _swigmsg;
7619     {
7620         data1_handle arg1 ;
7621         int arg2 ;
7622         data1_attset *result;
7623         int argvi = 0;
7624         dXSARGS;
7625
7626         if ((items < 2) || (items > 2)) {
7627             SWIG_croak("Usage: data1_attset_search_id(dh,id);");
7628         }
7629         {
7630             data1_handle * argp;
7631             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7632                 SWIG_croak("Type error in argument 1 of data1_attset_search_id. Expected _p_data1_handle");
7633             }
7634             arg1 = *argp;
7635         }
7636         arg2 = (int) SvIV(ST(1));
7637         result = (data1_attset *)data1_attset_search_id(arg1,arg2);
7638
7639         ST(argvi) = sv_newmortal();
7640         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_attset,0);
7641         XSRETURN(argvi);
7642         fail:
7643         (void) _swigerr;
7644     }
7645     croak(_swigerr);
7646 }
7647
7648
7649 XS(_wrap_data1_getNodeValue) {
7650     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7651     const char *_swigerr = _swigmsg;
7652     {
7653         data1_node *arg1 ;
7654         char *arg2 ;
7655         char *result;
7656         int argvi = 0;
7657         dXSARGS;
7658
7659         if ((items < 2) || (items > 2)) {
7660             SWIG_croak("Usage: data1_getNodeValue(node,pTagPath);");
7661         }
7662         {
7663             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_data1_node,0) < 0) {
7664                 SWIG_croak("Type error in argument 1 of data1_getNodeValue. Expected _p_data1_node");
7665             }
7666         }
7667         if (!SvOK((SV*) ST(1))) arg2 = 0;
7668         else arg2 = (char *) SvPV(ST(1), PL_na);
7669         result = (char *)data1_getNodeValue(arg1,arg2);
7670
7671         ST(argvi) = sv_newmortal();
7672         if (result) {
7673             sv_setpv((SV*)ST(argvi++), (char *) result);
7674         }else {
7675             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7676         }
7677         XSRETURN(argvi);
7678         fail:
7679         (void) _swigerr;
7680     }
7681     croak(_swigerr);
7682 }
7683
7684
7685 XS(_wrap_data1_LookupNode) {
7686     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7687     const char *_swigerr = _swigmsg;
7688     {
7689         data1_node *arg1 ;
7690         char *arg2 ;
7691         data1_node *result;
7692         int argvi = 0;
7693         dXSARGS;
7694
7695         if ((items < 2) || (items > 2)) {
7696             SWIG_croak("Usage: data1_LookupNode(node,pTagPath);");
7697         }
7698         {
7699             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_data1_node,0) < 0) {
7700                 SWIG_croak("Type error in argument 1 of data1_LookupNode. Expected _p_data1_node");
7701             }
7702         }
7703         if (!SvOK((SV*) ST(1))) arg2 = 0;
7704         else arg2 = (char *) SvPV(ST(1), PL_na);
7705         result = (data1_node *)data1_LookupNode(arg1,arg2);
7706
7707         ST(argvi) = sv_newmortal();
7708         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_node,0);
7709         XSRETURN(argvi);
7710         fail:
7711         (void) _swigerr;
7712     }
7713     croak(_swigerr);
7714 }
7715
7716
7717 XS(_wrap_data1_CountOccurences) {
7718     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7719     const char *_swigerr = _swigmsg;
7720     {
7721         data1_node *arg1 ;
7722         char *arg2 ;
7723         int result;
7724         int argvi = 0;
7725         dXSARGS;
7726
7727         if ((items < 2) || (items > 2)) {
7728             SWIG_croak("Usage: data1_CountOccurences(node,pTagPath);");
7729         }
7730         {
7731             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_data1_node,0) < 0) {
7732                 SWIG_croak("Type error in argument 1 of data1_CountOccurences. Expected _p_data1_node");
7733             }
7734         }
7735         if (!SvOK((SV*) ST(1))) arg2 = 0;
7736         else arg2 = (char *) SvPV(ST(1), PL_na);
7737         result = (int)data1_CountOccurences(arg1,arg2);
7738
7739         ST(argvi) = sv_newmortal();
7740         sv_setiv(ST(argvi++), (IV) result);
7741         XSRETURN(argvi);
7742         fail:
7743         (void) _swigerr;
7744     }
7745     croak(_swigerr);
7746 }
7747
7748
7749 XS(_wrap_data1_path_fopen) {
7750     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7751     const char *_swigerr = _swigmsg;
7752     {
7753         data1_handle arg1 ;
7754         char *arg2 ;
7755         char *arg3 ;
7756         FILE *result;
7757         int argvi = 0;
7758         dXSARGS;
7759
7760         if ((items < 3) || (items > 3)) {
7761             SWIG_croak("Usage: data1_path_fopen(dh,file,mode);");
7762         }
7763         {
7764             data1_handle * argp;
7765             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7766                 SWIG_croak("Type error in argument 1 of data1_path_fopen. Expected _p_data1_handle");
7767             }
7768             arg1 = *argp;
7769         }
7770         if (!SvOK((SV*) ST(1))) arg2 = 0;
7771         else arg2 = (char *) SvPV(ST(1), PL_na);
7772         if (!SvOK((SV*) ST(2))) arg3 = 0;
7773         else arg3 = (char *) SvPV(ST(2), PL_na);
7774         result = (FILE *)data1_path_fopen(arg1,(char const *)arg2,(char const *)arg3);
7775
7776         ST(argvi) = sv_newmortal();
7777         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_FILE,0);
7778         XSRETURN(argvi);
7779         fail:
7780         (void) _swigerr;
7781     }
7782     croak(_swigerr);
7783 }
7784
7785
7786 XS(_wrap_data1_set_tabpath) {
7787     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7788     const char *_swigerr = _swigmsg;
7789     {
7790         data1_handle arg1 ;
7791         char *arg2 ;
7792         int argvi = 0;
7793         dXSARGS;
7794
7795         if ((items < 2) || (items > 2)) {
7796             SWIG_croak("Usage: data1_set_tabpath(dh,path);");
7797         }
7798         {
7799             data1_handle * argp;
7800             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7801                 SWIG_croak("Type error in argument 1 of data1_set_tabpath. Expected _p_data1_handle");
7802             }
7803             arg1 = *argp;
7804         }
7805         if (!SvOK((SV*) ST(1))) arg2 = 0;
7806         else arg2 = (char *) SvPV(ST(1), PL_na);
7807         data1_set_tabpath(arg1,(char const *)arg2);
7808
7809
7810         XSRETURN(argvi);
7811         fail:
7812         (void) _swigerr;
7813     }
7814     croak(_swigerr);
7815 }
7816
7817
7818 XS(_wrap_data1_set_tabroot) {
7819     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7820     const char *_swigerr = _swigmsg;
7821     {
7822         data1_handle arg1 ;
7823         char *arg2 ;
7824         int argvi = 0;
7825         dXSARGS;
7826
7827         if ((items < 2) || (items > 2)) {
7828             SWIG_croak("Usage: data1_set_tabroot(dp,p);");
7829         }
7830         {
7831             data1_handle * argp;
7832             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7833                 SWIG_croak("Type error in argument 1 of data1_set_tabroot. Expected _p_data1_handle");
7834             }
7835             arg1 = *argp;
7836         }
7837         if (!SvOK((SV*) ST(1))) arg2 = 0;
7838         else arg2 = (char *) SvPV(ST(1), PL_na);
7839         data1_set_tabroot(arg1,(char const *)arg2);
7840
7841
7842         XSRETURN(argvi);
7843         fail:
7844         (void) _swigerr;
7845     }
7846     croak(_swigerr);
7847 }
7848
7849
7850 XS(_wrap_data1_get_tabpath) {
7851     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7852     const char *_swigerr = _swigmsg;
7853     {
7854         data1_handle arg1 ;
7855         char *result;
7856         int argvi = 0;
7857         dXSARGS;
7858
7859         if ((items < 1) || (items > 1)) {
7860             SWIG_croak("Usage: data1_get_tabpath(dh);");
7861         }
7862         {
7863             data1_handle * argp;
7864             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7865                 SWIG_croak("Type error in argument 1 of data1_get_tabpath. Expected _p_data1_handle");
7866             }
7867             arg1 = *argp;
7868         }
7869         result = (char *)data1_get_tabpath(arg1);
7870
7871         ST(argvi) = sv_newmortal();
7872         if (result) {
7873             sv_setpv((SV*)ST(argvi++), (char *) result);
7874         }else {
7875             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7876         }
7877         XSRETURN(argvi);
7878         fail:
7879         (void) _swigerr;
7880     }
7881     croak(_swigerr);
7882 }
7883
7884
7885 XS(_wrap_data1_get_tabroot) {
7886     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7887     const char *_swigerr = _swigmsg;
7888     {
7889         data1_handle arg1 ;
7890         char *result;
7891         int argvi = 0;
7892         dXSARGS;
7893
7894         if ((items < 1) || (items > 1)) {
7895             SWIG_croak("Usage: data1_get_tabroot(dh);");
7896         }
7897         {
7898             data1_handle * argp;
7899             if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_data1_handle,0) < 0) {
7900                 SWIG_croak("Type error in argument 1 of data1_get_tabroot. Expected _p_data1_handle");
7901             }
7902             arg1 = *argp;
7903         }
7904         result = (char *)data1_get_tabroot(arg1);
7905
7906         ST(argvi) = sv_newmortal();
7907         if (result) {
7908             sv_setpv((SV*)ST(argvi++), (char *) result);
7909         }else {
7910             sv_setsv((SV*)ST(argvi++), &PL_sv_undef);
7911         }
7912         XSRETURN(argvi);
7913         fail:
7914         (void) _swigerr;
7915     }
7916     croak(_swigerr);
7917 }
7918
7919
7920 XS(_wrap_grs_perl_readf) {
7921     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7922     const char *_swigerr = _swigmsg;
7923     {
7924         struct perl_context *arg1 ;
7925         size_t arg2 ;
7926         int result;
7927         int argvi = 0;
7928         dXSARGS;
7929
7930         if ((items < 2) || (items > 2)) {
7931             SWIG_croak("Usage: grs_perl_readf(context,len);");
7932         }
7933         {
7934             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
7935                 SWIG_croak("Type error in argument 1 of grs_perl_readf. Expected _p_perl_context");
7936             }
7937         }
7938         arg2 = (size_t) SvUV(ST(1));
7939         result = (int)grs_perl_readf(arg1,arg2);
7940
7941         ST(argvi) = sv_newmortal();
7942         sv_setiv(ST(argvi++), (IV) result);
7943         XSRETURN(argvi);
7944         fail:
7945         (void) _swigerr;
7946     }
7947     croak(_swigerr);
7948 }
7949
7950
7951 XS(_wrap_grs_perl_readline) {
7952     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7953     const char *_swigerr = _swigmsg;
7954     {
7955         struct perl_context *arg1 ;
7956         int result;
7957         int argvi = 0;
7958         dXSARGS;
7959
7960         if ((items < 1) || (items > 1)) {
7961             SWIG_croak("Usage: grs_perl_readline(context);");
7962         }
7963         {
7964             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
7965                 SWIG_croak("Type error in argument 1 of grs_perl_readline. Expected _p_perl_context");
7966             }
7967         }
7968         result = (int)grs_perl_readline(arg1);
7969
7970         ST(argvi) = sv_newmortal();
7971         sv_setiv(ST(argvi++), (IV) result);
7972         XSRETURN(argvi);
7973         fail:
7974         (void) _swigerr;
7975     }
7976     croak(_swigerr);
7977 }
7978
7979
7980 XS(_wrap_grs_perl_getc) {
7981     char _swigmsg[SWIG_MAX_ERRMSG] = "";
7982     const char *_swigerr = _swigmsg;
7983     {
7984         struct perl_context *arg1 ;
7985         char result;
7986         int argvi = 0;
7987         dXSARGS;
7988
7989         if ((items < 1) || (items > 1)) {
7990             SWIG_croak("Usage: grs_perl_getc(context);");
7991         }
7992         {
7993             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
7994                 SWIG_croak("Type error in argument 1 of grs_perl_getc. Expected _p_perl_context");
7995             }
7996         }
7997         result = (char)grs_perl_getc(arg1);
7998
7999         ST(argvi) = sv_newmortal();
8000         sv_setpvn((SV*)ST(argvi++), &result, 1);
8001         XSRETURN(argvi);
8002         fail:
8003         (void) _swigerr;
8004     }
8005     croak(_swigerr);
8006 }
8007
8008
8009 XS(_wrap_grs_perl_seekf) {
8010     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8011     const char *_swigerr = _swigmsg;
8012     {
8013         struct perl_context *arg1 ;
8014         off_t arg2 ;
8015         off_t result;
8016         int argvi = 0;
8017         dXSARGS;
8018
8019         if ((items < 2) || (items > 2)) {
8020             SWIG_croak("Usage: grs_perl_seekf(context,offset);");
8021         }
8022         {
8023             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8024                 SWIG_croak("Type error in argument 1 of grs_perl_seekf. Expected _p_perl_context");
8025             }
8026         }
8027         {
8028             off_t * argp;
8029             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_off_t,0) < 0) {
8030                 SWIG_croak("Type error in argument 2 of grs_perl_seekf. Expected _p_off_t");
8031             }
8032             arg2 = *argp;
8033         }
8034         result = grs_perl_seekf(arg1,arg2);
8035
8036         {
8037             off_t * resultobj = (off_t *) malloc(sizeof(off_t));
8038             memmove(resultobj, &result, sizeof(off_t));
8039             ST(argvi) = sv_newmortal();
8040             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_off_t,0);
8041         }
8042         XSRETURN(argvi);
8043         fail:
8044         (void) _swigerr;
8045     }
8046     croak(_swigerr);
8047 }
8048
8049
8050 XS(_wrap_grs_perl_tellf) {
8051     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8052     const char *_swigerr = _swigmsg;
8053     {
8054         struct perl_context *arg1 ;
8055         off_t result;
8056         int argvi = 0;
8057         dXSARGS;
8058
8059         if ((items < 1) || (items > 1)) {
8060             SWIG_croak("Usage: grs_perl_tellf(context);");
8061         }
8062         {
8063             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8064                 SWIG_croak("Type error in argument 1 of grs_perl_tellf. Expected _p_perl_context");
8065             }
8066         }
8067         result = grs_perl_tellf(arg1);
8068
8069         {
8070             off_t * resultobj = (off_t *) malloc(sizeof(off_t));
8071             memmove(resultobj, &result, sizeof(off_t));
8072             ST(argvi) = sv_newmortal();
8073             SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_off_t,0);
8074         }
8075         XSRETURN(argvi);
8076         fail:
8077         (void) _swigerr;
8078     }
8079     croak(_swigerr);
8080 }
8081
8082
8083 XS(_wrap_grs_perl_endf) {
8084     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8085     const char *_swigerr = _swigmsg;
8086     {
8087         struct perl_context *arg1 ;
8088         off_t arg2 ;
8089         int argvi = 0;
8090         dXSARGS;
8091
8092         if ((items < 2) || (items > 2)) {
8093             SWIG_croak("Usage: grs_perl_endf(context,offset);");
8094         }
8095         {
8096             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8097                 SWIG_croak("Type error in argument 1 of grs_perl_endf. Expected _p_perl_context");
8098             }
8099         }
8100         {
8101             off_t * argp;
8102             if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_off_t,0) < 0) {
8103                 SWIG_croak("Type error in argument 2 of grs_perl_endf. Expected _p_off_t");
8104             }
8105             arg2 = *argp;
8106         }
8107         grs_perl_endf(arg1,arg2);
8108
8109
8110         XSRETURN(argvi);
8111         fail:
8112         (void) _swigerr;
8113     }
8114     croak(_swigerr);
8115 }
8116
8117
8118 XS(_wrap_grs_perl_get_dh) {
8119     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8120     const char *_swigerr = _swigmsg;
8121     {
8122         struct perl_context *arg1 ;
8123         data1_handle *result;
8124         int argvi = 0;
8125         dXSARGS;
8126
8127         if ((items < 1) || (items > 1)) {
8128             SWIG_croak("Usage: grs_perl_get_dh(context);");
8129         }
8130         {
8131             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8132                 SWIG_croak("Type error in argument 1 of grs_perl_get_dh. Expected _p_perl_context");
8133             }
8134         }
8135         result = (data1_handle *)grs_perl_get_dh(arg1);
8136
8137         ST(argvi) = sv_newmortal();
8138         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_data1_handle,0);
8139         XSRETURN(argvi);
8140         fail:
8141         (void) _swigerr;
8142     }
8143     croak(_swigerr);
8144 }
8145
8146
8147 XS(_wrap_grs_perl_get_mem) {
8148     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8149     const char *_swigerr = _swigmsg;
8150     {
8151         struct perl_context *arg1 ;
8152         NMEM *result;
8153         int argvi = 0;
8154         dXSARGS;
8155
8156         if ((items < 1) || (items > 1)) {
8157             SWIG_croak("Usage: grs_perl_get_mem(context);");
8158         }
8159         {
8160             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8161                 SWIG_croak("Type error in argument 1 of grs_perl_get_mem. Expected _p_perl_context");
8162             }
8163         }
8164         result = (NMEM *)grs_perl_get_mem(arg1);
8165
8166         ST(argvi) = sv_newmortal();
8167         SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_NMEM,0);
8168         XSRETURN(argvi);
8169         fail:
8170         (void) _swigerr;
8171     }
8172     croak(_swigerr);
8173 }
8174
8175
8176 XS(_wrap_grs_perl_set_res) {
8177     char _swigmsg[SWIG_MAX_ERRMSG] = "";
8178     const char *_swigerr = _swigmsg;
8179     {
8180         struct perl_context *arg1 ;
8181         data1_node *arg2 ;
8182         int argvi = 0;
8183         dXSARGS;
8184
8185         if ((items < 2) || (items > 2)) {
8186             SWIG_croak("Usage: grs_perl_set_res(context,n);");
8187         }
8188         {
8189             if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) {
8190                 SWIG_croak("Type error in argument 1 of grs_perl_set_res. Expected _p_perl_context");
8191             }
8192         }
8193         {
8194             if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_data1_node,0) < 0) {
8195                 SWIG_croak("Type error in argument 2 of grs_perl_set_res. Expected _p_data1_node");
8196             }
8197         }
8198         grs_perl_set_res(arg1,arg2);
8199
8200
8201         XSRETURN(argvi);
8202         fail:
8203         (void) _swigerr;
8204     }
8205     croak(_swigerr);
8206 }
8207
8208
8209
8210 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
8211
8212 static swig_type_info _swigt__p_ZebraService[] = {{"_p_ZebraService", 0, "ZebraService *", 0},{"_p_ZebraService"},{0}};
8213 static swig_type_info _swigt__p_cql_transform_t[] = {{"_p_cql_transform_t", 0, "cql_transform_t *", 0},{"_p_cql_transform_t"},{0}};
8214 static swig_type_info _swigt__p_data1_esetname[] = {{"_p_data1_esetname", 0, "data1_esetname *", 0},{"_p_data1_esetname"},{0}};
8215 static swig_type_info _swigt__p_data1_maptab[] = {{"_p_data1_maptab", 0, "data1_maptab *", 0},{"_p_data1_maptab"},{0}};
8216 static swig_type_info _swigt__p_ODR[] = {{"_p_ODR", 0, "ODR *", 0},{"_p_ODR"},{0}};
8217 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}};
8218 static swig_type_info _swigt__p_p_char[] = {{"_p_p_char", 0, "char **", 0},{"_p_p_char"},{0}};
8219 static swig_type_info _swigt__p_data1_absyn[] = {{"_p_data1_absyn", 0, "data1_absyn *", 0},{"_p_data1_absyn"},{0}};
8220 static swig_type_info _swigt__p_ZebraHandle[] = {{"_p_ZebraHandle", 0, "ZebraHandle *", 0},{"_p_ZebraHandle"},{0}};
8221 static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0},{"_p_void"},{0}};
8222 static swig_type_info _swigt__p_data1_attset[] = {{"_p_data1_attset", 0, "data1_attset *", 0},{"_p_data1_attset"},{0}};
8223 static swig_type_info _swigt__p_size_t[] = {{"_p_size_t", 0, "size_t *", 0},{"_p_size_t"},{0}};
8224 static swig_type_info _swigt__p_WRBUF[] = {{"_p_WRBUF", 0, "WRBUF *", 0},{"_p_WRBUF"},{0}};
8225 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}};
8226 static swig_type_info _swigt__p_Z_Espec1[] = {{"_p_Z_Espec1", 0, "Z_Espec1 *", 0},{"_p_Z_Espec1"},{0}};
8227 static swig_type_info _swigt__p_off_t[] = {{"_p_off_t", 0, "off_t *", 0},{"_p_off_t"},{0}};
8228 static swig_type_info _swigt__p_Odr_oid[] = {{"_p_Odr_oid", 0, "Odr_oid *", 0},{"_p_Odr_oid"},{0}};
8229 static swig_type_info _swigt__p_data1_varset[] = {{"_p_data1_varset", 0, "data1_varset *", 0},{"_p_data1_varset"},{0}};
8230 static swig_type_info _swigt__p_RetrievalRecordBuf[] = {{"_p_RetrievalRecordBuf", 0, "RetrievalRecordBuf *", 0},{"_p_RetrievalRecordBuf"},{0}};
8231 static swig_type_info _swigt__p_perl_context[] = {{"_p_perl_context", 0, "struct perl_context *", 0},{"_p_perl_context"},{0}};
8232 static swig_type_info _swigt__p_data1_node[] = {{"_p_data1_node", 0, "data1_node *", 0},{"_p_data1_node"},{0}};
8233 static swig_type_info _swigt__p_ScanObj[] = {{"IDZebra::ScanObj", 0, "ScanObj *", 0},{"IDZebra::ScanObj"},{0}};
8234 static swig_type_info _swigt__p_RetrievalObj[] = {{"IDZebra::RetrievalObj", 0, "RetrievalObj *", 0},{"IDZebra::RetrievalObj"},{0}};
8235 static swig_type_info _swigt__p_data1_tagset[] = {{"_p_data1_tagset", 0, "data1_tagset *", 0},{"_p_data1_tagset"},{0}};
8236 static swig_type_info _swigt__p_data1_tag[] = {{"_p_data1_tag", 0, "data1_tag *", 0},{"_p_data1_tag"},{0}};
8237 static swig_type_info _swigt__p_ZebraRetrievalRecord[] = {{"_p_ZebraRetrievalRecord", 0, "ZebraRetrievalRecord *", 0},{"_p_ZebraRetrievalRecord"},{0}};
8238 static swig_type_info _swigt__p_RetrievalRecord[] = {{"IDZebra::RetrievalRecord", 0, "RetrievalRecord *", 0},{"IDZebra::RetrievalRecord"},{0}};
8239 static swig_type_info _swigt__p_NMEM[] = {{"_p_NMEM", 0, "NMEM *", 0},{"_p_NMEM"},{0}};
8240 static swig_type_info _swigt__p_Z_ExplainRecord[] = {{"_p_Z_ExplainRecord", 0, "Z_ExplainRecord *", 0},{"_p_Z_ExplainRecord"},{0}};
8241 static swig_type_info _swigt__p_data1_marctab[] = {{"_p_data1_marctab", 0, "data1_marctab *", 0},{"_p_data1_marctab"},{0}};
8242 static swig_type_info _swigt__p_ZebraTransactionStatus[] = {{"IDZebra::ZebraTransactionStatus", 0, "ZebraTransactionStatus *", 0},{"IDZebra::ZebraTransactionStatus"},{0}};
8243 static swig_type_info _swigt__p_Z_BriefBib[] = {{"_p_Z_BriefBib", 0, "Z_BriefBib *", 0},{"_p_Z_BriefBib"},{0}};
8244 static swig_type_info _swigt__p_ScanEntry[] = {{"IDZebra::ScanEntry", 0, "ScanEntry *", 0},{"IDZebra::ScanEntry"},{0}};
8245 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}};
8246 static swig_type_info _swigt__p_FILE[] = {{"_p_FILE", 0, "FILE *", 0},{"_p_FILE"},{0}};
8247 static swig_type_info _swigt__p_data1_element[] = {{"_p_data1_element", 0, "data1_element *", 0},{"_p_data1_element"},{0}};
8248 static swig_type_info _swigt__p_recordGroup[] = {{"IDZebra::recordGroup", 0, "recordGroup *", 0},{"IDZebra::recordGroup"},{0}};
8249 static swig_type_info _swigt__p_int[] = {{"_p_int", 0, "int *", 0},{"_p_int"},{0}};
8250 static swig_type_info _swigt__p_data1_handle[] = {{"_p_data1_handle", 0, "data1_handle *", 0},{"_p_data1_handle"},{0}};
8251 static swig_type_info _swigt__p_p_int[] = {{"_p_p_int", 0, "int **", 0},{"_p_p_int"},{0}};
8252 static swig_type_info _swigt__p_data1_absyn_cache[] = {{"_p_data1_absyn_cache", 0, "data1_absyn_cache *", 0},{"_p_data1_absyn_cache"},{0}};
8253 static swig_type_info _swigt__p_data1_attset_cache[] = {{"_p_data1_attset_cache", 0, "data1_attset_cache *", 0},{"_p_data1_attset_cache"},{0}};
8254 static swig_type_info _swigt__p_Z_GenericRecord[] = {{"_p_Z_GenericRecord", 0, "Z_GenericRecord *", 0},{"_p_Z_GenericRecord"},{0}};
8255 static swig_type_info _swigt__p_data1_vartype[] = {{"_p_data1_vartype", 0, "data1_vartype *", 0},{"_p_data1_vartype"},{0}};
8256
8257 static swig_type_info *swig_types_initial[] = {
8258 _swigt__p_ZebraService,
8259 _swigt__p_cql_transform_t,
8260 _swigt__p_data1_esetname,
8261 _swigt__p_data1_maptab,
8262 _swigt__p_ODR,
8263 _swigt__p_f_p_void__int,
8264 _swigt__p_p_char,
8265 _swigt__p_data1_absyn,
8266 _swigt__p_ZebraHandle,
8267 _swigt__p_void,
8268 _swigt__p_data1_attset,
8269 _swigt__p_size_t,
8270 _swigt__p_WRBUF,
8271 _swigt__p_f_data1_handle_p_void_p_data1_absyn__void,
8272 _swigt__p_Z_Espec1,
8273 _swigt__p_off_t,
8274 _swigt__p_Odr_oid,
8275 _swigt__p_data1_varset,
8276 _swigt__p_RetrievalRecordBuf,
8277 _swigt__p_perl_context,
8278 _swigt__p_data1_node,
8279 _swigt__p_ScanObj,
8280 _swigt__p_RetrievalObj,
8281 _swigt__p_data1_tagset,
8282 _swigt__p_data1_tag,
8283 _swigt__p_ZebraRetrievalRecord,
8284 _swigt__p_RetrievalRecord,
8285 _swigt__p_NMEM,
8286 _swigt__p_Z_ExplainRecord,
8287 _swigt__p_data1_marctab,
8288 _swigt__p_ZebraTransactionStatus,
8289 _swigt__p_Z_BriefBib,
8290 _swigt__p_ScanEntry,
8291 _swigt__p_f_p_void_p_char_size_t__int,
8292 _swigt__p_FILE,
8293 _swigt__p_data1_element,
8294 _swigt__p_recordGroup,
8295 _swigt__p_int,
8296 _swigt__p_data1_handle,
8297 _swigt__p_p_int,
8298 _swigt__p_data1_absyn_cache,
8299 _swigt__p_data1_attset_cache,
8300 _swigt__p_Z_GenericRecord,
8301 _swigt__p_data1_vartype,
8302 0
8303 };
8304
8305
8306 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
8307
8308 static swig_constant_info swig_constants[] = {
8309 { SWIG_INT,     (char *) SWIG_prefix "LOG_FATAL", (long) 0x0001, 0, 0, 0},
8310 { SWIG_INT,     (char *) SWIG_prefix "LOG_DEBUG", (long) 0x0002, 0, 0, 0},
8311 { SWIG_INT,     (char *) SWIG_prefix "LOG_WARN", (long) 0x0004, 0, 0, 0},
8312 { SWIG_INT,     (char *) SWIG_prefix "LOG_LOG", (long) 0x0008, 0, 0, 0},
8313 { SWIG_INT,     (char *) SWIG_prefix "LOG_ERRNO", (long) 0x0010, 0, 0, 0},
8314 { SWIG_INT,     (char *) SWIG_prefix "LOG_FILE", (long) 0x0020, 0, 0, 0},
8315 { SWIG_INT,     (char *) SWIG_prefix "LOG_APP", (long) 0x0040, 0, 0, 0},
8316 { SWIG_INT,     (char *) SWIG_prefix "LOG_MALLOC", (long) 0x0080, 0, 0, 0},
8317 { SWIG_INT,     (char *) SWIG_prefix "LOG_ALL", (long) 0xff7f, 0, 0, 0},
8318 { SWIG_INT,     (char *) SWIG_prefix "LOG_DEFAULT_LEVEL", (long) (0x0001|0x0010|0x0008|0x0004), 0, 0, 0},
8319 { SWIG_INT,     (char *) SWIG_prefix "ODR_DECODE", (long) 0, 0, 0, 0},
8320 { SWIG_INT,     (char *) SWIG_prefix "ODR_ENCODE", (long) 1, 0, 0, 0},
8321 { SWIG_INT,     (char *) SWIG_prefix "ODR_PRINT", (long) 2, 0, 0, 0},
8322 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_unknown", (long) DATA1K_unknown, 0, 0, 0},
8323 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_structured", (long) DATA1K_structured, 0, 0, 0},
8324 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_string", (long) DATA1K_string, 0, 0, 0},
8325 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_numeric", (long) DATA1K_numeric, 0, 0, 0},
8326 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_bool", (long) DATA1K_bool, 0, 0, 0},
8327 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_oid", (long) DATA1K_oid, 0, 0, 0},
8328 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_generalizedtime", (long) DATA1K_generalizedtime, 0, 0, 0},
8329 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_intunit", (long) DATA1K_intunit, 0, 0, 0},
8330 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_int", (long) DATA1K_int, 0, 0, 0},
8331 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_octetstring", (long) DATA1K_octetstring, 0, 0, 0},
8332 { SWIG_INT,     (char *) SWIG_prefix "DATA1K_null", (long) DATA1K_null, 0, 0, 0},
8333 { SWIG_INT,     (char *) SWIG_prefix "DATA1T_numeric", (long) 1, 0, 0, 0},
8334 { SWIG_INT,     (char *) SWIG_prefix "DATA1T_string", (long) 2, 0, 0, 0},
8335 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_root", (long) 1, 0, 0, 0},
8336 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_tag", (long) 2, 0, 0, 0},
8337 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_data", (long) 3, 0, 0, 0},
8338 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_variant", (long) 4, 0, 0, 0},
8339 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_comment", (long) 5, 0, 0, 0},
8340 { SWIG_INT,     (char *) SWIG_prefix "DATA1N_preprocess", (long) 6, 0, 0, 0},
8341 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_inctxt", (long) 1, 0, 0, 0},
8342 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_incbin", (long) 2, 0, 0, 0},
8343 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_text", (long) 3, 0, 0, 0},
8344 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_num", (long) 4, 0, 0, 0},
8345 { SWIG_INT,     (char *) SWIG_prefix "DATA1I_oid", (long) 5, 0, 0, 0},
8346 { SWIG_INT,     (char *) SWIG_prefix "DATA1_LOCALDATA", (long) 12, 0, 0, 0},
8347 { SWIG_INT,     (char *) SWIG_prefix "DATA1_FLAG_XML", (long) 1, 0, 0, 0},
8348 {0}
8349 };
8350 #ifdef __cplusplus
8351 }
8352 #endif
8353 static swig_variable_info swig_variables[] = {
8354 {0}
8355 };
8356 static swig_command_info swig_commands[] = {
8357 {"IDZebrac::recordGroup_groupName_set", _wrap_recordGroup_groupName_set},
8358 {"IDZebrac::recordGroup_groupName_get", _wrap_recordGroup_groupName_get},
8359 {"IDZebrac::recordGroup_databaseName_set", _wrap_recordGroup_databaseName_set},
8360 {"IDZebrac::recordGroup_databaseName_get", _wrap_recordGroup_databaseName_get},
8361 {"IDZebrac::recordGroup_path_set", _wrap_recordGroup_path_set},
8362 {"IDZebrac::recordGroup_path_get", _wrap_recordGroup_path_get},
8363 {"IDZebrac::recordGroup_recordId_set", _wrap_recordGroup_recordId_set},
8364 {"IDZebrac::recordGroup_recordId_get", _wrap_recordGroup_recordId_get},
8365 {"IDZebrac::recordGroup_recordType_set", _wrap_recordGroup_recordType_set},
8366 {"IDZebrac::recordGroup_recordType_get", _wrap_recordGroup_recordType_get},
8367 {"IDZebrac::recordGroup_flagStoreData_set", _wrap_recordGroup_flagStoreData_set},
8368 {"IDZebrac::recordGroup_flagStoreData_get", _wrap_recordGroup_flagStoreData_get},
8369 {"IDZebrac::recordGroup_flagStoreKeys_set", _wrap_recordGroup_flagStoreKeys_set},
8370 {"IDZebrac::recordGroup_flagStoreKeys_get", _wrap_recordGroup_flagStoreKeys_get},
8371 {"IDZebrac::recordGroup_flagRw_set", _wrap_recordGroup_flagRw_set},
8372 {"IDZebrac::recordGroup_flagRw_get", _wrap_recordGroup_flagRw_get},
8373 {"IDZebrac::recordGroup_fileVerboseLimit_set", _wrap_recordGroup_fileVerboseLimit_set},
8374 {"IDZebrac::recordGroup_fileVerboseLimit_get", _wrap_recordGroup_fileVerboseLimit_get},
8375 {"IDZebrac::recordGroup_databaseNamePath_set", _wrap_recordGroup_databaseNamePath_set},
8376 {"IDZebrac::recordGroup_databaseNamePath_get", _wrap_recordGroup_databaseNamePath_get},
8377 {"IDZebrac::recordGroup_explainDatabase_set", _wrap_recordGroup_explainDatabase_set},
8378 {"IDZebrac::recordGroup_explainDatabase_get", _wrap_recordGroup_explainDatabase_get},
8379 {"IDZebrac::recordGroup_followLinks_set", _wrap_recordGroup_followLinks_set},
8380 {"IDZebrac::recordGroup_followLinks_get", _wrap_recordGroup_followLinks_get},
8381 {"IDZebrac::new_recordGroup", _wrap_new_recordGroup},
8382 {"IDZebrac::delete_recordGroup", _wrap_delete_recordGroup},
8383 {"IDZebrac::RetrievalObj_noOfRecords_set", _wrap_RetrievalObj_noOfRecords_set},
8384 {"IDZebrac::RetrievalObj_noOfRecords_get", _wrap_RetrievalObj_noOfRecords_get},
8385 {"IDZebrac::RetrievalObj_records_set", _wrap_RetrievalObj_records_set},
8386 {"IDZebrac::RetrievalObj_records_get", _wrap_RetrievalObj_records_get},
8387 {"IDZebrac::new_RetrievalObj", _wrap_new_RetrievalObj},
8388 {"IDZebrac::delete_RetrievalObj", _wrap_delete_RetrievalObj},
8389 {"IDZebrac::RetrievalRecord_errCode_set", _wrap_RetrievalRecord_errCode_set},
8390 {"IDZebrac::RetrievalRecord_errCode_get", _wrap_RetrievalRecord_errCode_get},
8391 {"IDZebrac::RetrievalRecord_errString_set", _wrap_RetrievalRecord_errString_set},
8392 {"IDZebrac::RetrievalRecord_errString_get", _wrap_RetrievalRecord_errString_get},
8393 {"IDZebrac::RetrievalRecord_position_set", _wrap_RetrievalRecord_position_set},
8394 {"IDZebrac::RetrievalRecord_position_get", _wrap_RetrievalRecord_position_get},
8395 {"IDZebrac::RetrievalRecord_base_set", _wrap_RetrievalRecord_base_set},
8396 {"IDZebrac::RetrievalRecord_base_get", _wrap_RetrievalRecord_base_get},
8397 {"IDZebrac::RetrievalRecord_sysno_set", _wrap_RetrievalRecord_sysno_set},
8398 {"IDZebrac::RetrievalRecord_sysno_get", _wrap_RetrievalRecord_sysno_get},
8399 {"IDZebrac::RetrievalRecord_score_set", _wrap_RetrievalRecord_score_set},
8400 {"IDZebrac::RetrievalRecord_score_get", _wrap_RetrievalRecord_score_get},
8401 {"IDZebrac::RetrievalRecord_format_set", _wrap_RetrievalRecord_format_set},
8402 {"IDZebrac::RetrievalRecord_format_get", _wrap_RetrievalRecord_format_get},
8403 {"IDZebrac::RetrievalRecord_buf_set", _wrap_RetrievalRecord_buf_set},
8404 {"IDZebrac::RetrievalRecord_buf_get", _wrap_RetrievalRecord_buf_get},
8405 {"IDZebrac::new_RetrievalRecord", _wrap_new_RetrievalRecord},
8406 {"IDZebrac::delete_RetrievalRecord", _wrap_delete_RetrievalRecord},
8407 {"IDZebrac::ScanEntry_occurrences_set", _wrap_ScanEntry_occurrences_set},
8408 {"IDZebrac::ScanEntry_occurrences_get", _wrap_ScanEntry_occurrences_get},
8409 {"IDZebrac::ScanEntry_term_set", _wrap_ScanEntry_term_set},
8410 {"IDZebrac::ScanEntry_term_get", _wrap_ScanEntry_term_get},
8411 {"IDZebrac::new_ScanEntry", _wrap_new_ScanEntry},
8412 {"IDZebrac::delete_ScanEntry", _wrap_delete_ScanEntry},
8413 {"IDZebrac::ScanObj_num_entries_set", _wrap_ScanObj_num_entries_set},
8414 {"IDZebrac::ScanObj_num_entries_get", _wrap_ScanObj_num_entries_get},
8415 {"IDZebrac::ScanObj_position_set", _wrap_ScanObj_position_set},
8416 {"IDZebrac::ScanObj_position_get", _wrap_ScanObj_position_get},
8417 {"IDZebrac::ScanObj_is_partial_set", _wrap_ScanObj_is_partial_set},
8418 {"IDZebrac::ScanObj_is_partial_get", _wrap_ScanObj_is_partial_get},
8419 {"IDZebrac::ScanObj_entries_set", _wrap_ScanObj_entries_set},
8420 {"IDZebrac::ScanObj_entries_get", _wrap_ScanObj_entries_get},
8421 {"IDZebrac::new_ScanObj", _wrap_new_ScanObj},
8422 {"IDZebrac::delete_ScanObj", _wrap_delete_ScanObj},
8423 {"IDZebrac::ZebraTransactionStatus_processed_set", _wrap_ZebraTransactionStatus_processed_set},
8424 {"IDZebrac::ZebraTransactionStatus_processed_get", _wrap_ZebraTransactionStatus_processed_get},
8425 {"IDZebrac::ZebraTransactionStatus_inserted_set", _wrap_ZebraTransactionStatus_inserted_set},
8426 {"IDZebrac::ZebraTransactionStatus_inserted_get", _wrap_ZebraTransactionStatus_inserted_get},
8427 {"IDZebrac::ZebraTransactionStatus_updated_set", _wrap_ZebraTransactionStatus_updated_set},
8428 {"IDZebrac::ZebraTransactionStatus_updated_get", _wrap_ZebraTransactionStatus_updated_get},
8429 {"IDZebrac::ZebraTransactionStatus_deleted_set", _wrap_ZebraTransactionStatus_deleted_set},
8430 {"IDZebrac::ZebraTransactionStatus_deleted_get", _wrap_ZebraTransactionStatus_deleted_get},
8431 {"IDZebrac::ZebraTransactionStatus_utime_set", _wrap_ZebraTransactionStatus_utime_set},
8432 {"IDZebrac::ZebraTransactionStatus_utime_get", _wrap_ZebraTransactionStatus_utime_get},
8433 {"IDZebrac::ZebraTransactionStatus_stime_set", _wrap_ZebraTransactionStatus_stime_set},
8434 {"IDZebrac::ZebraTransactionStatus_stime_get", _wrap_ZebraTransactionStatus_stime_get},
8435 {"IDZebrac::new_ZebraTransactionStatus", _wrap_new_ZebraTransactionStatus},
8436 {"IDZebrac::delete_ZebraTransactionStatus", _wrap_delete_ZebraTransactionStatus},
8437 {"IDZebrac::DESTROY", _wrap_DESTROY},
8438 {"IDZebrac::logLevel", _wrap_logLevel},
8439 {"IDZebrac::logFile", _wrap_logFile},
8440 {"IDZebrac::logMsg", _wrap_logMsg},
8441 {"IDZebrac::odr_createmem", _wrap_odr_createmem},
8442 {"IDZebrac::odr_reset", _wrap_odr_reset},
8443 {"IDZebrac::odr_destroy", _wrap_odr_destroy},
8444 {"IDZebrac::odr_malloc", _wrap_odr_malloc},
8445 {"IDZebrac::start", _wrap_start},
8446 {"IDZebrac::open", _wrap_open},
8447 {"IDZebrac::close", _wrap_close},
8448 {"IDZebrac::stop", _wrap_stop},
8449 {"IDZebrac::errCode", _wrap_errCode},
8450 {"IDZebrac::errString", _wrap_errString},
8451 {"IDZebrac::errAdd", _wrap_errAdd},
8452 {"IDZebrac::init_recordGroup", _wrap_init_recordGroup},
8453 {"IDZebrac::res_get_recordGroup", _wrap_res_get_recordGroup},
8454 {"IDZebrac::set_group", _wrap_set_group},
8455 {"IDZebrac::select_database", _wrap_select_database},
8456 {"IDZebrac::select_databases", _wrap_select_databases},
8457 {"IDZebrac::begin_trans", _wrap_begin_trans},
8458 {"IDZebrac::end_trans", _wrap_end_trans},
8459 {"IDZebrac::trans_no", _wrap_trans_no},
8460 {"IDZebrac::begin_read", _wrap_begin_read},
8461 {"IDZebrac::zts_test", _wrap_zts_test},
8462 {"IDZebrac::end_read", _wrap_end_read},
8463 {"IDZebrac::commit", _wrap_commit},
8464 {"IDZebrac::get_shadow_enable", _wrap_get_shadow_enable},
8465 {"IDZebrac::set_shadow_enable", _wrap_set_shadow_enable},
8466 {"IDZebrac::init", _wrap_init},
8467 {"IDZebrac::compact", _wrap_compact},
8468 {"IDZebrac::repository_update", _wrap_repository_update},
8469 {"IDZebrac::repository_delete", _wrap_repository_delete},
8470 {"IDZebrac::repository_show", _wrap_repository_show},
8471 {"IDZebrac::update_record", _wrap_update_record},
8472 {"IDZebrac::delete_record", _wrap_delete_record},
8473 {"IDZebrac::search_PQF", _wrap_search_PQF},
8474 {"IDZebrac::cql_transform_open_fname", _wrap_cql_transform_open_fname},
8475 {"IDZebrac::cql_transform_close", _wrap_cql_transform_close},
8476 {"IDZebrac::cql_transform_error", _wrap_cql_transform_error},
8477 {"IDZebrac::cql2pqf", _wrap_cql2pqf},
8478 {"IDZebrac::records_retrieve", _wrap_records_retrieve},
8479 {"IDZebrac::record_retrieve", _wrap_record_retrieve},
8480 {"IDZebrac::sort", _wrap_sort},
8481 {"IDZebrac::scan_PQF", _wrap_scan_PQF},
8482 {"IDZebrac::getScanEntry", _wrap_getScanEntry},
8483 {"IDZebrac::nmem_create", _wrap_nmem_create},
8484 {"IDZebrac::nmem_destroy", _wrap_nmem_destroy},
8485 {"IDZebrac::data1_create", _wrap_data1_create},
8486 {"IDZebrac::data1_createx", _wrap_data1_createx},
8487 {"IDZebrac::data1_destroy", _wrap_data1_destroy},
8488 {"IDZebrac::get_parent_tag", _wrap_get_parent_tag},
8489 {"IDZebrac::data1_read_node", _wrap_data1_read_node},
8490 {"IDZebrac::data1_read_nodex", _wrap_data1_read_nodex},
8491 {"IDZebrac::data1_read_record", _wrap_data1_read_record},
8492 {"IDZebrac::data1_read_absyn", _wrap_data1_read_absyn},
8493 {"IDZebrac::data1_gettagbynum", _wrap_data1_gettagbynum},
8494 {"IDZebrac::data1_empty_tagset", _wrap_data1_empty_tagset},
8495 {"IDZebrac::data1_read_tagset", _wrap_data1_read_tagset},
8496 {"IDZebrac::data1_getelementbytagname", _wrap_data1_getelementbytagname},
8497 {"IDZebrac::data1_nodetogr", _wrap_data1_nodetogr},
8498 {"IDZebrac::data1_gettagbyname", _wrap_data1_gettagbyname},
8499 {"IDZebrac::data1_free_tree", _wrap_data1_free_tree},
8500 {"IDZebrac::data1_nodetobuf", _wrap_data1_nodetobuf},
8501 {"IDZebrac::data1_mk_tag_data_wd", _wrap_data1_mk_tag_data_wd},
8502 {"IDZebrac::data1_mk_tag_data", _wrap_data1_mk_tag_data},
8503 {"IDZebrac::data1_maptype", _wrap_data1_maptype},
8504 {"IDZebrac::data1_read_varset", _wrap_data1_read_varset},
8505 {"IDZebrac::data1_getvartypebyct", _wrap_data1_getvartypebyct},
8506 {"IDZebrac::data1_read_espec1", _wrap_data1_read_espec1},
8507 {"IDZebrac::data1_doespec1", _wrap_data1_doespec1},
8508 {"IDZebrac::data1_getesetbyname", _wrap_data1_getesetbyname},
8509 {"IDZebrac::data1_getelementbyname", _wrap_data1_getelementbyname},
8510 {"IDZebrac::data1_mk_node2", _wrap_data1_mk_node2},
8511 {"IDZebrac::data1_mk_tag", _wrap_data1_mk_tag},
8512 {"IDZebrac::data1_mk_tag_n", _wrap_data1_mk_tag_n},
8513 {"IDZebrac::data1_tag_add_attr", _wrap_data1_tag_add_attr},
8514 {"IDZebrac::data1_mk_text_n", _wrap_data1_mk_text_n},
8515 {"IDZebrac::data1_mk_text_nf", _wrap_data1_mk_text_nf},
8516 {"IDZebrac::data1_mk_text", _wrap_data1_mk_text},
8517 {"IDZebrac::data1_mk_comment_n", _wrap_data1_mk_comment_n},
8518 {"IDZebrac::data1_mk_comment", _wrap_data1_mk_comment},
8519 {"IDZebrac::data1_mk_preprocess", _wrap_data1_mk_preprocess},
8520 {"IDZebrac::data1_mk_root", _wrap_data1_mk_root},
8521 {"IDZebrac::data1_set_root", _wrap_data1_set_root},
8522 {"IDZebrac::data1_mk_tag_data_int", _wrap_data1_mk_tag_data_int},
8523 {"IDZebrac::data1_mk_tag_data_oid", _wrap_data1_mk_tag_data_oid},
8524 {"IDZebrac::data1_mk_tag_data_text", _wrap_data1_mk_tag_data_text},
8525 {"IDZebrac::data1_mk_tag_data_text_uni", _wrap_data1_mk_tag_data_text_uni},
8526 {"IDZebrac::data1_get_absyn", _wrap_data1_get_absyn},
8527 {"IDZebrac::data1_search_tag", _wrap_data1_search_tag},
8528 {"IDZebrac::data1_mk_tag_uni", _wrap_data1_mk_tag_uni},
8529 {"IDZebrac::data1_get_attset", _wrap_data1_get_attset},
8530 {"IDZebrac::data1_read_maptab", _wrap_data1_read_maptab},
8531 {"IDZebrac::data1_map_record", _wrap_data1_map_record},
8532 {"IDZebrac::data1_read_marctab", _wrap_data1_read_marctab},
8533 {"IDZebrac::data1_nodetomarc", _wrap_data1_nodetomarc},
8534 {"IDZebrac::data1_nodetoidsgml", _wrap_data1_nodetoidsgml},
8535 {"IDZebrac::data1_nodetoexplain", _wrap_data1_nodetoexplain},
8536 {"IDZebrac::data1_nodetosummary", _wrap_data1_nodetosummary},
8537 {"IDZebrac::data1_nodetosoif", _wrap_data1_nodetosoif},
8538 {"IDZebrac::data1_get_wrbuf", _wrap_data1_get_wrbuf},
8539 {"IDZebrac::data1_get_read_buf", _wrap_data1_get_read_buf},
8540 {"IDZebrac::data1_get_map_buf", _wrap_data1_get_map_buf},
8541 {"IDZebrac::data1_absyn_cache_get", _wrap_data1_absyn_cache_get},
8542 {"IDZebrac::data1_attset_cache_get", _wrap_data1_attset_cache_get},
8543 {"IDZebrac::data1_nmem_get", _wrap_data1_nmem_get},
8544 {"IDZebrac::data1_pr_tree", _wrap_data1_pr_tree},
8545 {"IDZebrac::data1_print_tree", _wrap_data1_print_tree},
8546 {"IDZebrac::data1_insert_string", _wrap_data1_insert_string},
8547 {"IDZebrac::data1_insert_string_n", _wrap_data1_insert_string_n},
8548 {"IDZebrac::data1_read_sgml", _wrap_data1_read_sgml},
8549 {"IDZebrac::data1_absyn_trav", _wrap_data1_absyn_trav},
8550 {"IDZebrac::data1_attset_search_id", _wrap_data1_attset_search_id},
8551 {"IDZebrac::data1_getNodeValue", _wrap_data1_getNodeValue},
8552 {"IDZebrac::data1_LookupNode", _wrap_data1_LookupNode},
8553 {"IDZebrac::data1_CountOccurences", _wrap_data1_CountOccurences},
8554 {"IDZebrac::data1_path_fopen", _wrap_data1_path_fopen},
8555 {"IDZebrac::data1_set_tabpath", _wrap_data1_set_tabpath},
8556 {"IDZebrac::data1_set_tabroot", _wrap_data1_set_tabroot},
8557 {"IDZebrac::data1_get_tabpath", _wrap_data1_get_tabpath},
8558 {"IDZebrac::data1_get_tabroot", _wrap_data1_get_tabroot},
8559 {"IDZebrac::grs_perl_readf", _wrap_grs_perl_readf},
8560 {"IDZebrac::grs_perl_readline", _wrap_grs_perl_readline},
8561 {"IDZebrac::grs_perl_getc", _wrap_grs_perl_getc},
8562 {"IDZebrac::grs_perl_seekf", _wrap_grs_perl_seekf},
8563 {"IDZebrac::grs_perl_tellf", _wrap_grs_perl_tellf},
8564 {"IDZebrac::grs_perl_endf", _wrap_grs_perl_endf},
8565 {"IDZebrac::grs_perl_get_dh", _wrap_grs_perl_get_dh},
8566 {"IDZebrac::grs_perl_get_mem", _wrap_grs_perl_get_mem},
8567 {"IDZebrac::grs_perl_set_res", _wrap_grs_perl_set_res},
8568 {0,0}
8569 };
8570
8571 #ifdef __cplusplus
8572 extern "C"
8573 #endif
8574
8575 XS(SWIG_init) {
8576     dXSARGS;
8577     int i;
8578     static int _init = 0;
8579     if (!_init) {
8580         for (i = 0; swig_types_initial[i]; i++) {
8581             swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
8582         }
8583         _init = 1;
8584     }
8585
8586     /* Install commands */
8587     for (i = 0; swig_commands[i].name; i++) {
8588         newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
8589     }
8590
8591     /* Install variables */
8592     for (i = 0; swig_variables[i].name; i++) {
8593         SV *sv;
8594         sv = perl_get_sv((char*) swig_variables[i].name, TRUE | 0x2);
8595         if (swig_variables[i].type) {
8596             SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
8597         }else {
8598             sv_setiv(sv,(IV) 0);
8599         }
8600         swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
8601     }
8602
8603     /* Install constant */
8604     for (i = 0; swig_constants[i].type; i++) {
8605         SV *sv;
8606         sv = perl_get_sv((char*)swig_constants[i].name, TRUE | 0x2);
8607         switch(swig_constants[i].type) {
8608             case SWIG_INT:
8609             sv_setiv(sv, (IV) swig_constants[i].lvalue);
8610             break;
8611             case SWIG_FLOAT:
8612             sv_setnv(sv, (double) swig_constants[i].dvalue);
8613             break;
8614             case SWIG_STRING:
8615             sv_setpv(sv, (char *) swig_constants[i].pvalue);
8616             break;
8617             case SWIG_POINTER:
8618             SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
8619             break;
8620             case SWIG_BINARY:
8621             /*      obj = SWIG_NewPackedObj(swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype)); */
8622             break;
8623             default:
8624             break;
8625         }
8626         SvREADONLY_on(sv);
8627     }
8628
8629     SWIG_TypeClientData(SWIGTYPE_p_recordGroup, (void*) "IDZebra::recordGroup");
8630     SWIG_TypeClientData(SWIGTYPE_p_RetrievalObj, (void*) "IDZebra::RetrievalObj");
8631     SWIG_TypeClientData(SWIGTYPE_p_RetrievalRecord, (void*) "IDZebra::RetrievalRecord");
8632     SWIG_TypeClientData(SWIGTYPE_p_ScanEntry, (void*) "IDZebra::ScanEntry");
8633     SWIG_TypeClientData(SWIGTYPE_p_ScanObj, (void*) "IDZebra::ScanObj");
8634     SWIG_TypeClientData(SWIGTYPE_p_ZebraTransactionStatus, (void*) "IDZebra::ZebraTransactionStatus");
8635     ST(0) = &PL_sv_yes;
8636     XSRETURN(1);
8637 }
8638