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