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