X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=ZOOM.xs;h=4e5de767769699c2bf094d765829de6b69a2dbb6;hb=38bb374c040f6ddf0c9329569e250776c141b3f7;hp=d8319f6a293a99367e44dbc7d85b815c442d5fdb;hpb=b0dd79557412ca039daebfdeaccd0e1a28240b88;p=ZOOM-Perl-moved-to-github.git diff --git a/ZOOM.xs b/ZOOM.xs index d8319f6..4e5de76 100644 --- a/ZOOM.xs +++ b/ZOOM.xs @@ -3,276 +3,431 @@ #include "XSUB.h" #include +#include +#include +#include +#include + +/* Used by the *_setl() functions */ +typedef char opaquechar; + +/* Used as the return value of the *_getl() functions */ +struct datachunk { + char *data; + int len; +}; + +/* Used to package Perl function-pointer and user-data together */ +struct callback_block { + SV *function; + SV *handle; +}; + +/* The callback function used for ZOOM_options_set_callback(). I do + * not claim to fully understand all the stack-hacking magic, and less + * still the reference-counting/mortality stuff. Accordingly, the + * memory management here is best characterised as What I Could Get To + * Work, More Or Less. + */ +const char *__ZOOM_option_callback (void *handle, const char *name) +{ + struct callback_block *cb = (struct callback_block*) handle; + int count; + SV *ret; + char *s; + char *res; + + dSP; + + ENTER; + SAVETMPS; + + PUSHMARK(SP); + XPUSHs(cb->handle); + XPUSHs(sv_2mortal(newSVpv(name, 0))); + PUTBACK; + /* Perl_sv_dump(0, cb->function); */ + + count = call_sv(cb->function, G_SCALAR); + + SPAGAIN; + + if (count != 1) + croak("callback function for ZOOM_options_get() returned %d values: should have returned exactly one", count); + + ret = POPs; + if (SvPOK(ret)) { + s = SvPV_nolen(ret); + /* ### `res' never gets freed! I think it is + * impossible to solve this problem "correctly" + * because the ZOOM-C option callback interface is + * inadequate. */ + res = xstrdup(s); + } else { + res = 0; + } + + PUTBACK; + FREETMPS; + LEAVE; + + return res; +} + + +MODULE = Net::Z3950::ZOOM PACKAGE = Net::Z3950::ZOOM PREFIX=ZOOM_ + +PROTOTYPES: ENABLE -MODULE = ZOOM PACKAGE = ZOOM - +ZOOM_connection +ZOOM_connection_new(host, portnum) + const char* host + int portnum -const char * -ZOOM_connection_addinfo(c) - ZOOM_connection c +ZOOM_connection +ZOOM_connection_create(options) + ZOOM_options options void ZOOM_connection_connect(c, host, portnum) ZOOM_connection c - const char * host - int portnum - -ZOOM_connection -ZOOM_connection_create(options) - ZOOM_options options + const char* host + int portnum void ZOOM_connection_destroy(c) ZOOM_connection c -int -ZOOM_connection_errcode(c) +const char * +ZOOM_connection_option_get(c, key) ZOOM_connection c + const char *key -const char * -ZOOM_connection_errmsg(c) +struct datachunk +ZOOM_connection_option_getl(c, key, len) ZOOM_connection c + const char* key + int &len + CODE: + RETVAL.data = (char*) ZOOM_connection_option_getl(c, key, &len); + RETVAL.len = len; + OUTPUT: + RETVAL + len +void +ZOOM_connection_option_set(c, key, val) + ZOOM_connection c + const char *key + const char *val + +# In ZOOM-C, the `val' parameter is const char*. However, our typemap +# treats this as T_PV, i.e. it's "known" that it points to a +# NUL-terminated string. Instead, then, I here use opaquechar*, which +# is an opaque pointer. The underlying C function can then use this +# along with `len' to Do The Right Thing. +# +void +ZOOM_connection_option_setl(c, key, val, len) + ZOOM_connection c + const char* key + opaquechar* val + int len + +# The reference parameters, `cp' and `addinfo', need to already have +# values when this function is called, otherwise an "uninitialised +# value" warning is generated. As far as I can see, there is no way +# around this: no way to specify in a prototype that an argument is +# allowed to be undefined, for example. Since these function will +# never be called directly by well-behaved client code, but only by +# our own wrapper classes, I think we can live with that. +# +# The poxing about with cpp and caddinfo is due to Perl XS's lack of +# support for const char**, but who can blame it? If you ask me, the +# whole "const" thing was well-intentioned by ghastly mistake. +# int ZOOM_connection_error(c, cp, addinfo) ZOOM_connection c - const char ** cp - const char ** addinfo - + char* &cp + char* &addinfo + CODE: + { + const char *ccp, *caddinfo; + RETVAL = ZOOM_connection_error(c, &ccp, &caddinfo); + cp = (char*) ccp; + addinfo = (char*) caddinfo; + } + OUTPUT: + RETVAL + cp + addinfo + +# See comments for ZOOM_connection_error() above int ZOOM_connection_error_x(c, cp, addinfo, diagset) ZOOM_connection c - const char ** cp - const char ** addinfo - const char ** diagset + const char * &cp + const char * &addinfo + const char * &diagset + CODE: + { + const char *ccp, *caddinfo, *cdset; + RETVAL = ZOOM_connection_error_x(c, &ccp, &caddinfo, &cdset); + cp = (char*) ccp; + addinfo = (char*) caddinfo; + diagset = (char*) cdset; + } + OUTPUT: + RETVAL + cp + addinfo + diagset int -ZOOM_connection_last_event(cs) - ZOOM_connection cs - -ZOOM_connection -ZOOM_connection_new(host, portnum) - const char * host - int portnum +ZOOM_connection_errcode(c) + ZOOM_connection c const char * -ZOOM_connection_option_get(c, key) +ZOOM_connection_errmsg(c) ZOOM_connection c - const char * key -void -ZOOM_connection_option_set(c, key, val) +const char * +ZOOM_connection_addinfo(c) ZOOM_connection c - const char * key - const char * val -void -ZOOM_connection_option_setl(c, key, val, len) +const char * +ZOOM_connection_diagset(c) ZOOM_connection c - const char * key - const char * val - int len -ZOOM_package -ZOOM_connection_package(c, options) - ZOOM_connection c - ZOOM_options options +const char * +ZOOM_diag_str(error) + int error -ZOOM_scanset -ZOOM_connection_scan(c, startterm) - ZOOM_connection c - const char * startterm +const char * +ZOOM_diag_srw_str(error) + int error + CODE: + RETVAL = yaz_diag_srw_str(error); + OUTPUT: + RETVAL ZOOM_resultset ZOOM_connection_search(arg0, q) ZOOM_connection arg0 - ZOOM_query q + ZOOM_query q ZOOM_resultset ZOOM_connection_search_pqf(c, q) - ZOOM_connection c - const char * q - -const char * -ZOOM_diag_str(error) - int error - -int -ZOOM_event(no, cs) - int no - ZOOM_connection * cs - -ZOOM_options -ZOOM_options_create() - -ZOOM_options -ZOOM_options_create_with_parent(parent) - ZOOM_options parent - -ZOOM_options -ZOOM_options_create_with_parent2(parent1, parent2) - ZOOM_options parent1 - ZOOM_options parent2 + ZOOM_connection c + const char *q void -ZOOM_options_destroy(opt) - ZOOM_options opt +ZOOM_resultset_destroy(r) + ZOOM_resultset r const char * -ZOOM_options_get(opt, name) - ZOOM_options opt - const char * name +ZOOM_resultset_option_get(r, key) + ZOOM_resultset r + const char* key -int -ZOOM_options_get_bool(opt, name, defa) - ZOOM_options opt - const char * name - int defa +void +ZOOM_resultset_option_set(r, key, val) + ZOOM_resultset r + const char* key + const char* val -int -ZOOM_options_get_int(opt, name, defa) - ZOOM_options opt - const char * name - int defa +size_t +ZOOM_resultset_size(r) + ZOOM_resultset r + +SV * +ZOOM_resultset_records(r, start, count, return_records) + ZOOM_resultset r + size_t start + size_t count + int return_records + CODE: + { + ZOOM_record *recs = 0; + if (return_records) + recs = (ZOOM_record*) xmalloc(count * sizeof *recs); + ZOOM_resultset_records(r, recs, start, count); + if (return_records) { + AV *av = newAV(); + int i; + for (i = 0; i < count; i++) { + SV *tmp = newSV(0); + sv_setref_pv(tmp, "ZOOM_record", (void*) recs[i]); + av_push(av, tmp); + } + RETVAL = newRV((SV*) av); + } else { + RETVAL = &PL_sv_undef; + } + } + OUTPUT: + RETVAL -void -ZOOM_options_set(opt, name, v) - ZOOM_options opt - const char * name - const char * v +ZOOM_record +ZOOM_resultset_record(s, pos) + ZOOM_resultset s + size_t pos -ZOOM_options_callback -ZOOM_options_set_callback(opt, c, handle) - ZOOM_options opt - ZOOM_options_callback c - void * handle +ZOOM_record +ZOOM_resultset_record_immediate(s, pos) + ZOOM_resultset s + size_t pos void -ZOOM_options_set_int(opt, name, value) - ZOOM_options opt - const char * name - int value +ZOOM_resultset_cache_reset(r) + ZOOM_resultset r +# TESTED (but deprecated) void -ZOOM_options_setl(opt, name, value, len) - ZOOM_options opt - const char * name - const char * value - int len +ZOOM_resultset_sort(r, sort_type, sort_spec) + ZOOM_resultset r + const char* sort_type + const char* sort_spec + +int +ZOOM_resultset_sort1(r, sort_type, sort_spec) + ZOOM_resultset r + const char* sort_type + const char* sort_spec + +# See comments for ZOOM_connection_error() above +int +ZOOM_record_error(rec, cp, addinfo, diagset) + ZOOM_record rec + const char* &cp + const char* &addinfo + const char* &diagset + CODE: + { + const char *ccp = "", *caddinfo = "", *cdset = ""; + RETVAL = ZOOM_record_error(rec, &ccp, &caddinfo, &cdset); + cp = (char*) ccp; + addinfo = (char*) caddinfo; + diagset = (char*) cdset; + } + OUTPUT: + RETVAL + cp + addinfo + diagset + +# See "typemap" for discussion of the "const char *" return-type. +const char * +ZOOM_record_get_string(rec, type) + ZOOM_record rec + const char* type + INIT: + int len; + CODE: + RETVAL = ZOOM_record_get(rec, type, &len); + OUTPUT: + RETVAL + +struct datachunk +ZOOM_record_get_binary(rec, type) + ZOOM_record rec + const char* type + CODE: + RETVAL.data = (char*) ZOOM_record_get(rec, type, &RETVAL.len); + OUTPUT: + RETVAL void -ZOOM_package_destroy(p) - ZOOM_package p +ZOOM_record_destroy(rec) + ZOOM_record rec -const char * -ZOOM_package_option_get(p, key) - ZOOM_package p - const char * key +ZOOM_record +ZOOM_record_clone(srec) + ZOOM_record srec -void -ZOOM_package_option_set(p, key, val) - ZOOM_package p - const char * key - const char * val +ZOOM_query +ZOOM_query_create() void -ZOOM_package_send(p, type) - ZOOM_package p - const char * type +ZOOM_query_destroy(s) + ZOOM_query s int ZOOM_query_cql(s, str) - ZOOM_query s - const char * str + ZOOM_query s + const char* str -ZOOM_query -ZOOM_query_create() +int +ZOOM_query_cql2rpn(s, str, conn) + ZOOM_query s + const char* str + ZOOM_connection conn -void -ZOOM_query_destroy(s) - ZOOM_query s +int +ZOOM_query_ccl2rpn(s, query_str, config, errcode, errstr, errpos) + ZOOM_query s + const char* query_str + const char* config + int &errcode + const char* &errstr + int &errpos + OUTPUT: + RETVAL + errcode + errstr + errpos int ZOOM_query_prefix(s, str) - ZOOM_query s - const char * str + ZOOM_query s + const char* str int ZOOM_query_sortby(s, criteria) ZOOM_query s const char * criteria -ZOOM_record -ZOOM_record_clone(srec) - ZOOM_record srec +ZOOM_scanset +ZOOM_connection_scan(c, startterm) + ZOOM_connection c + const char* startterm -void -ZOOM_record_destroy(rec) - ZOOM_record rec +ZOOM_scanset +ZOOM_connection_scan1(c, startterm) + ZOOM_connection c + ZOOM_query startterm const char * -ZOOM_record_get(rec, type, len) - ZOOM_record rec - const char * type - int * len - -void -ZOOM_resultset_cache_reset(r) - ZOOM_resultset r - -void -ZOOM_resultset_destroy(r) - ZOOM_resultset r +ZOOM_scanset_term(scan, pos, occ, len) + ZOOM_scanset scan + size_t pos + size_t& occ + size_t& len + OUTPUT: + RETVAL + occ + len const char * -ZOOM_resultset_option_get(r, key) - ZOOM_resultset r - const char * key - -void -ZOOM_resultset_option_set(r, key, val) - ZOOM_resultset r - const char * key - const char * val - -ZOOM_record -ZOOM_resultset_record(s, pos) - ZOOM_resultset s - size_t pos - -ZOOM_record -ZOOM_resultset_record_immediate(s, pos) - ZOOM_resultset s - size_t pos - -void -ZOOM_resultset_records(r, recs, start, count) - ZOOM_resultset r - ZOOM_record * recs - size_t start - size_t count +ZOOM_scanset_display_term(scan, pos, occ, len) + ZOOM_scanset scan + size_t pos + size_t& occ + size_t& len + OUTPUT: + RETVAL + occ + len size_t -ZOOM_resultset_size(r) - ZOOM_resultset r - -void -ZOOM_resultset_sort(r, sort_type, sort_spec) - ZOOM_resultset r - const char * sort_type - const char * sort_spec +ZOOM_scanset_size(scan) + ZOOM_scanset scan void ZOOM_scanset_destroy(scan) - ZOOM_scanset scan - -const char * -ZOOM_scanset_display_term(scan, pos, occ, len) - ZOOM_scanset scan - size_t pos - int * occ - int * len + ZOOM_scanset scan const char * ZOOM_scanset_option_get(scan, key) @@ -285,631 +440,260 @@ ZOOM_scanset_option_set(scan, key, val) const char * key const char * val -size_t -ZOOM_scanset_size(scan) - ZOOM_scanset scan - -const char * -ZOOM_scanset_term(scan, pos, occ, len) - ZOOM_scanset scan - size_t pos - int * occ - int * len - +# We ignore the return value of ZOOM_options_set_callback(), since it +# is always just the address of the __ZOOM_option_callback() function. +# The information that we actually want -- the address of the Perl +# function in the callback_block -- is unavailable to us, as the +# underlying C function doesn't give the block back. +# void -_Exit(__status) - int __status - -size_t -__ctype_get_mb_cur_max() - -char * -__secure_getenv(__name) - __const char * __name - -double -__strtod_internal(__nptr, __endptr, __group) - __const char * __nptr - char ** __endptr - int __group - -float -__strtof_internal(__nptr, __endptr, __group) - __const char * __nptr - char ** __endptr - int __group - -long int -__strtol_internal(__nptr, __endptr, __base, __group) - __const char * __nptr - char ** __endptr - int __base - int __group - -long double -__strtold_internal(__nptr, __endptr, __group) - __const char * __nptr - char ** __endptr - int __group - -__extension__ extern long long int -__strtoll_internal(__nptr, __endptr, __base, __group) - __const char * __nptr - char ** __endptr - int __base - int __group - -unsigned long int -__strtoul_internal(__nptr, __endptr, __base, __group) - __const char * __nptr - char ** __endptr - int __base - int __group - -__extension__ extern unsigned long long int -__strtoull_internal(__nptr, __endptr, __base, __group) - __const char * __nptr - char ** __endptr - int __base - int __group - -long int -a64l(__s) - __const char * __s +ZOOM_options_set_callback(opt, function, handle) + ZOOM_options opt + SV* function; + SV* handle; + CODE: + { + /* The tiny amount of memory allocated here is never + * released, as options_destroy() doesn't do anything + * to the callback information. Not a big deal. + * Also, I have no idea how to drive the Perl "mortal" + * reference-counting stuff, so I am just allocating + * copies which also never get released. Don't sue! + */ + struct callback_block *block = (struct callback_block*) + xmalloc(sizeof *block); + block->function = function; + block->handle = handle; + SvREFCNT(block->function); + SvREFCNT(block->handle); + ZOOM_options_set_callback(opt, __ZOOM_option_callback, + (void*) block); + } -void -abort() - -int -abs(__x) - int __x - -void * -alloca(__size) - size_t __size +ZOOM_options +ZOOM_options_create() -int -atexit(arg0) - void ( * __func ) ( void ) arg0 +ZOOM_options +ZOOM_options_create_with_parent(parent) + ZOOM_options parent -double -atof(__nptr) - __const char * __nptr +ZOOM_options +ZOOM_options_create_with_parent2(parent1, parent2) + ZOOM_options parent1 + ZOOM_options parent2 -int -atoi(__nptr) - __const char * __nptr - -long int -atol(__nptr) - __const char * __nptr - -__extension__ extern long long int -atoll(__nptr) - __const char * __nptr - -void * -bsearch(__key, __base, __nmemb, __size, __compar) - __const void * __key - __const void * __base - size_t __nmemb - size_t __size - __compar_fn_t __compar - -void * -calloc(__nmemb, __size) - size_t __nmemb - size_t __size - -char * -canonicalize_file_name(__name) - __const char * __name +const char * +ZOOM_options_get(opt, name) + ZOOM_options opt + const char* name + +struct datachunk +ZOOM_options_getl(opt, name, len) + ZOOM_options opt + const char* name + int &len + CODE: + RETVAL.data = (char*) ZOOM_options_getl(opt, name, &len); + RETVAL.len = len; + OUTPUT: + RETVAL + len void -cfree(__ptr) - void * __ptr - -int -clearenv() - -div_t -div(__numer, __denom) - int __numer - int __denom - -double -drand48() - -int -drand48_r(__buffer, __result) - struct drand48_data * __buffer - double * __result - -char * -ecvt(__value, __ndigit, __decpt, __sign) - double __value - int __ndigit - int * __decpt - int * __sign - -int -ecvt_r(__value, __ndigit, __decpt, __sign, __buf, __len) - double __value - int __ndigit - int * __decpt - int * __sign - char * __buf - size_t __len - -double -erand48(__xsubi) - unsigned short int __xsubi[3] - -int -erand48_r(__xsubi, __buffer, __result) - unsigned short int __xsubi[3] - struct drand48_data * __buffer - double * __result +ZOOM_options_set(opt, name, v) + ZOOM_options opt + const char* name + const char* v void -exit(__status) - int __status - -char * -fcvt(__value, __ndigit, __decpt, __sign) - double __value - int __ndigit - int * __decpt - int * __sign - -int -fcvt_r(__value, __ndigit, __decpt, __sign, __buf, __len) - double __value - int __ndigit - int * __decpt - int * __sign - char * __buf - size_t __len +ZOOM_options_setl(opt, name, value, len) + ZOOM_options opt + const char* name + opaquechar* value + int len void -free(__ptr) - void * __ptr - -char * -gcvt(__value, __ndigit, __buf) - double __value - int __ndigit - char * __buf - -char * -getenv(__name) - __const char * __name - -int -getloadavg(__loadavg, __nelem) - double __loadavg[] - int __nelem - -int -getpt() - -int -getsubopt(__optionp, __tokens, __valuep) - char ** __optionp - char * __const * __tokens - char ** __valuep - -int -grantpt(__fd) - int __fd - -char * -initstate(__seed, __statebuf, __statelen) - unsigned int __seed - char * __statebuf - size_t __statelen +ZOOM_options_destroy(opt) + ZOOM_options opt int -initstate_r(__seed, __statebuf, __statelen, __buf) - unsigned int __seed - char * __statebuf - size_t __statelen - struct random_data * __buf - -long int -jrand48(__xsubi) - unsigned short int __xsubi[3] +ZOOM_options_get_bool(opt, name, defa) + ZOOM_options opt + const char* name + int defa int -jrand48_r(__xsubi, __buffer, __result) - unsigned short int __xsubi[3] - struct drand48_data * __buffer - long int * __result - -char * -l64a(__n) - long int __n - -long int -labs(__x) - long int __x +ZOOM_options_get_int(opt, name, defa) + ZOOM_options opt + const char* name + int defa void -lcong48(__param) - unsigned short int __param[7] - -int -lcong48_r(__param, __buffer) - unsigned short int __param[7] - struct drand48_data * __buffer - -ldiv_t -ldiv(__numer, __denom) - long int __numer - long int __denom - -__extension__ extern long long int -llabs(__x) - long long int __x - -__extension__ extern lldiv_t -lldiv(__numer, __denom) - long long int __numer - long long int __denom - -long int -lrand48() - -int -lrand48_r(__buffer, __result) - struct drand48_data * __buffer - long int * __result - -void * -malloc(__size) - size_t __size - -int -mblen(__s, __n) - __const char * __s - size_t __n - -size_t -mbstowcs(__pwcs, __s, __n) - wchar_t * __pwcs - __const char * __s - size_t __n - -int -mbtowc(__pwc, __s, __n) - wchar_t * __pwc - __const char * __s - size_t __n - -char * -mkdtemp(__template) - char * __template - -int -mkstemp(__template) - char * __template - -int -mkstemp64(__template) - char * __template - -char * -mktemp(__template) - char * __template - -long int -mrand48() - -int -mrand48_r(__buffer, __result) - struct drand48_data * __buffer - long int * __result - -long int -nrand48(__xsubi) - unsigned short int __xsubi[3] - -int -nrand48_r(__xsubi, __buffer, __result) - unsigned short int __xsubi[3] - struct drand48_data * __buffer - long int * __result - -int -on_exit(arg0, __arg) - void ( * __func ) ( int __status, void * __arg ) arg0 - void * __arg - -int -posix_memalign(__memptr, __alignment, __size) - void ** __memptr - size_t __alignment - size_t __size - -int -posix_openpt(__oflag) - int __oflag - -int -pselect(__nfds, __readfds, __writefds, __exceptfds, __timeout, __sigmask) - int __nfds - fd_set * __readfds - fd_set * __writefds - fd_set * __exceptfds - const struct timespec * __timeout - const __sigset_t * __sigmask - -char * -ptsname(__fd) - int __fd - -int -ptsname_r(__fd, __buf, __buflen) - int __fd - char * __buf - size_t __buflen +ZOOM_options_set_int(opt, name, value) + ZOOM_options opt + const char* name + int value -int -putenv(__string) - char * __string +ZOOM_package +ZOOM_connection_package(c, options) + ZOOM_connection c + ZOOM_options options -char * -qecvt(__value, __ndigit, __decpt, __sign) - long double __value - int __ndigit - int * __decpt - int * __sign +void +ZOOM_package_destroy(p) + ZOOM_package p -int -qecvt_r(__value, __ndigit, __decpt, __sign, __buf, __len) - long double __value - int __ndigit - int * __decpt - int * __sign - char * __buf - size_t __len - -char * -qfcvt(__value, __ndigit, __decpt, __sign) - long double __value - int __ndigit - int * __decpt - int * __sign +void +ZOOM_package_send(p, type) + ZOOM_package p + const char * type -int -qfcvt_r(__value, __ndigit, __decpt, __sign, __buf, __len) - long double __value - int __ndigit - int * __decpt - int * __sign - char * __buf - size_t __len - -char * -qgcvt(__value, __ndigit, __buf) - long double __value - int __ndigit - char * __buf +const char * +ZOOM_package_option_get(p, key) + ZOOM_package p + const char * key void -qsort(__base, __nmemb, __size, __compar) - void * __base - size_t __nmemb - size_t __size - __compar_fn_t __compar +ZOOM_package_option_set(p, key, val) + ZOOM_package p + const char * key + const char * val -int -rand() +# This has to be called with a single argument which is a _reference_ +# to an array -- rather than directly with an array, which is of +# course identical to passing arbitrarily many arguments. This is +# because there doesn't seem to be a way to do varargs in an XS +# function. +# +int +ZOOM_event(conns) + SV* conns + INIT: + SV *realconns; + I32 n, i; + ZOOM_connection *cs; + CODE: + /*printf("* in ZOOM_event(%p)\n", conns);*/ + if (!SvROK(conns)) { + /*printf("* argument is not a reference\n");*/ + XSRETURN_IV(-1); + } + realconns = SvRV(conns); + /*printf("* realconns = %p\n", realconns);*/ + if (SvTYPE(realconns) != SVt_PVAV) { + /*printf("* reference is not to an array\n");*/ + XSRETURN_IV(-2); + } + n = av_len((AV*) realconns); + n++; /* The av_len() return-value is zero-based */ + if (n == 0) { + /*printf("* No connections in referenced array\n");*/ + XSRETURN_IV(-3); + } + + /*printf("* n = %d\n", n);*/ + if ((cs = (ZOOM_connection*) malloc(n * sizeof *cs)) == 0) { + /*printf("* Too many connections (%d)\n", (int) n);*/ + XSRETURN_IV(-4); + } + + for (i = 0; i < n; i++) { + SV **connp = av_fetch((AV*) realconns, i, (I32) 0); + SV *conn, *sv; + /*printf("* %d of %d: connp = %p\n", (int) i, (int) n,connp);*/ + assert(connp != 0); + conn = *connp; + /*printf("* conn = %p\n", conn);*/ + /* + * From here on, the tests and assertions seem to + * be ignored: if I pass in a reference to + * something other than a ZOOM_connection, or even + * if I pass a non-reference, the assertions still + * pass and everything seems to work until the + * segmentation fault bites. + */ + assert(sv_derived_from(conn, "ZOOM_connection")); + /*printf("* passed assert(isa(ZOOM_connection))\n");*/ + assert(SvROK(conn)); + /*printf("* passed assert SvROK()\n");*/ + sv = (SV*) SvRV(conn); + /*printf("* sv = %p\n", sv);*/ + cs[i] = INT2PTR(ZOOM_connection, SvIV(sv)); + /*printf("got cs[%d] of %d = %p\n", (int) i, (int) n, cs[i]);*/ + } + RETVAL = ZOOM_event((int) n, cs); + free(cs); + OUTPUT: + RETVAL int -rand_r(__seed) - unsigned int * __seed - -long int -random() +ZOOM_connection_last_event(cs) + ZOOM_connection cs int -random_r(__buf, __result) - struct random_data * __buf - int32_t * __result - -void * -realloc(__ptr, __size) - void * __ptr - size_t __size - -char * -realpath(__name, __resolved) - __const char * __name - char * __resolved +ZOOM_connection_is_idle(cs) + ZOOM_connection cs int -rpmatch(__response) - __const char * __response +ZOOM_connection_peek_event(cs) + ZOOM_connection cs -unsigned short int * -seed48(__seed16v) - unsigned short int __seed16v[3] -int -seed48_r(__seed16v, __buffer) - unsigned short int __seed16v[3] - struct drand48_data * __buffer +# ---------------------------------------------------------------------------- +# What follows is the YAZ logging API. This is not strictly part of +# ZOOM, but it's so useful that it would be silly to omit. int -select(__nfds, __readfds, __writefds, __exceptfds, __timeout) - int __nfds - fd_set * __readfds - fd_set * __writefds - fd_set * __exceptfds - struct timeval * __timeout +yaz_log_mask_str(str) + const char *str int -setenv(__name, __value, __replace) - __const char * __name - __const char * __value - int __replace +yaz_log_module_level(name) + const char *name void -setkey(__key) - __const char * __key - -char * -setstate(__statebuf) - char * __statebuf - -int -setstate_r(__statebuf, __buf) - char * __statebuf - struct random_data * __buf +yaz_log_init(level, prefix, name) + int level + const char *prefix + const char *name void -srand(__seed) - unsigned int __seed +yaz_log_init_file(fname) + const char *fname void -srand48(__seedval) - long int __seedval - -int -srand48_r(__seedval, __buffer) - long int __seedval - struct drand48_data * __buffer +yaz_log_init_level(level) + int level void -srandom(__seed) - unsigned int __seed +yaz_log_init_prefix(prefix) + const char *prefix -int -srandom_r(__seed, __buf) - unsigned int __seed - struct random_data * __buf - -double -strtod(__nptr, __endptr) - __const char * __nptr - char ** __endptr - -double -strtod_l(__nptr, __endptr, __loc) - __const char * __nptr - char ** __endptr - __locale_t __loc - -float -strtof(__nptr, __endptr) - __const char * __nptr - char ** __endptr - -float -strtof_l(__nptr, __endptr, __loc) - __const char * __nptr - char ** __endptr - __locale_t __loc - -long int -strtol(__nptr, __endptr, __base) - __const char * __nptr - char ** __endptr - int __base - -long int -strtol_l(__nptr, __endptr, __base, __loc) - __const char * __nptr - char ** __endptr - int __base - __locale_t __loc - -long double -strtold(__nptr, __endptr) - __const char * __nptr - char ** __endptr - -long double -strtold_l(__nptr, __endptr, __loc) - __const char * __nptr - char ** __endptr - __locale_t __loc - -__extension__ extern long long int -strtoll(__nptr, __endptr, __base) - __const char * __nptr - char ** __endptr - int __base - -__extension__ extern long long int -strtoll_l(__nptr, __endptr, __base, __loc) - __const char * __nptr - char ** __endptr - int __base - __locale_t __loc - -__extension__ extern long long int -strtoq(__nptr, __endptr, __base) - __const char * __nptr - char ** __endptr - int __base - -unsigned long int -strtoul(__nptr, __endptr, __base) - __const char * __nptr - char ** __endptr - int __base - -unsigned long int -strtoul_l(__nptr, __endptr, __base, __loc) - __const char * __nptr - char ** __endptr - int __base - __locale_t __loc - -__extension__ extern unsigned long long int -strtoull(__nptr, __endptr, __base) - __const char * __nptr - char ** __endptr - int __base - -__extension__ extern unsigned long long int -strtoull_l(__nptr, __endptr, __base, __loc) - __const char * __nptr - char ** __endptr - int __base - __locale_t __loc - -__extension__ extern unsigned long long int -strtouq(__nptr, __endptr, __base) - __const char * __nptr - char ** __endptr - int __base - -int -system(__command) - __const char * __command - -int -unlockpt(__fd) - int __fd - -int -unsetenv(__name) - __const char * __name +void +yaz_log_time_format(fmt) + const char *fmt -void * -valloc(__size) - size_t __size +void +yaz_log_init_max_size(mx) + int mx -size_t -wcstombs(__s, __pwcs, __n) - char * __s - __const wchar_t * __pwcs - size_t __n +# interfaces are horrible to code for a Perl-C interface +# layer. Instead, we expect Perl applications to construct the +# message themselves, and pass it in as an opaque lump. +void +yaz_log(level, str) + int level + const char *str + CODE: + yaz_log(level, "%s", str); + +# This is also not strictly part of ZOOM +unsigned long +yaz_version(version_str, sys_str) + char *version_str + char *sys_str + OUTPUT: + RETVAL + version_str + sys_str -int -wctomb(__s, __wchar) - char * __s - wchar_t __wchar