X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=perl%2FIDZebra_wrap.c;h=e147810f13b9c1f2856f38c641a71ed5aaa99e32;hb=52551bf774d771a0422a401946fd0c5ee3788f34;hp=6f8fe930514f8f0a5e724ce7554927c91fe39634;hpb=110403896e7928d0f079c377f7f26192bfb13850;p=idzebra-moved-to-github.git diff --git a/perl/IDZebra_wrap.c b/perl/IDZebra_wrap.c index 6f8fe93..e147810 100644 --- a/perl/IDZebra_wrap.c +++ b/perl/IDZebra_wrap.c @@ -212,7 +212,7 @@ SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { * perl5.swg * * Perl5 runtime library - * $Header: /home/cvsroot/idis/perl/Attic/IDZebra_wrap.c,v 1.3 2002-11-18 13:16:43 pop Exp $ + * $Header: /home/cvsroot/idis/perl/Attic/IDZebra_wrap.c,v 1.16 2003-03-13 04:25:17 pop Exp $ * ----------------------------------------------------------------------------- */ #define SWIGPERL @@ -499,12 +499,12 @@ static void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (C /* -------- TYPES TABLE (BEGIN) -------- */ #define SWIGTYPE_p_ZebraService swig_types[0] -#define SWIGTYPE_p_data1_esetname swig_types[1] -#define SWIGTYPE_p_data1_maptab swig_types[2] -#define SWIGTYPE_p_ODR swig_types[3] -#define SWIGTYPE_p_f_p_void__int swig_types[4] -#define SWIGTYPE_p_p_char swig_types[5] -#define SWIGTYPE_p_oid_value swig_types[6] +#define SWIGTYPE_p_cql_transform_t swig_types[1] +#define SWIGTYPE_p_data1_esetname swig_types[2] +#define SWIGTYPE_p_data1_maptab swig_types[3] +#define SWIGTYPE_p_ODR swig_types[4] +#define SWIGTYPE_p_f_p_void__int swig_types[5] +#define SWIGTYPE_p_p_char swig_types[6] #define SWIGTYPE_p_data1_absyn swig_types[7] #define SWIGTYPE_p_ZebraHandle swig_types[8] #define SWIGTYPE_p_void swig_types[9] @@ -519,28 +519,30 @@ static void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (C #define SWIGTYPE_p_RetrievalRecordBuf swig_types[18] #define SWIGTYPE_p_perl_context swig_types[19] #define SWIGTYPE_p_data1_node swig_types[20] -#define SWIGTYPE_p_RetrievalObj swig_types[21] -#define SWIGTYPE_p_data1_tagset swig_types[22] -#define SWIGTYPE_p_data1_tag swig_types[23] -#define SWIGTYPE_p_Z_ExplainRecord swig_types[24] +#define SWIGTYPE_p_ScanObj swig_types[21] +#define SWIGTYPE_p_RetrievalObj swig_types[22] +#define SWIGTYPE_p_data1_tagset swig_types[23] +#define SWIGTYPE_p_data1_tag swig_types[24] #define SWIGTYPE_p_ZebraRetrievalRecord swig_types[25] #define SWIGTYPE_p_RetrievalRecord swig_types[26] #define SWIGTYPE_p_NMEM swig_types[27] -#define SWIGTYPE_p_data1_marctab swig_types[28] -#define SWIGTYPE_p_Z_BriefBib swig_types[29] -#define SWIGTYPE_p_ScanEntry swig_types[30] -#define SWIGTYPE_p_f_p_void_p_char_size_t__int swig_types[31] -#define SWIGTYPE_p_FILE swig_types[32] -#define SWIGTYPE_p_data1_element swig_types[33] -#define SWIGTYPE_p_recordGroup swig_types[34] -#define SWIGTYPE_p_int swig_types[35] -#define SWIGTYPE_p_data1_handle swig_types[36] -#define SWIGTYPE_p_p_int swig_types[37] -#define SWIGTYPE_p_data1_absyn_cache swig_types[38] -#define SWIGTYPE_p_data1_attset_cache swig_types[39] -#define SWIGTYPE_p_Z_GenericRecord swig_types[40] -#define SWIGTYPE_p_data1_vartype swig_types[41] -static swig_type_info *swig_types[43]; +#define SWIGTYPE_p_Z_ExplainRecord swig_types[28] +#define SWIGTYPE_p_data1_marctab swig_types[29] +#define SWIGTYPE_p_ZebraTransactionStatus swig_types[30] +#define SWIGTYPE_p_Z_BriefBib swig_types[31] +#define SWIGTYPE_p_scanEntry swig_types[32] +#define SWIGTYPE_p_f_p_void_p_char_size_t__int swig_types[33] +#define SWIGTYPE_p_FILE swig_types[34] +#define SWIGTYPE_p_data1_element swig_types[35] +#define SWIGTYPE_p_recordGroup swig_types[36] +#define SWIGTYPE_p_int swig_types[37] +#define SWIGTYPE_p_data1_handle swig_types[38] +#define SWIGTYPE_p_p_int swig_types[39] +#define SWIGTYPE_p_data1_absyn_cache swig_types[40] +#define SWIGTYPE_p_data1_attset_cache swig_types[41] +#define SWIGTYPE_p_Z_GenericRecord swig_types[42] +#define SWIGTYPE_p_data1_vartype swig_types[43] +static swig_type_info *swig_types[45]; /* -------- TYPES TABLE (END) -------- */ @@ -564,10 +566,10 @@ SWIGEXPORT(void) SWIG_init (CV *cv, CPerlObj *); #include "zebraapi.h" -#include "zebra_api_ext.h" #include "zebra_perl.h" #include "data1.h" #include "yaz/odr.h" +#include "yaz/cql.h" #ifdef PERL_OBJECT #define MAGIC_CLASS _wrap_IDZebra_var:: @@ -1795,12 +1797,128 @@ XS(_wrap_RetrievalRecord_base_get) { } +XS(_wrap_RetrievalRecord_sysno_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + RetrievalRecord *arg1 ; + int arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: RetrievalRecord_sysno_set(self,sysno);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) { + SWIG_croak("Type error in argument 1 of RetrievalRecord_sysno_set. Expected _p_RetrievalRecord"); + } + } + arg2 = (int) SvIV(ST(1)); + if (arg1) (arg1)->sysno = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_RetrievalRecord_sysno_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + RetrievalRecord *arg1 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: RetrievalRecord_sysno_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) { + SWIG_croak("Type error in argument 1 of RetrievalRecord_sysno_get. Expected _p_RetrievalRecord"); + } + } + result = (int) ((arg1)->sysno); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_RetrievalRecord_score_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + RetrievalRecord *arg1 ; + int arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: RetrievalRecord_score_set(self,score);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) { + SWIG_croak("Type error in argument 1 of RetrievalRecord_score_set. Expected _p_RetrievalRecord"); + } + } + arg2 = (int) SvIV(ST(1)); + if (arg1) (arg1)->score = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_RetrievalRecord_score_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + RetrievalRecord *arg1 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: RetrievalRecord_score_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_RetrievalRecord,0) < 0) { + SWIG_croak("Type error in argument 1 of RetrievalRecord_score_get. Expected _p_RetrievalRecord"); + } + } + result = (int) ((arg1)->score); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + XS(_wrap_RetrievalRecord_format_set) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; { RetrievalRecord *arg1 ; - oid_value arg2 ; + char *arg2 ; int argvi = 0; dXSARGS; @@ -1812,15 +1930,13 @@ XS(_wrap_RetrievalRecord_format_set) { SWIG_croak("Type error in argument 1 of RetrievalRecord_format_set. Expected _p_RetrievalRecord"); } } + if (!SvOK((SV*) ST(1))) arg2 = 0; + else arg2 = (char *) SvPV(ST(1), PL_na); { - oid_value * argp; - if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_oid_value,0) < 0) { - SWIG_croak("Type error in argument 2 of RetrievalRecord_format_set. Expected _p_oid_value"); - } - arg2 = *argp; + if (arg1->format) free((char*)arg1->format); + arg1->format = (char *) malloc(strlen(arg2)+1); + strcpy((char*)arg1->format,arg2); } - if (arg1) (arg1)->format = arg2; - XSRETURN(argvi); fail: @@ -1835,7 +1951,7 @@ XS(_wrap_RetrievalRecord_format_get) { const char *_swigerr = _swigmsg; { RetrievalRecord *arg1 ; - oid_value result; + char *result; int argvi = 0; dXSARGS; @@ -1847,13 +1963,13 @@ XS(_wrap_RetrievalRecord_format_get) { SWIG_croak("Type error in argument 1 of RetrievalRecord_format_get. Expected _p_RetrievalRecord"); } } - result = ((arg1)->format); + result = (char *) ((arg1)->format); - { - oid_value * resultobj = (oid_value *) malloc(sizeof(oid_value)); - memmove(resultobj, &result, sizeof(oid_value)); - ST(argvi) = sv_newmortal(); - SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_oid_value,0); + ST(argvi) = sv_newmortal(); + if (result) { + sv_setpv((SV*)ST(argvi++), (char *) result); + }else { + sv_setsv((SV*)ST(argvi++), &PL_sv_undef); } XSRETURN(argvi); fail: @@ -1916,7 +2032,11 @@ XS(_wrap_RetrievalRecord_buf_get) { result = (RetrievalRecordBuf *) ((arg1)->buf); { - ST(argvi) = newSVpv(result->buf,result->len); + if (result->len) { + ST(argvi) = newSVpv(result->buf,result->len); + }else { + ST(argvi) = newSVpv("",0); + } sv_2mortal(ST(argvi)); argvi++; } @@ -1978,21 +2098,21 @@ XS(_wrap_delete_RetrievalRecord) { } -XS(_wrap_ScanEntry_occurrences_set) { +XS(_wrap_scanEntry_occurrences_set) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; { - ScanEntry *arg1 ; + scanEntry *arg1 ; int arg2 ; int argvi = 0; dXSARGS; if ((items < 2) || (items > 2)) { - SWIG_croak("Usage: ScanEntry_occurrences_set(self,occurrences);"); + SWIG_croak("Usage: scanEntry_occurrences_set(self,occurrences);"); } { - if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanEntry,0) < 0) { - SWIG_croak("Type error in argument 1 of ScanEntry_occurrences_set. Expected _p_ScanEntry"); + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) { + SWIG_croak("Type error in argument 1 of scanEntry_occurrences_set. Expected _p_scanEntry"); } } arg2 = (int) SvIV(ST(1)); @@ -2007,21 +2127,21 @@ XS(_wrap_ScanEntry_occurrences_set) { } -XS(_wrap_ScanEntry_occurrences_get) { +XS(_wrap_scanEntry_occurrences_get) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; { - ScanEntry *arg1 ; + scanEntry *arg1 ; int result; int argvi = 0; dXSARGS; if ((items < 1) || (items > 1)) { - SWIG_croak("Usage: ScanEntry_occurrences_get(self);"); + SWIG_croak("Usage: scanEntry_occurrences_get(self);"); } { - if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanEntry,0) < 0) { - SWIG_croak("Type error in argument 1 of ScanEntry_occurrences_get. Expected _p_ScanEntry"); + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) { + SWIG_croak("Type error in argument 1 of scanEntry_occurrences_get. Expected _p_scanEntry"); } } result = (int) ((arg1)->occurrences); @@ -2036,30 +2156,718 @@ XS(_wrap_ScanEntry_occurrences_get) { } -XS(_wrap_ScanEntry_term_set) { +XS(_wrap_scanEntry_term_set) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; { - ScanEntry *arg1 ; + scanEntry *arg1 ; char *arg2 ; int argvi = 0; dXSARGS; if ((items < 2) || (items > 2)) { - SWIG_croak("Usage: ScanEntry_term_set(self,term);"); + SWIG_croak("Usage: scanEntry_term_set(self,term);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) { + SWIG_croak("Type error in argument 1 of scanEntry_term_set. Expected _p_scanEntry"); + } + } + if (!SvOK((SV*) ST(1))) arg2 = 0; + else arg2 = (char *) SvPV(ST(1), PL_na); + { + if (arg1->term) free((char*)arg1->term); + arg1->term = (char *) malloc(strlen(arg2)+1); + strcpy((char*)arg1->term,arg2); + } + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_scanEntry_term_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + scanEntry *arg1 ; + char *result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: scanEntry_term_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) { + SWIG_croak("Type error in argument 1 of scanEntry_term_get. Expected _p_scanEntry"); + } + } + result = (char *) ((arg1)->term); + + ST(argvi) = sv_newmortal(); + if (result) { + sv_setpv((SV*)ST(argvi++), (char *) result); + }else { + sv_setsv((SV*)ST(argvi++), &PL_sv_undef); + } + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_new_scanEntry) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + scanEntry *result; + int argvi = 0; + dXSARGS; + + if ((items < 0) || (items > 0)) { + SWIG_croak("Usage: new_scanEntry();"); + } + result = (scanEntry *)(scanEntry *) calloc(1, sizeof(scanEntry)); + + ST(argvi) = sv_newmortal(); + SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_scanEntry,0); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_delete_scanEntry) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + scanEntry *arg1 ; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: delete_scanEntry(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_scanEntry,0) < 0) { + SWIG_croak("Type error in argument 1 of delete_scanEntry. Expected _p_scanEntry"); + } + } + free((char *) arg1); + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ScanObj_num_entries_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *arg1 ; + int arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: ScanObj_num_entries_set(self,num_entries);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 1 of ScanObj_num_entries_set. Expected _p_ScanObj"); + } + } + arg2 = (int) SvIV(ST(1)); + if (arg1) (arg1)->num_entries = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ScanObj_num_entries_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *arg1 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: ScanObj_num_entries_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 1 of ScanObj_num_entries_get. Expected _p_ScanObj"); + } + } + result = (int) ((arg1)->num_entries); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ScanObj_position_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *arg1 ; + int arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: ScanObj_position_set(self,position);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 1 of ScanObj_position_set. Expected _p_ScanObj"); + } + } + arg2 = (int) SvIV(ST(1)); + if (arg1) (arg1)->position = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ScanObj_position_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *arg1 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: ScanObj_position_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 1 of ScanObj_position_get. Expected _p_ScanObj"); + } + } + result = (int) ((arg1)->position); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ScanObj_is_partial_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *arg1 ; + int arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: ScanObj_is_partial_set(self,is_partial);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 1 of ScanObj_is_partial_set. Expected _p_ScanObj"); + } + } + arg2 = (int) SvIV(ST(1)); + if (arg1) (arg1)->is_partial = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ScanObj_is_partial_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *arg1 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: ScanObj_is_partial_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 1 of ScanObj_is_partial_get. Expected _p_ScanObj"); + } + } + result = (int) ((arg1)->is_partial); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ScanObj_entries_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *arg1 ; + scanEntry *arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: ScanObj_entries_set(self,entries);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 1 of ScanObj_entries_set. Expected _p_ScanObj"); + } + } + { + if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_scanEntry,0) < 0) { + SWIG_croak("Type error in argument 2 of ScanObj_entries_set. Expected _p_scanEntry"); + } + } + if (arg1) (arg1)->entries = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ScanObj_entries_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *arg1 ; + scanEntry *result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: ScanObj_entries_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 1 of ScanObj_entries_get. Expected _p_ScanObj"); + } + } + result = (scanEntry *) ((arg1)->entries); + + ST(argvi) = sv_newmortal(); + SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_scanEntry,0); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_new_ScanObj) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *result; + int argvi = 0; + dXSARGS; + + if ((items < 0) || (items > 0)) { + SWIG_croak("Usage: new_ScanObj();"); + } + result = (ScanObj *)(ScanObj *) calloc(1, sizeof(ScanObj)); + + ST(argvi) = sv_newmortal(); + SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ScanObj,0); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_delete_ScanObj) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *arg1 ; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: delete_ScanObj(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 1 of delete_ScanObj. Expected _p_ScanObj"); + } + } + free((char *) arg1); + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_processed_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + int arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: ZebraTransactionStatus_processed_set(self,processed);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_processed_set. Expected _p_ZebraTransactionStatus"); + } + } + arg2 = (int) SvIV(ST(1)); + if (arg1) (arg1)->processed = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_processed_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: ZebraTransactionStatus_processed_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_processed_get. Expected _p_ZebraTransactionStatus"); + } + } + result = (int) ((arg1)->processed); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_inserted_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + int arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: ZebraTransactionStatus_inserted_set(self,inserted);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_inserted_set. Expected _p_ZebraTransactionStatus"); + } + } + arg2 = (int) SvIV(ST(1)); + if (arg1) (arg1)->inserted = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_inserted_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: ZebraTransactionStatus_inserted_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_inserted_get. Expected _p_ZebraTransactionStatus"); + } + } + result = (int) ((arg1)->inserted); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_updated_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + int arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: ZebraTransactionStatus_updated_set(self,updated);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_updated_set. Expected _p_ZebraTransactionStatus"); + } + } + arg2 = (int) SvIV(ST(1)); + if (arg1) (arg1)->updated = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_updated_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: ZebraTransactionStatus_updated_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_updated_get. Expected _p_ZebraTransactionStatus"); + } + } + result = (int) ((arg1)->updated); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_deleted_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + int arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: ZebraTransactionStatus_deleted_set(self,deleted);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_deleted_set. Expected _p_ZebraTransactionStatus"); + } + } + arg2 = (int) SvIV(ST(1)); + if (arg1) (arg1)->deleted = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_deleted_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: ZebraTransactionStatus_deleted_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_deleted_get. Expected _p_ZebraTransactionStatus"); + } + } + result = (int) ((arg1)->deleted); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_utime_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + long arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: ZebraTransactionStatus_utime_set(self,utime);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_utime_set. Expected _p_ZebraTransactionStatus"); + } + } + arg2 = (long) SvIV(ST(1)); + if (arg1) (arg1)->utime = arg2; + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_utime_get) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + long result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: ZebraTransactionStatus_utime_get(self);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_utime_get. Expected _p_ZebraTransactionStatus"); + } + } + result = (long) ((arg1)->utime); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_ZebraTransactionStatus_stime_set) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraTransactionStatus *arg1 ; + long arg2 ; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: ZebraTransactionStatus_stime_set(self,stime);"); } { - if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanEntry,0) < 0) { - SWIG_croak("Type error in argument 1 of ScanEntry_term_set. Expected _p_ScanEntry"); + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_stime_set. Expected _p_ZebraTransactionStatus"); } } - if (!SvOK((SV*) ST(1))) arg2 = 0; - else arg2 = (char *) SvPV(ST(1), PL_na); - { - if (arg1->term) free((char*)arg1->term); - arg1->term = (char *) malloc(strlen(arg2)+1); - strcpy((char*)arg1->term,arg2); - } + arg2 = (long) SvIV(ST(1)); + if (arg1) (arg1)->stime = arg2; + XSRETURN(argvi); fail: @@ -2069,31 +2877,27 @@ XS(_wrap_ScanEntry_term_set) { } -XS(_wrap_ScanEntry_term_get) { +XS(_wrap_ZebraTransactionStatus_stime_get) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; { - ScanEntry *arg1 ; - char *result; + ZebraTransactionStatus *arg1 ; + long result; int argvi = 0; dXSARGS; if ((items < 1) || (items > 1)) { - SWIG_croak("Usage: ScanEntry_term_get(self);"); + SWIG_croak("Usage: ZebraTransactionStatus_stime_get(self);"); } { - if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanEntry,0) < 0) { - SWIG_croak("Type error in argument 1 of ScanEntry_term_get. Expected _p_ScanEntry"); + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of ZebraTransactionStatus_stime_get. Expected _p_ZebraTransactionStatus"); } } - result = (char *) ((arg1)->term); + result = (long) ((arg1)->stime); ST(argvi) = sv_newmortal(); - if (result) { - sv_setpv((SV*)ST(argvi++), (char *) result); - }else { - sv_setsv((SV*)ST(argvi++), &PL_sv_undef); - } + sv_setiv(ST(argvi++), (IV) result); XSRETURN(argvi); fail: (void) _swigerr; @@ -2102,21 +2906,21 @@ XS(_wrap_ScanEntry_term_get) { } -XS(_wrap_new_ScanEntry) { +XS(_wrap_new_ZebraTransactionStatus) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; { - ScanEntry *result; + ZebraTransactionStatus *result; int argvi = 0; dXSARGS; if ((items < 0) || (items > 0)) { - SWIG_croak("Usage: new_ScanEntry();"); + SWIG_croak("Usage: new_ZebraTransactionStatus();"); } - result = (ScanEntry *)(ScanEntry *) calloc(1, sizeof(ScanEntry)); + result = (ZebraTransactionStatus *)(ZebraTransactionStatus *) calloc(1, sizeof(ZebraTransactionStatus)); ST(argvi) = sv_newmortal(); - SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ScanEntry,0); + SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_ZebraTransactionStatus,0); XSRETURN(argvi); fail: (void) _swigerr; @@ -2125,20 +2929,20 @@ XS(_wrap_new_ScanEntry) { } -XS(_wrap_delete_ScanEntry) { +XS(_wrap_delete_ZebraTransactionStatus) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; { - ScanEntry *arg1 ; + ZebraTransactionStatus *arg1 ; int argvi = 0; dXSARGS; if ((items < 1) || (items > 1)) { - SWIG_croak("Usage: delete_ScanEntry(self);"); + SWIG_croak("Usage: delete_ZebraTransactionStatus(self);"); } { - if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanEntry,0) < 0) { - SWIG_croak("Type error in argument 1 of delete_ScanEntry. Expected _p_ScanEntry"); + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 1 of delete_ZebraTransactionStatus. Expected _p_ZebraTransactionStatus"); } } free((char *) arg1); @@ -2809,11 +3613,13 @@ XS(_wrap_begin_trans) { const char *_swigerr = _swigmsg; { ZebraHandle arg1 ; + int arg2 ; + int result; int argvi = 0; dXSARGS; - if ((items < 1) || (items > 1)) { - SWIG_croak("Usage: begin_trans(zh);"); + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: begin_trans(zh,rw);"); } { ZebraHandle * argp; @@ -2822,9 +3628,11 @@ XS(_wrap_begin_trans) { } arg1 = *argp; } - zebra_begin_trans(arg1); - + arg2 = (int) SvIV(ST(1)); + result = (int)zebra_begin_trans(arg1,arg2); + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); XSRETURN(argvi); fail: (void) _swigerr; @@ -2838,11 +3646,12 @@ XS(_wrap_end_trans) { const char *_swigerr = _swigmsg; { ZebraHandle arg1 ; + ZebraTransactionStatus *arg2 ; int argvi = 0; dXSARGS; - if ((items < 1) || (items > 1)) { - SWIG_croak("Usage: end_trans(zh);"); + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: end_trans(zh,stat);"); } { ZebraHandle * argp; @@ -2851,7 +3660,12 @@ XS(_wrap_end_trans) { } arg1 = *argp; } - zebra_end_trans(arg1); + { + if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ZebraTransactionStatus,0) < 0) { + SWIG_croak("Type error in argument 2 of end_trans. Expected _p_ZebraTransactionStatus"); + } + } + zebra_end_transaction(arg1,arg2); XSRETURN(argvi); @@ -2862,7 +3676,7 @@ XS(_wrap_end_trans) { } -XS(_wrap_begin_read) { +XS(_wrap_trans_no) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; { @@ -2872,16 +3686,16 @@ XS(_wrap_begin_read) { dXSARGS; if ((items < 1) || (items > 1)) { - SWIG_croak("Usage: begin_read(zh);"); + SWIG_croak("Usage: trans_no(zh);"); } { ZebraHandle * argp; if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) { - SWIG_croak("Type error in argument 1 of begin_read. Expected _p_ZebraHandle"); + SWIG_croak("Type error in argument 1 of trans_no. Expected _p_ZebraHandle"); } arg1 = *argp; } - result = (int)zebra_begin_read(arg1); + result = (int)zebra_trans_no(arg1); ST(argvi) = sv_newmortal(); sv_setiv(ST(argvi++), (IV) result); @@ -2893,35 +3707,6 @@ XS(_wrap_begin_read) { } -XS(_wrap_end_read) { - char _swigmsg[SWIG_MAX_ERRMSG] = ""; - const char *_swigerr = _swigmsg; - { - ZebraHandle arg1 ; - int argvi = 0; - dXSARGS; - - if ((items < 1) || (items > 1)) { - SWIG_croak("Usage: end_read(zh);"); - } - { - ZebraHandle * argp; - if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) { - SWIG_croak("Type error in argument 1 of end_read. Expected _p_ZebraHandle"); - } - arg1 = *argp; - } - zebra_end_read(arg1); - - - XSRETURN(argvi); - fail: - (void) _swigerr; - } - croak(_swigerr); -} - - XS(_wrap_commit) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; @@ -3191,23 +3976,80 @@ XS(_wrap_repository_show) { } +XS(_wrap_insert_record) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraHandle arg1 ; + recordGroup *arg2 ; + char *arg3 ; + int arg4 ; + char *arg5 ; + char *arg6 ; + char *arg7 ; + int arg8 ; + int arg9 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 9) || (items > 9)) { + SWIG_croak("Usage: insert_record(zh,rGroup,recordType,sysno,match,fname,buf,buf_size,force_update);"); + } + { + ZebraHandle * argp; + if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) { + SWIG_croak("Type error in argument 1 of insert_record. Expected _p_ZebraHandle"); + } + arg1 = *argp; + } + { + if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) { + SWIG_croak("Type error in argument 2 of insert_record. Expected _p_recordGroup"); + } + } + if (!SvOK((SV*) ST(2))) arg3 = 0; + else arg3 = (char *) SvPV(ST(2), PL_na); + arg4 = (int) SvIV(ST(3)); + if (!SvOK((SV*) ST(4))) arg5 = 0; + else arg5 = (char *) SvPV(ST(4), PL_na); + if (!SvOK((SV*) ST(5))) arg6 = 0; + else arg6 = (char *) SvPV(ST(5), PL_na); + if (!SvOK((SV*) ST(6))) arg7 = 0; + else arg7 = (char *) SvPV(ST(6), PL_na); + arg8 = (int) SvIV(ST(7)); + arg9 = (int) SvIV(ST(8)); + result = (int)zebra_insert_record(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8,arg9); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + XS(_wrap_update_record) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; { ZebraHandle arg1 ; recordGroup *arg2 ; - int arg3 ; - char *arg4 ; + char *arg3 ; + int arg4 ; char *arg5 ; char *arg6 ; - int arg7 ; + char *arg7 ; + int arg8 ; + int arg9 ; int result; int argvi = 0; dXSARGS; - if ((items < 7) || (items > 7)) { - SWIG_croak("Usage: update_record(zh,rGroup,sysno,match,fname,buf,buf_size);"); + if ((items < 9) || (items > 9)) { + SWIG_croak("Usage: update_record(zh,rGroup,recordType,sysno,match,fname,buf,buf_size,force_update);"); } { ZebraHandle * argp; @@ -3221,15 +4063,18 @@ XS(_wrap_update_record) { SWIG_croak("Type error in argument 2 of update_record. Expected _p_recordGroup"); } } - arg3 = (int) SvIV(ST(2)); - if (!SvOK((SV*) ST(3))) arg4 = 0; - else arg4 = (char *) SvPV(ST(3), PL_na); + if (!SvOK((SV*) ST(2))) arg3 = 0; + else arg3 = (char *) SvPV(ST(2), PL_na); + arg4 = (int) SvIV(ST(3)); if (!SvOK((SV*) ST(4))) arg5 = 0; else arg5 = (char *) SvPV(ST(4), PL_na); if (!SvOK((SV*) ST(5))) arg6 = 0; else arg6 = (char *) SvPV(ST(5), PL_na); - arg7 = (int) SvIV(ST(6)); - result = (int)zebra_update_record(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,arg7); + if (!SvOK((SV*) ST(6))) arg7 = 0; + else arg7 = (char *) SvPV(ST(6), PL_na); + arg8 = (int) SvIV(ST(7)); + arg9 = (int) SvIV(ST(8)); + result = (int)zebra_update_record(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8,arg9); ST(argvi) = sv_newmortal(); sv_setiv(ST(argvi++), (IV) result); @@ -3247,17 +4092,19 @@ XS(_wrap_delete_record) { { ZebraHandle arg1 ; recordGroup *arg2 ; - int arg3 ; - char *arg4 ; + char *arg3 ; + int arg4 ; char *arg5 ; char *arg6 ; - int arg7 ; + char *arg7 ; + int arg8 ; + int arg9 ; int result; int argvi = 0; dXSARGS; - if ((items < 7) || (items > 7)) { - SWIG_croak("Usage: delete_record(zh,rGroup,sysno,match,fname,buf,buf_size);"); + if ((items < 9) || (items > 9)) { + SWIG_croak("Usage: delete_record(zh,rGroup,recordType,sysno,match,fname,buf,buf_size,force_update);"); } { ZebraHandle * argp; @@ -3267,72 +4114,230 @@ XS(_wrap_delete_record) { arg1 = *argp; } { - if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) { - SWIG_croak("Type error in argument 2 of delete_record. Expected _p_recordGroup"); + if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_recordGroup,0) < 0) { + SWIG_croak("Type error in argument 2 of delete_record. Expected _p_recordGroup"); + } + } + if (!SvOK((SV*) ST(2))) arg3 = 0; + else arg3 = (char *) SvPV(ST(2), PL_na); + arg4 = (int) SvIV(ST(3)); + if (!SvOK((SV*) ST(4))) arg5 = 0; + else arg5 = (char *) SvPV(ST(4), PL_na); + if (!SvOK((SV*) ST(5))) arg6 = 0; + else arg6 = (char *) SvPV(ST(5), PL_na); + if (!SvOK((SV*) ST(6))) arg7 = 0; + else arg7 = (char *) SvPV(ST(6), PL_na); + arg8 = (int) SvIV(ST(7)); + arg9 = (int) SvIV(ST(8)); + result = (int)zebra_delete_record(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5,(char const *)arg6,(char const *)arg7,arg8,arg9); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_search_PQF) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraHandle arg1 ; + ODR arg2 ; + ODR arg3 ; + char *arg4 ; + char *arg5 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 5) || (items > 5)) { + SWIG_croak("Usage: search_PQF(zh,odr_input,odr_output,pqf_query,setname);"); + } + { + ZebraHandle * argp; + if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) { + SWIG_croak("Type error in argument 1 of search_PQF. Expected _p_ZebraHandle"); + } + arg1 = *argp; + } + { + ODR * argp; + if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) { + SWIG_croak("Type error in argument 2 of search_PQF. Expected _p_ODR"); + } + arg2 = *argp; + } + { + ODR * argp; + if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) { + SWIG_croak("Type error in argument 3 of search_PQF. Expected _p_ODR"); + } + arg3 = *argp; + } + if (!SvOK((SV*) ST(3))) arg4 = 0; + else arg4 = (char *) SvPV(ST(3), PL_na); + if (!SvOK((SV*) ST(4))) arg5 = 0; + else arg5 = (char *) SvPV(ST(4), PL_na); + result = (int)zebra_search_PQF(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_cql_transform_open_fname) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + char *arg1 ; + cql_transform_t result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: cql_transform_open_fname(fname);"); + } + if (!SvOK((SV*) ST(0))) arg1 = 0; + else arg1 = (char *) SvPV(ST(0), PL_na); + result = cql_transform_open_fname((char const *)arg1); + + { + cql_transform_t * resultobj = (cql_transform_t *) malloc(sizeof(cql_transform_t)); + memmove(resultobj, &result, sizeof(cql_transform_t)); + ST(argvi) = sv_newmortal(); + SWIG_MakePtr(ST(argvi++), (void *) resultobj, SWIGTYPE_p_cql_transform_t,0); + } + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_cql_transform_close) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + cql_transform_t arg1 ; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: cql_transform_close(ct);"); + } + { + cql_transform_t * argp; + if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_cql_transform_t,0) < 0) { + SWIG_croak("Type error in argument 1 of cql_transform_close. Expected _p_cql_transform_t"); + } + arg1 = *argp; + } + cql_transform_close(arg1); + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_cql_transform_error) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + cql_transform_t arg1 ; + char **arg2 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: cql_transform_error(ct,addinfo);"); + } + { + cql_transform_t * argp; + if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_cql_transform_t,0) < 0) { + SWIG_croak("Type error in argument 1 of cql_transform_error. Expected _p_cql_transform_t"); + } + arg1 = *argp; + } + { + AV *tempav; + I32 len; + int i; + SV **tv; + STRLEN na; + if (!SvROK(ST(1))) + croak("Argument 2 is not a reference."); + if (SvTYPE(SvRV(ST(1))) != SVt_PVAV) + croak("Argument 2 is not an array."); + tempav = (AV*)SvRV(ST(1)); + len = av_len(tempav); + arg2 = (char **) malloc((len+2)*sizeof(char *)); + for (i = 0; i <= len; i++) { + tv = av_fetch(tempav, i, 0); + arg2[i] = (char *) SvPV(*tv,na); } + arg2[i] = NULL; } - arg3 = (int) SvIV(ST(2)); - if (!SvOK((SV*) ST(3))) arg4 = 0; - else arg4 = (char *) SvPV(ST(3), PL_na); - if (!SvOK((SV*) ST(4))) arg5 = 0; - else arg5 = (char *) SvPV(ST(4), PL_na); - if (!SvOK((SV*) ST(5))) arg6 = 0; - else arg6 = (char *) SvPV(ST(5), PL_na); - arg7 = (int) SvIV(ST(6)); - result = (int)zebra_delete_record(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5,(char const *)arg6,arg7); + result = (int)cql_transform_error(arg1,(char const **)arg2); ST(argvi) = sv_newmortal(); sv_setiv(ST(argvi++), (IV) result); + { + free(arg2); + } XSRETURN(argvi); fail: + { + free(arg2); + } (void) _swigerr; } croak(_swigerr); } -XS(_wrap_search_PQF) { +XS(_wrap_cql2pqf) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; { - ZebraHandle arg1 ; - ODR arg2 ; - ODR arg3 ; - char *arg4 ; - char *arg5 ; + cql_transform_t arg1 ; + char *arg2 ; + char *arg3 ; + int arg4 ; int result; int argvi = 0; dXSARGS; - if ((items < 5) || (items > 5)) { - SWIG_croak("Usage: search_PQF(zh,odr_input,odr_output,pqf_query,setname);"); + if ((items < 4) || (items > 4)) { + SWIG_croak("Usage: cql2pqf(ct,query,res,len);"); } { - ZebraHandle * argp; - if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) { - SWIG_croak("Type error in argument 1 of search_PQF. Expected _p_ZebraHandle"); + cql_transform_t * argp; + if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_cql_transform_t,0) < 0) { + SWIG_croak("Type error in argument 1 of cql2pqf. Expected _p_cql_transform_t"); } arg1 = *argp; } - { - ODR * argp; - if (SWIG_ConvertPtr(ST(1),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) { - SWIG_croak("Type error in argument 2 of search_PQF. Expected _p_ODR"); - } - arg2 = *argp; - } - { - ODR * argp; - if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) { - SWIG_croak("Type error in argument 3 of search_PQF. Expected _p_ODR"); - } - arg3 = *argp; - } - if (!SvOK((SV*) ST(3))) arg4 = 0; - else arg4 = (char *) SvPV(ST(3), PL_na); - if (!SvOK((SV*) ST(4))) arg5 = 0; - else arg5 = (char *) SvPV(ST(4), PL_na); - result = (int)zebra_search_PQF(arg1,arg2,arg3,(char const *)arg4,(char const *)arg5); + if (!SvOK((SV*) ST(1))) arg2 = 0; + else arg2 = (char *) SvPV(ST(1), PL_na); + if (!SvOK((SV*) ST(2))) arg3 = 0; + else arg3 = (char *) SvPV(ST(2), PL_na); + arg4 = (int) SvIV(ST(3)); + result = (int)zebra_cql2pqf(arg1,(char const *)arg2,arg3,arg4); ST(argvi) = sv_newmortal(); sv_setiv(ST(argvi++), (IV) result); @@ -3446,6 +4451,75 @@ XS(_wrap_record_retrieve) { } +XS(_wrap_deleteResultSet) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraHandle arg1 ; + int arg2 ; + int arg3 ; + char **arg4 ; + int *arg5 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 5) || (items > 5)) { + SWIG_croak("Usage: deleteResultSet(zh,function,num_setnames,setnames,statuses);"); + } + { + ZebraHandle * argp; + if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) { + SWIG_croak("Type error in argument 1 of deleteResultSet. Expected _p_ZebraHandle"); + } + arg1 = *argp; + } + arg2 = (int) SvIV(ST(1)); + arg3 = (int) SvIV(ST(2)); + { + AV *tempav; + I32 len; + int i; + SV **tv; + STRLEN na; + if (!SvROK(ST(3))) + croak("Argument 4 is not a reference."); + if (SvTYPE(SvRV(ST(3))) != SVt_PVAV) + croak("Argument 4 is not an array."); + tempav = (AV*)SvRV(ST(3)); + len = av_len(tempav); + arg4 = (char **) malloc((len+2)*sizeof(char *)); + for (i = 0; i <= len; i++) { + tv = av_fetch(tempav, i, 0); + arg4[i] = (char *) SvPV(*tv,na); + } + arg4[i] = NULL; + } + { + int i; + if (!SvIOK(ST(4))) + croak("Argument 5 is not an integer."); + i = SvIV(ST(4)); + arg5 = &i; + } + result = (int)zebra_deleleResultSet(arg1,arg2,arg3,arg4,arg5); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + { + free(arg4); + } + XSRETURN(argvi); + fail: + { + free(arg4); + } + (void) _swigerr; + } + croak(_swigerr); +} + + XS(_wrap_sort) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; @@ -3517,6 +4591,83 @@ XS(_wrap_sort) { } +XS(_wrap_scan_PQF) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ZebraHandle arg1 ; + ScanObj *arg2 ; + ODR arg3 ; + char *arg4 ; + int argvi = 0; + dXSARGS; + + if ((items < 4) || (items > 4)) { + SWIG_croak("Usage: scan_PQF(zh,so,stream,pqf_query);"); + } + { + ZebraHandle * argp; + if (SWIG_ConvertPtr(ST(0),(void **) &argp, SWIGTYPE_p_ZebraHandle,0) < 0) { + SWIG_croak("Type error in argument 1 of scan_PQF. Expected _p_ZebraHandle"); + } + arg1 = *argp; + } + { + if (SWIG_ConvertPtr(ST(1), (void **) &arg2, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 2 of scan_PQF. Expected _p_ScanObj"); + } + } + { + ODR * argp; + if (SWIG_ConvertPtr(ST(2),(void **) &argp, SWIGTYPE_p_ODR,0) < 0) { + SWIG_croak("Type error in argument 3 of scan_PQF. Expected _p_ODR"); + } + arg3 = *argp; + } + if (!SvOK((SV*) ST(3))) arg4 = 0; + else arg4 = (char *) SvPV(ST(3), PL_na); + zebra_scan_PQF(arg1,arg2,arg3,(char const *)arg4); + + + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_getScanEntry) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + ScanObj *arg1 ; + int arg2 ; + scanEntry *result; + int argvi = 0; + dXSARGS; + + if ((items < 2) || (items > 2)) { + SWIG_croak("Usage: getScanEntry(so,pos);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_ScanObj,0) < 0) { + SWIG_croak("Type error in argument 1 of getScanEntry. Expected _p_ScanObj"); + } + } + arg2 = (int) SvIV(ST(1)); + result = (scanEntry *)getScanEntry(arg1,arg2); + + ST(argvi) = sv_newmortal(); + SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_scanEntry,0); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + XS(_wrap_nmem_create) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; @@ -4097,9 +5248,11 @@ XS(_wrap_data1_nodetogr) { arg4 = *argp; } { - if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_int,0) < 0) { - SWIG_croak("Type error in argument 5 of data1_nodetogr. Expected _p_int"); - } + int i; + if (!SvIOK(ST(4))) + croak("Argument 5 is not an integer."); + i = SvIV(ST(4)); + arg5 = &i; } result = (Z_GenericRecord *)data1_nodetogr(arg1,arg2,arg3,arg4,arg5); @@ -4217,9 +5370,11 @@ XS(_wrap_data1_nodetobuf) { } arg3 = (int) SvIV(ST(2)); { - if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_int,0) < 0) { - SWIG_croak("Type error in argument 4 of data1_nodetobuf. Expected _p_int"); - } + int i; + if (!SvIOK(ST(3))) + croak("Argument 4 is not an integer."); + i = SvIV(ST(3)); + arg4 = &i; } result = (char *)data1_nodetobuf(arg1,arg2,arg3,arg4); @@ -5791,9 +6946,11 @@ XS(_wrap_data1_nodetomarc) { } arg4 = (int) SvIV(ST(3)); { - if (SWIG_ConvertPtr(ST(4), (void **) &arg5, SWIGTYPE_p_int,0) < 0) { - SWIG_croak("Type error in argument 5 of data1_nodetomarc. Expected _p_int"); - } + int i; + if (!SvIOK(ST(4))) + croak("Argument 5 is not an integer."); + i = SvIV(ST(4)); + arg5 = &i; } result = (char *)data1_nodetomarc(arg1,arg2,arg3,arg4,arg5); @@ -5840,9 +6997,11 @@ XS(_wrap_data1_nodetoidsgml) { } arg3 = (int) SvIV(ST(2)); { - if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_int,0) < 0) { - SWIG_croak("Type error in argument 4 of data1_nodetoidsgml. Expected _p_int"); - } + int i; + if (!SvIOK(ST(3))) + croak("Argument 4 is not an integer."); + i = SvIV(ST(3)); + arg4 = &i; } result = (char *)data1_nodetoidsgml(arg1,arg2,arg3,arg4); @@ -5983,9 +7142,11 @@ XS(_wrap_data1_nodetosoif) { } arg3 = (int) SvIV(ST(2)); { - if (SWIG_ConvertPtr(ST(3), (void **) &arg4, SWIGTYPE_p_int,0) < 0) { - SWIG_croak("Type error in argument 4 of data1_nodetosoif. Expected _p_int"); - } + int i; + if (!SvIOK(ST(3))) + croak("Argument 4 is not an integer."); + i = SvIV(ST(3)); + arg4 = &i; } result = (char *)data1_nodetosoif(arg1,arg2,arg3,arg4); @@ -6077,7 +7238,7 @@ XS(_wrap_data1_get_read_buf) { svs[i] = sv_newmortal(); sv_setpv((SV*)svs[i],result[i]); }; - myav = av_make(len,svs); + myav = av_make(len,svs); free(svs); ST(argvi) = newRV((SV*)myav); sv_2mortal(ST(argvi)); @@ -6130,7 +7291,7 @@ XS(_wrap_data1_get_map_buf) { svs[i] = sv_newmortal(); sv_setpv((SV*)svs[i],result[i]); }; - myav = av_make(len,svs); + myav = av_make(len,svs); free(svs); ST(argvi) = newRV((SV*)myav); sv_2mortal(ST(argvi)); @@ -6841,6 +8002,64 @@ XS(_wrap_grs_perl_readf) { } +XS(_wrap_grs_perl_readline) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + struct perl_context *arg1 ; + int result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: grs_perl_readline(context);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) { + SWIG_croak("Type error in argument 1 of grs_perl_readline. Expected _p_perl_context"); + } + } + result = (int)grs_perl_readline(arg1); + + ST(argvi) = sv_newmortal(); + sv_setiv(ST(argvi++), (IV) result); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + +XS(_wrap_grs_perl_getc) { + char _swigmsg[SWIG_MAX_ERRMSG] = ""; + const char *_swigerr = _swigmsg; + { + struct perl_context *arg1 ; + char result; + int argvi = 0; + dXSARGS; + + if ((items < 1) || (items > 1)) { + SWIG_croak("Usage: grs_perl_getc(context);"); + } + { + if (SWIG_ConvertPtr(ST(0), (void **) &arg1, SWIGTYPE_p_perl_context,0) < 0) { + SWIG_croak("Type error in argument 1 of grs_perl_getc. Expected _p_perl_context"); + } + } + result = (char)grs_perl_getc(arg1); + + ST(argvi) = sv_newmortal(); + sv_setpvn((SV*)ST(argvi++), &result, 1); + XSRETURN(argvi); + fail: + (void) _swigerr; + } + croak(_swigerr); +} + + XS(_wrap_grs_perl_seekf) { char _swigmsg[SWIG_MAX_ERRMSG] = ""; const char *_swigerr = _swigmsg; @@ -7045,12 +8264,12 @@ XS(_wrap_grs_perl_set_res) { /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ static swig_type_info _swigt__p_ZebraService[] = {{"_p_ZebraService", 0, "ZebraService *", 0},{"_p_ZebraService"},{0}}; +static swig_type_info _swigt__p_cql_transform_t[] = {{"_p_cql_transform_t", 0, "cql_transform_t *", 0},{"_p_cql_transform_t"},{0}}; static swig_type_info _swigt__p_data1_esetname[] = {{"_p_data1_esetname", 0, "data1_esetname *", 0},{"_p_data1_esetname"},{0}}; static swig_type_info _swigt__p_data1_maptab[] = {{"_p_data1_maptab", 0, "data1_maptab *", 0},{"_p_data1_maptab"},{0}}; static swig_type_info _swigt__p_ODR[] = {{"_p_ODR", 0, "ODR *", 0},{"_p_ODR"},{0}}; 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}}; static swig_type_info _swigt__p_p_char[] = {{"_p_p_char", 0, "char **", 0},{"_p_p_char"},{0}}; -static swig_type_info _swigt__p_oid_value[] = {{"_p_oid_value", 0, "oid_value *", 0},{"_p_oid_value"},{0}}; static swig_type_info _swigt__p_data1_absyn[] = {{"_p_data1_absyn", 0, "data1_absyn *", 0},{"_p_data1_absyn"},{0}}; static swig_type_info _swigt__p_ZebraHandle[] = {{"_p_ZebraHandle", 0, "ZebraHandle *", 0},{"_p_ZebraHandle"},{0}}; static swig_type_info _swigt__p_void[] = {{"_p_void", 0, "void *", 0},{"_p_void"},{0}}; @@ -7065,16 +8284,18 @@ static swig_type_info _swigt__p_data1_varset[] = {{"_p_data1_varset", 0, "data1_ static swig_type_info _swigt__p_RetrievalRecordBuf[] = {{"_p_RetrievalRecordBuf", 0, "RetrievalRecordBuf *", 0},{"_p_RetrievalRecordBuf"},{0}}; static swig_type_info _swigt__p_perl_context[] = {{"_p_perl_context", 0, "struct perl_context *", 0},{"_p_perl_context"},{0}}; static swig_type_info _swigt__p_data1_node[] = {{"_p_data1_node", 0, "data1_node *", 0},{"_p_data1_node"},{0}}; +static swig_type_info _swigt__p_ScanObj[] = {{"IDZebra::ScanObj", 0, "ScanObj *", 0},{"IDZebra::ScanObj"},{0}}; static swig_type_info _swigt__p_RetrievalObj[] = {{"IDZebra::RetrievalObj", 0, "RetrievalObj *", 0},{"IDZebra::RetrievalObj"},{0}}; static swig_type_info _swigt__p_data1_tagset[] = {{"_p_data1_tagset", 0, "data1_tagset *", 0},{"_p_data1_tagset"},{0}}; static swig_type_info _swigt__p_data1_tag[] = {{"_p_data1_tag", 0, "data1_tag *", 0},{"_p_data1_tag"},{0}}; -static swig_type_info _swigt__p_Z_ExplainRecord[] = {{"_p_Z_ExplainRecord", 0, "Z_ExplainRecord *", 0},{"_p_Z_ExplainRecord"},{0}}; static swig_type_info _swigt__p_ZebraRetrievalRecord[] = {{"_p_ZebraRetrievalRecord", 0, "ZebraRetrievalRecord *", 0},{"_p_ZebraRetrievalRecord"},{0}}; static swig_type_info _swigt__p_RetrievalRecord[] = {{"IDZebra::RetrievalRecord", 0, "RetrievalRecord *", 0},{"IDZebra::RetrievalRecord"},{0}}; static swig_type_info _swigt__p_NMEM[] = {{"_p_NMEM", 0, "NMEM *", 0},{"_p_NMEM"},{0}}; +static swig_type_info _swigt__p_Z_ExplainRecord[] = {{"_p_Z_ExplainRecord", 0, "Z_ExplainRecord *", 0},{"_p_Z_ExplainRecord"},{0}}; static swig_type_info _swigt__p_data1_marctab[] = {{"_p_data1_marctab", 0, "data1_marctab *", 0},{"_p_data1_marctab"},{0}}; +static swig_type_info _swigt__p_ZebraTransactionStatus[] = {{"IDZebra::ZebraTransactionStatus", 0, "ZebraTransactionStatus *", 0},{"IDZebra::ZebraTransactionStatus"},{0}}; static swig_type_info _swigt__p_Z_BriefBib[] = {{"_p_Z_BriefBib", 0, "Z_BriefBib *", 0},{"_p_Z_BriefBib"},{0}}; -static swig_type_info _swigt__p_ScanEntry[] = {{"IDZebra::ScanEntry", 0, "ScanEntry *", 0},{"IDZebra::ScanEntry"},{0}}; +static swig_type_info _swigt__p_scanEntry[] = {{"IDZebra::scanEntry", 0, "scanEntry *", 0},{"IDZebra::scanEntry"},{0}}; 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}}; static swig_type_info _swigt__p_FILE[] = {{"_p_FILE", 0, "FILE *", 0},{"_p_FILE"},{0}}; static swig_type_info _swigt__p_data1_element[] = {{"_p_data1_element", 0, "data1_element *", 0},{"_p_data1_element"},{0}}; @@ -7089,12 +8310,12 @@ static swig_type_info _swigt__p_data1_vartype[] = {{"_p_data1_vartype", 0, "data static swig_type_info *swig_types_initial[] = { _swigt__p_ZebraService, +_swigt__p_cql_transform_t, _swigt__p_data1_esetname, _swigt__p_data1_maptab, _swigt__p_ODR, _swigt__p_f_p_void__int, _swigt__p_p_char, -_swigt__p_oid_value, _swigt__p_data1_absyn, _swigt__p_ZebraHandle, _swigt__p_void, @@ -7109,16 +8330,18 @@ _swigt__p_data1_varset, _swigt__p_RetrievalRecordBuf, _swigt__p_perl_context, _swigt__p_data1_node, +_swigt__p_ScanObj, _swigt__p_RetrievalObj, _swigt__p_data1_tagset, _swigt__p_data1_tag, -_swigt__p_Z_ExplainRecord, _swigt__p_ZebraRetrievalRecord, _swigt__p_RetrievalRecord, _swigt__p_NMEM, +_swigt__p_Z_ExplainRecord, _swigt__p_data1_marctab, +_swigt__p_ZebraTransactionStatus, _swigt__p_Z_BriefBib, -_swigt__p_ScanEntry, +_swigt__p_scanEntry, _swigt__p_f_p_void_p_char_size_t__int, _swigt__p_FILE, _swigt__p_data1_element, @@ -7225,18 +8448,46 @@ static swig_command_info swig_commands[] = { {"IDZebrac::RetrievalRecord_position_get", _wrap_RetrievalRecord_position_get}, {"IDZebrac::RetrievalRecord_base_set", _wrap_RetrievalRecord_base_set}, {"IDZebrac::RetrievalRecord_base_get", _wrap_RetrievalRecord_base_get}, +{"IDZebrac::RetrievalRecord_sysno_set", _wrap_RetrievalRecord_sysno_set}, +{"IDZebrac::RetrievalRecord_sysno_get", _wrap_RetrievalRecord_sysno_get}, +{"IDZebrac::RetrievalRecord_score_set", _wrap_RetrievalRecord_score_set}, +{"IDZebrac::RetrievalRecord_score_get", _wrap_RetrievalRecord_score_get}, {"IDZebrac::RetrievalRecord_format_set", _wrap_RetrievalRecord_format_set}, {"IDZebrac::RetrievalRecord_format_get", _wrap_RetrievalRecord_format_get}, {"IDZebrac::RetrievalRecord_buf_set", _wrap_RetrievalRecord_buf_set}, {"IDZebrac::RetrievalRecord_buf_get", _wrap_RetrievalRecord_buf_get}, {"IDZebrac::new_RetrievalRecord", _wrap_new_RetrievalRecord}, {"IDZebrac::delete_RetrievalRecord", _wrap_delete_RetrievalRecord}, -{"IDZebrac::ScanEntry_occurrences_set", _wrap_ScanEntry_occurrences_set}, -{"IDZebrac::ScanEntry_occurrences_get", _wrap_ScanEntry_occurrences_get}, -{"IDZebrac::ScanEntry_term_set", _wrap_ScanEntry_term_set}, -{"IDZebrac::ScanEntry_term_get", _wrap_ScanEntry_term_get}, -{"IDZebrac::new_ScanEntry", _wrap_new_ScanEntry}, -{"IDZebrac::delete_ScanEntry", _wrap_delete_ScanEntry}, +{"IDZebrac::scanEntry_occurrences_set", _wrap_scanEntry_occurrences_set}, +{"IDZebrac::scanEntry_occurrences_get", _wrap_scanEntry_occurrences_get}, +{"IDZebrac::scanEntry_term_set", _wrap_scanEntry_term_set}, +{"IDZebrac::scanEntry_term_get", _wrap_scanEntry_term_get}, +{"IDZebrac::new_scanEntry", _wrap_new_scanEntry}, +{"IDZebrac::delete_scanEntry", _wrap_delete_scanEntry}, +{"IDZebrac::ScanObj_num_entries_set", _wrap_ScanObj_num_entries_set}, +{"IDZebrac::ScanObj_num_entries_get", _wrap_ScanObj_num_entries_get}, +{"IDZebrac::ScanObj_position_set", _wrap_ScanObj_position_set}, +{"IDZebrac::ScanObj_position_get", _wrap_ScanObj_position_get}, +{"IDZebrac::ScanObj_is_partial_set", _wrap_ScanObj_is_partial_set}, +{"IDZebrac::ScanObj_is_partial_get", _wrap_ScanObj_is_partial_get}, +{"IDZebrac::ScanObj_entries_set", _wrap_ScanObj_entries_set}, +{"IDZebrac::ScanObj_entries_get", _wrap_ScanObj_entries_get}, +{"IDZebrac::new_ScanObj", _wrap_new_ScanObj}, +{"IDZebrac::delete_ScanObj", _wrap_delete_ScanObj}, +{"IDZebrac::ZebraTransactionStatus_processed_set", _wrap_ZebraTransactionStatus_processed_set}, +{"IDZebrac::ZebraTransactionStatus_processed_get", _wrap_ZebraTransactionStatus_processed_get}, +{"IDZebrac::ZebraTransactionStatus_inserted_set", _wrap_ZebraTransactionStatus_inserted_set}, +{"IDZebrac::ZebraTransactionStatus_inserted_get", _wrap_ZebraTransactionStatus_inserted_get}, +{"IDZebrac::ZebraTransactionStatus_updated_set", _wrap_ZebraTransactionStatus_updated_set}, +{"IDZebrac::ZebraTransactionStatus_updated_get", _wrap_ZebraTransactionStatus_updated_get}, +{"IDZebrac::ZebraTransactionStatus_deleted_set", _wrap_ZebraTransactionStatus_deleted_set}, +{"IDZebrac::ZebraTransactionStatus_deleted_get", _wrap_ZebraTransactionStatus_deleted_get}, +{"IDZebrac::ZebraTransactionStatus_utime_set", _wrap_ZebraTransactionStatus_utime_set}, +{"IDZebrac::ZebraTransactionStatus_utime_get", _wrap_ZebraTransactionStatus_utime_get}, +{"IDZebrac::ZebraTransactionStatus_stime_set", _wrap_ZebraTransactionStatus_stime_set}, +{"IDZebrac::ZebraTransactionStatus_stime_get", _wrap_ZebraTransactionStatus_stime_get}, +{"IDZebrac::new_ZebraTransactionStatus", _wrap_new_ZebraTransactionStatus}, +{"IDZebrac::delete_ZebraTransactionStatus", _wrap_delete_ZebraTransactionStatus}, {"IDZebrac::DESTROY", _wrap_DESTROY}, {"IDZebrac::logLevel", _wrap_logLevel}, {"IDZebrac::logFile", _wrap_logFile}, @@ -7259,8 +8510,7 @@ static swig_command_info swig_commands[] = { {"IDZebrac::select_databases", _wrap_select_databases}, {"IDZebrac::begin_trans", _wrap_begin_trans}, {"IDZebrac::end_trans", _wrap_end_trans}, -{"IDZebrac::begin_read", _wrap_begin_read}, -{"IDZebrac::end_read", _wrap_end_read}, +{"IDZebrac::trans_no", _wrap_trans_no}, {"IDZebrac::commit", _wrap_commit}, {"IDZebrac::get_shadow_enable", _wrap_get_shadow_enable}, {"IDZebrac::set_shadow_enable", _wrap_set_shadow_enable}, @@ -7269,12 +8519,20 @@ static swig_command_info swig_commands[] = { {"IDZebrac::repository_update", _wrap_repository_update}, {"IDZebrac::repository_delete", _wrap_repository_delete}, {"IDZebrac::repository_show", _wrap_repository_show}, +{"IDZebrac::insert_record", _wrap_insert_record}, {"IDZebrac::update_record", _wrap_update_record}, {"IDZebrac::delete_record", _wrap_delete_record}, {"IDZebrac::search_PQF", _wrap_search_PQF}, +{"IDZebrac::cql_transform_open_fname", _wrap_cql_transform_open_fname}, +{"IDZebrac::cql_transform_close", _wrap_cql_transform_close}, +{"IDZebrac::cql_transform_error", _wrap_cql_transform_error}, +{"IDZebrac::cql2pqf", _wrap_cql2pqf}, {"IDZebrac::records_retrieve", _wrap_records_retrieve}, {"IDZebrac::record_retrieve", _wrap_record_retrieve}, +{"IDZebrac::deleteResultSet", _wrap_deleteResultSet}, {"IDZebrac::sort", _wrap_sort}, +{"IDZebrac::scan_PQF", _wrap_scan_PQF}, +{"IDZebrac::getScanEntry", _wrap_getScanEntry}, {"IDZebrac::nmem_create", _wrap_nmem_create}, {"IDZebrac::nmem_destroy", _wrap_nmem_destroy}, {"IDZebrac::data1_create", _wrap_data1_create}, @@ -7352,6 +8610,8 @@ static swig_command_info swig_commands[] = { {"IDZebrac::data1_get_tabpath", _wrap_data1_get_tabpath}, {"IDZebrac::data1_get_tabroot", _wrap_data1_get_tabroot}, {"IDZebrac::grs_perl_readf", _wrap_grs_perl_readf}, +{"IDZebrac::grs_perl_readline", _wrap_grs_perl_readline}, +{"IDZebrac::grs_perl_getc", _wrap_grs_perl_getc}, {"IDZebrac::grs_perl_seekf", _wrap_grs_perl_seekf}, {"IDZebrac::grs_perl_tellf", _wrap_grs_perl_tellf}, {"IDZebrac::grs_perl_endf", _wrap_grs_perl_endf}, @@ -7422,7 +8682,9 @@ XS(SWIG_init) { SWIG_TypeClientData(SWIGTYPE_p_recordGroup, (void*) "IDZebra::recordGroup"); SWIG_TypeClientData(SWIGTYPE_p_RetrievalObj, (void*) "IDZebra::RetrievalObj"); SWIG_TypeClientData(SWIGTYPE_p_RetrievalRecord, (void*) "IDZebra::RetrievalRecord"); - SWIG_TypeClientData(SWIGTYPE_p_ScanEntry, (void*) "IDZebra::ScanEntry"); + SWIG_TypeClientData(SWIGTYPE_p_scanEntry, (void*) "IDZebra::scanEntry"); + SWIG_TypeClientData(SWIGTYPE_p_ScanObj, (void*) "IDZebra::ScanObj"); + SWIG_TypeClientData(SWIGTYPE_p_ZebraTransactionStatus, (void*) "IDZebra::ZebraTransactionStatus"); ST(0) = &PL_sv_yes; XSRETURN(1); }