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