Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 2.188 )
Jabber-mod_perl
view release on metacpan or search on metacpan
patches/NADs.xs view on Meta::CPAN
SV * sv_elem
INIT:
int depth, el;
nad_t nad;
PPCODE:
nad = ((nad_t) SvIV(SvRV(sv_n)));
el = SvIV(sv_elem);
// find the children of the given node = + 1
if (el >= 0){
depth = nad->elems[el].depth + 1;
patches/NADs.xs view on Meta::CPAN
SV * sv_elem
INIT:
int attr, el;
nad_t nad;
PPCODE:
nad = ((nad_t) SvIV(SvRV(sv_n)));
el = SvIV(sv_elem);
if (el >= 0 && el < nad->ecur){
attr = nad->elems[el].attr;
while (attr >= 0){
JavaScript-Duktape-XS
view release on metacpan or search on metacpan
RETVAL = create_duktape_object(aTHX_ opt);
OUTPUT: RETVAL
void
reset(Duk* duk)
PPCODE:
tear_down(duk);
set_up(duk);
HV*
get_stats(Duk* duk)
RETVAL = duk->stats;
OUTPUT: RETVAL
void
reset_stats(Duk* duk)
PPCODE:
hv_clear(duk->stats);
HV*
get_msgs(Duk* duk)
CODE:
RETVAL = duk->msgs;
OUTPUT: RETVAL
void
reset_msgs(Duk* duk)
PPCODE:
hv_clear(duk->msgs);
SV*
get(Duk* duk, const char* name)
PREINIT:
JavaScript-SpiderMonkey
view release on metacpan or search on metacpan
SpiderMonkey.xs view on Meta::CPAN
char * name
######################################################################
PREINIT:
bool rc;
SV *sv = sv_newmortal();
PPCODE:
{
JS::RootedObject robj(cx, obj);
JS::RootedValue vp(cx);
rc = JS_GetProperty(cx, robj, name, &vp);
if (rc) {
SpiderMonkey.xs view on Meta::CPAN
int idx
######################################################################
PREINIT:
bool rc;
SV *sv = sv_newmortal();
PPCODE:
{
JS::RootedObject robj(cx, obj);
JS::RootedValue vp(cx);
rc = JS_GetElement(cx, robj, (uint32_t)idx, &vp);
if (rc) {
Judy
view release on metacpan or search on metacpan
Moved XS from Judy::HS to Judy.
Added Judy.pm, Judy.pod
Release script checks a -Duse64bitint perl.
Added notes to XS
DEADBEEF is sized to UVSIZE
Switched from PPCODE-style XS to CODE/OUTPUT-style XS to use implicit TARG.
Added typedefs for Pvoid_t, Word_t*, Word_t
Throw warning when UV/IV integers discard data when being truncated
for storage into native sized Word_t.
Require at least Alien-Judy 0.05
Removed const-c.inc, const-xs.inc from the dist since they're generated
Kernel-Keyring
view release on metacpan or search on metacpan
void
_key_read (key_id)
int key_id
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
_key_read(key_id);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Keystone
view release on metacpan or search on metacpan
Keystone.xs view on Meta::CPAN
ks_version()
PREINIT:
int major, minor;
PPCODE:
ks_version(&major, &minor);
EXTEND(SP, 2);
XST_mIV(0, major);
XST_mIV(1, minor);
Keystone.xs view on Meta::CPAN
PREINIT:
size_t size, i, count;
unsigned char *opcodes;
int ret;
PPCODE:
if(SvTYPE(code) != SVt_PV) {
croak("<code> argument not an array scalar");
}
Keyword-API
view release on metacpan or search on metacpan
next_keyword_plugin = PL_keyword_plugin;
PL_keyword_plugin = my_keyword_plugin;
void
install_keyword(SV *classname, SV *keyword)
PPCODE:
keyword_enable(classname,keyword);
void
uninstall_keyword();
PPCODE:
keyword_disable();
void
lex_read_space(int flag);
Keyword-Pluggable
view release on metacpan or search on metacpan
Pluggable.xs view on Meta::CPAN
BOOT:
my_boot(aTHX);
void define_global (char *kw, SV *entry)
PPCODE:
{
if ( !global_kw ) return;
hv_store( global_kw, kw, strlen(kw), newSVsv(entry), 0);
}
void undefine_global (char *kw)
PPCODE:
{
if ( !global_kw ) return;
hv_delete( global_kw, kw, strlen(kw), G_DISCARD);
}
void cleanup()
PPCODE:
{
sv_free(( SV *) global_kw);
global_kw = NULL;
}
KinoSearch
view release on metacpan or search on metacpan
clownfish/lib/Clownfish/Binding/Perl.pm view on Meta::CPAN
MODULE = KinoSearch PACKAGE = KinoSearch::Autobinding
void
init_autobindings()
PPCODE:
{
char* file = __FILE__;
CHY_UNUSED_VAR(cv);
CHY_UNUSED_VAR(items); $xs_init
}
KinoSearch1
view release on metacpan or search on metacpan
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
new(either_sv)
SV *either_sv;
PREINIT:
const char *class;
TokenBatch *batch;
PPCODE:
/* determine the class */
class = sv_isobject(either_sv)
? sv_reftype(either_sv, 0)
: SvPV_nolen(either_sv);
/* build object */
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
PREINIT:
char *text;
STRLEN len;
I32 pos_inc = 1;
Token *token;
PPCODE:
text = SvPV(text_sv, len);
if (items == 5)
pos_inc = SvIV( ST(4) );
else if (items > 5)
Kino1_confess("Too many arguments: %d", items);
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
STRLEN len, start_offset, end_offset;
I32 i, max;
SV **start_sv_ptr;
SV **end_sv_ptr;
Token *token;
PPCODE:
{
string_start = SvPV(string_sv, len);
max = av_len(starts_av);
for (i = 0; i <= max; i++) {
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
void
build_posting_list(batch, doc_num, field_num)
TokenBatch *batch;
U32 doc_num;
U16 field_num;
PPCODE:
Kino1_TokenBatch_build_plist(batch, doc_num, field_num);
void
set_all_texts(batch, texts_av)
TokenBatch *batch;
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
Token *token;
I32 i, max;
SV **sv_ptr;
char *text;
STRLEN len;
PPCODE:
{
token = batch->first;
max = av_len(texts_av);
for (i = 0; i <= max; i++) {
if (token == NULL) {
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
get_all_texts(batch)
TokenBatch *batch;
PREINIT:
Token *token;
AV *out_av;
PPCODE:
{
out_av = newAV();
token = batch->first;
while (token != NULL) {
SV *text = newSVpvn(token->text, token->len);
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
OUTPUT: RETVAL
void
reset(batch)
TokenBatch *batch;
PPCODE:
Kino1_TokenBatch_reset(batch);
I32
next(batch)
TokenBatch *batch;
lib/KinoSearch1/Analysis/TokenBatch.pm view on Meta::CPAN
OUTPUT: RETVAL
void
DESTROY(batch)
TokenBatch *batch;
PPCODE:
Kino1_TokenBatch_destroy(batch);
__H__
Krb4
view release on metacpan or search on metacpan
PREINIT:
char host[MAXHOSTNAMELEN];
char *phost;
PPCODE:
phost=(char *)krb_get_phost(alias);
strncpy(host,phost,MAXHOSTNAMELEN);
if (host) {
XPUSHs(sv_2mortal(newSVpv(host,strlen(host))));
}
PREINIT:
char realm[REALM_SZ];
int error;
PPCODE:
error=krb_get_lrealm(realm,n);
seterror(error);
XPUSHs(sv_2mortal(newSVpv(realm,strlen(realm))));
void
char * host
PREINIT:
char *realm;
PPCODE:
realm=(char *)krb_realmofhost(host);
seterror(0);
XPUSHs(sv_2mortal(newSVpv(realm,strlen(realm))));
int
PREINIT:
des_cblock *k;
int error=0;
PPCODE:
if (!New(0,k,1,des_cblock)) XSRETURN_UNDEF;
error=read_service_key(user,inst,realm,kvno,srvtab[0] ? srvtab : (char *)0,(char *)k);
seterror(error);
if (error) XSRETURN_UNDEF;
XPUSHs(sv_2mortal(newSVpv((char *)k,sizeof(des_cblock))));
void
krb4_get_err_txt(n)
int n
PPCODE:
if (n < 0 || n > 255) {
XPUSHs(newSVsv(&PL_sv_undef));
}
else {
XPUSHs(newSVpv(krb_err_txt[n],strlen(krb_err_txt[n])));
PREINIT:
KTEXT authent;
int error;
PPCODE:
if (!New(0,authent,1,KTEXT_ST)) XSRETURN_UNDEF;
error=krb_mk_req(authent,service,instance,realm,checksum);
seterror(error);
if (error == KSUCCESS) {
ST(0) = sv_newmortal();
PREINIT:
AUTH_DAT *ad;
int error;
PPCODE:
if (!New(0,ad,1,AUTH_DAT)) XSRETURN_UNDEF;
error=krb_rd_req(t,service,instance,(u_long)0,ad,fn);
seterror(error);
if (error == RD_AP_OK) {
ST(0) = sv_newmortal();
PREINIT:
CREDENTIALS *c;
int error;
PPCODE:
if (!New(0,c,1,CREDENTIALS)) XSRETURN_UNDEF;
error=krb_get_cred(service,instance,realm,c);
seterror(error);
if (error == GC_OK) {
ST(0) = sv_newmortal();
PREINIT:
C_Block session;
des_key_schedule *sched;
int error;
PPCODE:
if (!New(0,sched,1,des_key_schedule)) XSRETURN_UNDEF;
Copy(SvPV(sv_session,PL_na),&session,1,C_Block);
error=des_key_sched(session,sched);
seterror(error);
if (error == KSUCCESS) {
u_char *out;
des_cblock k;
long in_length;
long out_length;
PPCODE:
in_length=SvCUR(s_in);
if (in_length == 0) {
seterror(-1);
return;
}
des_cblock k;
int error;
long in_length;
MSG_DAT msg_data;
PPCODE:
in_length=SvCUR(s_in);
if (in_length == 0) {
seterror(-1);
return;
}
MSG_DAT msg_data;
CREDENTIALS *cred;
des_key_schedule *schedule;
int error,fd;
PPCODE:
if (!New(0,ktext,1,KTEXT_ST)) XSRETURN_UNDEF;
if (!New(0,cred,1,CREDENTIALS)) XSRETURN_UNDEF;
if (!New(0,schedule,1,des_key_schedule)) XSRETURN_UNDEF;
fd=fileno(fh);
error=krb_sendauth(options,fd,ktext,service,inst,realm,checksum,
AUTH_DAT *ad;
des_key_schedule *schedule;
char version[KRB_SENDAUTH_VLEN];
int error,fd;
PPCODE:
ktext=(KTEXT)safemalloc(sizeof(KTEXT_ST));
if (!ktext) XSRETURN_UNDEF;
ad=(AUTH_DAT *)safemalloc(sizeof(AUTH_DAT));
if (!ad) XSRETURN_UNDEF;
schedule=(des_key_schedule *)safemalloc(sizeof(des_key_schedule));
PREINIT:
KTEXT authent;
int error;
PPCODE:
if (!SvOK(dat)) XSRETURN_UNDEF;
authent=(KTEXT)safemalloc(sizeof(KTEXT_ST));
if (!authent) XSRETURN_UNDEF;
authent->length=SvCUR(dat);
Copy(SvPV(dat,PL_na),&authent->dat,authent->length,u_char);
void
dat(t)
Authen::Krb4::Ticket t
PPCODE:
XPUSHs(sv_2mortal(newSVpv((char *)&(t->dat),t->length)));
MODULE = Authen::Krb4 PACKAGE = Authen::Krb4::AuthDat
int
void
pname(ad)
Authen::Krb4::AuthDat ad
PPCODE:
XPUSHs(sv_2mortal(newSVpv(ad->pname,strlen(ad->pname))));
void
pinst(ad)
Authen::Krb4::AuthDat ad
PPCODE:
XPUSHs(sv_2mortal(newSVpv(ad->pinst,strlen(ad->pinst))));
void
prealm(ad)
Authen::Krb4::AuthDat ad
PPCODE:
XPUSHs(sv_2mortal(newSVpv(ad->prealm,strlen(ad->prealm))));
void
session(ad)
Authen::Krb4::AuthDat ad
PPCODE:
XPUSHs(sv_2mortal(newSVpv((char *)&(ad->session),sizeof(ad->session))));
void
k_flags(ad)
Authen::Krb4::AuthDat ad
PPCODE:
XPUSHs(sv_2mortal(newSVpv((char *)&(ad->k_flags),sizeof(ad->k_flags))));
void
checksum(ad)
Authen::Krb4::AuthDat ad
PPCODE:
XPUSHs(sv_2mortal(newSVnv(ad->checksum)));
void
life(ad)
Authen::Krb4::AuthDat ad
PPCODE:
XPUSHs(sv_2mortal(newSViv(ad->life)));
void
time_sec(ad)
Authen::Krb4::AuthDat ad
PPCODE:
XPUSHs(sv_2mortal(newSVnv(ad->time_sec)));
void
address(ad)
Authen::Krb4::AuthDat ad
PPCODE:
XPUSHs(sv_2mortal(newSVnv(ad->address)));
Authen::Krb4::Ticket
reply(ad)
Authen::Krb4::AuthDat ad
PPCODE:
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), "Authen::Krb4::Ticket", (void*)&ad->reply);
XSRETURN(1);
MODULE = Authen::Krb4 PACKAGE = Authen::Krb4::Creds
void
service(c)
Authen::Krb4::Creds c
PPCODE:
XPUSHs(sv_2mortal(newSVpv(c->service,strlen(c->service))));
void
instance(c)
Authen::Krb4::Creds c
PPCODE:
XPUSHs(sv_2mortal(newSVpv(c->instance,strlen(c->instance))));
void
realm(c)
Authen::Krb4::Creds c
PPCODE:
XPUSHs(sv_2mortal(newSVpv(c->realm,strlen(c->realm))));
void
lifetime(c)
Authen::Krb4::Creds c
PPCODE:
XPUSHs(sv_2mortal(newSViv(c->lifetime)));
void
kvno(c)
Authen::Krb4::Creds c
PPCODE:
XPUSHs(sv_2mortal(newSViv(c->kvno)));
void
issue_date(c)
Authen::Krb4::Creds c
PPCODE:
XPUSHs(sv_2mortal(newSVnv(c->issue_date)));
void
session(c)
Authen::Krb4::Creds c
PPCODE:
XPUSHs(sv_2mortal(newSVpv((char *)&(c->session),sizeof(c->session))));
Authen::Krb4::Ticket
ticket(c)
Authen::Krb4::Creds c
PPCODE:
ST(0) = sv_newmortal();
sv_setref_pv(ST(0), "Authen::Krb4::Ticket", (void*)&c->ticket_st);
XSRETURN(1);
void
pname(c)
Authen::Krb4::Creds c
PPCODE:
XPUSHs(sv_2mortal(newSVpv(c->pname,strlen(c->pname))));
void
pinst(c)
Authen::Krb4::Creds c
PPCODE:
XPUSHs(sv_2mortal(newSVpv(c->pinst,strlen(c->pinst))));
MODULE = Authen::Krb4 PACKAGE = Authen::Krb4::KeySchedule
Krb5
view release on metacpan or search on metacpan
krb5_get_default_realm()
PREINIT:
char *realm;
PPCODE:
err = krb5_get_default_realm(context,&realm);
if (err || !realm) XSRETURN_UNDEF;
XPUSHs(sv_2mortal(newSVpv(realm,strlen(realm))));
Safefree(realm);
PREINIT:
char **realmlist;
int i;
PPCODE:
err = krb5_get_host_realm(context,host,&realmlist);
if (err || !realmlist) XSRETURN_UNDEF;
for (i = 0; realmlist[i]; i++) {
XPUSHs(sv_2mortal(newSVpv(realmlist[i],
strlen(realmlist[i]))));
PREINIT:
krb5_data realm_data;
char **hostlist;
int i;
PPCODE:
realm_data.data = realm;
realm_data.length = strlen(realm);
err = krb5_get_krbhst(context,&realm_data,&hostlist);
if (err || !hostlist) XSRETURN_UNDEF;
for (i = 0; hostlist[i]; i++) {
SV *in
PREINIT:
krb5_data in_data, out_data;
PPCODE:
in_data.data = SvPV(in,in_data.length);
err = krb5_mk_priv(context,auth_context,&in_data,&out_data,NULL);
if (err) XSRETURN_UNDEF;
XPUSHs(sv_2mortal(newSVpv(out_data.data,out_data.length)));
/* krb5_free_data(context,&out_data); */
SV *in
PREINIT:
krb5_data in_data, out_data;
PPCODE:
in_data.data = SvPV(in,in_data.length);
err = krb5_rd_priv(context,auth_context,&in_data,&out_data,NULL);
if (err) XSRETURN_UNDEF;
XPUSHs(sv_2mortal(newSVpv(out_data.data,out_data.length)));
PREINIT:
krb5_data in_data;
krb5_creds *out_creds = NULL;
int fd;
PPCODE:
fd = fileno(fh);
in_data.data = SvPV(in,in_data.length);
err = krb5_sendauth(context,&auth_context,&fd,version,client,server,
options,&in_data,in_creds,cc,NULL,NULL,&out_creds);
if (err) XSRETURN_UNDEF;
PREINIT:
krb5_ticket *ticket = NULL;
int fd;
PPCODE:
fd = fileno(fh);
err = krb5_recvauth(context,&auth_context,&fd,version,server,0,
keytab,&ticket);
if (err) XSRETURN_UNDEF;
ST(0) = sv_newmortal();
void
data(p)
Authen::Krb5::Principal p
PPCODE:
if (p->length > 0) {
int len = p->length;
krb5_data *data;
EXTEND(sp,len);
void
contents(kb)
Authen::Krb5::KeyBlock kb
PPCODE:
/* sv_2mortal here causes 'Attempt to free unreferenced scalar' later */
XPUSHs(newSVpvn((char*)(kb->contents), kb->length));
int
enctype(kb)
Authen::Krb5::KeyBlock kb
PREINIT:
char buf[256];
PPCODE:
err = krb5_enctype_to_string(kb->enctype, buf, 255);
if (err) {
XSRETURN_UNDEF;
}
XPUSHs(newSVpv(buf, 0));
LCS-XS
view release on metacpan or search on metacpan
AV * s2
PREINIT:
struct CTX *ctx = (struct CTX *)SvIVX(SvRV(obj));
PPCODE:
int d, sn, i;
struct varray *ses = varray_new(sizeof(struct diff_edit), NULL);
IV n;
IV m;
SV * s2
PREINIT:
struct CTX *ctx = (struct CTX *)SvIVX(SvRV(obj));
PPCODE:
int d, sn, i;
struct varray *ses = varray_new(sizeof(struct diff_edit), NULL);
STRLEN n;
STRLEN m;
SV * s2
PREINIT:
struct CTX *ctx = (struct CTX *)SvIVX(SvRV(obj));
PPCODE:
int d, sn, i;
struct varray *ses = varray_new(sizeof(struct diff_edit), NULL);
STRLEN n;
STRLEN m;
LMDB_File
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
const char *pv;
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv, &pv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
LSF-Base
view release on metacpan or search on metacpan
PREINIT:
SV *rv;
int i, count=0, num;
LSF_Base_hostInfo *hi, *p;
char **c, **hl;
PPCODE:
for( c = hostlist; hostlist && *c; c++ ) count++;
if( count == 0 ) hostlist = NULL;
hi = ls_gethostinfo(resreq, &num, hostlist, count, options );
if(hi == NULL){
STATUS_NATIVE_SET(lserrno);
char* path
PREINIT:
struct config_param *param;
int i, count=0;
char **p;
PPCODE:
for( p = env; env && *p; p++ ) count++;
param = safemalloc(sizeof(struct config_param)*count + 1);
for( i=0; i<count; i++){
param[i].paramName = env[i];
}
LSF_Base_lsInfo *self;
PREINIT:
SV *rv;
int i;
LSF_Base_resItem *p;
PPCODE:
for( i = 0,p =self->resTable; i < self->nRes; i++,p++ ){
rv = newRV_inc(&PL_sv_undef);
sv_setref_iv(rv, "LSF::Base::resItemPtr",(IV)p);
XPUSHs(sv_2mortal(rv));
}
void
li_hostTypes(self)
LSF_Base_lsInfo *self;
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nTypes; i++){
XPUSHs(sv_2mortal(newSVpv(self->hostTypes[i],0)));
}
XSRETURN(self->nTypes);
void
li_hostModels(self)
LSF_Base_lsInfo *self;
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nModels; i++ ){
XPUSHs(sv_2mortal(newSVpv(self->hostModels[i],0)));
}
XSRETURN(self->nModels);
void
li_hostArchs(self)
LSF_Base_lsInfo *self;
PREINIT:
int i;
PPCODE:
for( i = 0; i < self->nTypes; i++){
XPUSHs(sv_2mortal(newSVpv(self->hostArchs[i],0)));
}
XSRETURN(self->nTypes);
li_modelRefs(self)
LSF_Base_lsInfo *self;
PREINIT:
int i;
int *p;
PPCODE:
for( i = 0,p = self->modelRefs; i < self->nModels; i++,p++ ){
XPUSHs(sv_2mortal(newSViv((int)*p)));
}
XSRETURN(self->nModels);
li_cpuFactor(self)
LSF_Base_lsInfo *self;
PREINIT:
int i;
float *p;
PPCODE:
for( i = 0,p = self->cpuFactor; i < self->nModels; i++,p++ ){
XPUSHs(sv_2mortal(newSVnv((double)*p)));
}
XSRETURN(self->nModels);
hi_resources(self)
LSF_Base_hostInfo *self;
PREINIT:
int i;
char *p;
PPCODE:
for( i = 0; i < self->nRes; i++ ){
XPUSHs(sv_2mortal(newSVpv(self->resources[i],0)));
}
XSRETURN(self->nRes);
void
hi_busyThreshold(self)
LSF_Base_hostInfo *self;
PREINIT:
int i;
PPCODE:
for( i=0; i < self->numIndx; i++ ){
XPUSHs(sv_2mortal(newSVnv(self->busyThreshold[i])));
}
XSRETURN(self->numIndx);
PREINIT:
struct hostLoad *hl, *p;
int num, i;
SV *rv;
PPCODE:
num = numhosts;
if(strlen(fromhost)==0) fromhost = NULL;
hl = ls_load( resreq, &num, options, fromhost);
if(hl == NULL){
STATUS_NATIVE_SET(lserrno);
# int numhosts
# int options
# char* fromhost
# char** hostlist
# char** indxnamelist
# PPCODE:
void
ls_loadofhosts( self, resreq, numhosts, options, fromhost, hostlist )
void *self
char* resreq
PREINIT:
LSF_Base_hostLoad *hl, *p;
int num, i, count;
SV *rv;
char **c;
PPCODE:
num = numhosts;
count = 0;
for( c = hostlist; hostlist && *c; c++ ) count++;
if( count == 0 ) hostlist = NULL;
if(strlen(fromhost)==0) fromhost = NULL;
PREINIT:
int num;
char *s, **list;
int i;
PPCODE:
num = numhosts;
if(strlen(fromhost)==0) fromhost = NULL;
list = ls_placereq( resreq, &num, options, fromhost );
if( list == NULL ){
STATUS_NATIVE_SET(lserrno);
char* fromhost
char **hostlist
PREINIT:
char **list,**c;
int num, i,count=0;
PPCODE:
num = numhosts;
for( c = hostlist; hostlist && *c; c++ ) count++;
if(strlen(fromhost)==0) fromhost = NULL;
list = ls_placeofhosts( resreq, &num, options, fromhost,
hostlist, count);
RETVAL
void
hl_status(self)
LSF_Base_hostLoad *self;
PPCODE:
XPUSHs(sv_2mortal(newSViv(self->status[0])));
XPUSHs(sv_2mortal(newSViv(self->status[1])));
XSRETURN(2);
void
LSF_Base_hostLoad *self;
PREINIT:
int i, ni;
float *p;
LSF_Base_lsInfo *li;
PPCODE:
/* At this point, I don't know the number of indices to return */
if(li_ni == 0){
li = ls_info();
li_ni = li->numIndx;
}
char* task
int mode
PREINIT:
char resreqstr[1024];
int ret;
PPCODE:
ret = ls_eligible(task, resreqstr, mode);
if( ret < 0 ){
STATUS_NATIVE_SET(lserrno);
SET_LSF_ERRMSG;
XSRETURN_EMPTY;
void *self
int sortflag
PREINIT:
char **list;
int num,i;
PPCODE:
num = ls_listrtask(&list, sortflag);
if( num == 0 ){
STATUS_NATIVE_SET(lserrno);
SET_LSF_ERRMSG;
XSRETURN_EMPTY;
void *self
int sortflag
PREINIT:
char **list;
int num,i;
PPCODE:
num = ls_listltask(&list, sortflag);
if( num == 0 ){
STATUS_NATIVE_SET(lserrno);
SET_LSF_ERRMSG;
XSRETURN_EMPTY;
ls_findmyconnections(self)
void *self
PREINIT:
char **p,**hosts;
int count=0;
PPCODE:
hosts = ls_findmyconnections();
if(hosts){
for( p = hosts; *p; p++){
XPUSHs(sv_2mortal(newSVpv(*p,0)));
count++;
PREINIT:
LSF_Base_rusage *ru;
LS_WAIT_T status;
int tid;
SV *rv;
PPCODE:
ru = safemalloc(sizeof(LSF_Base_rusage));
tid = ls_rwait(&status, options, ru);
if( tid < 0 ){
STATUS_NATIVE_SET(lserrno);
SET_LSF_ERRMSG;
int options
PREINIT:
LSF_Base_rusage *ru;
LS_WAIT_T status;
SV *rv;
PPCODE:
ru = safemalloc(sizeof(LSF_Base_rusage));
tid = ls_rwaittid(tid, &status, options, ru);
if( tid < 0 ){
STATUS_NATIVE_SET(lserrno);
SET_LSF_ERRMSG;
int on;
int max;
PREINIT:
int *tidlist;
int i, count;
PPCODE:
tidlist = safemalloc(sizeof(int)*max);
if( count = ls_getstdin(on, tidlist, max) < 0 ){
STATUS_NATIVE_SET(lserrno);
SET_LSF_ERRMSG;
XSRETURN_UNDEF;
ls_rfstat(self, rfd)
void *self
int rfd
PREINIT:
struct stat st;
PPCODE:
/*make this stat look more like the perl stat function*/
if( ls_rfstat(rfd, &st) < 0 ){
XSRETURN_UNDEF;
}
else{
void *self
char* host
char* fn
PREINIT:
struct stat st;
PPCODE:
/*make this stat look more like the perl stat function*/
if( ls_rstat(host, fn, &st) < 0 ){
XSRETURN_UNDEF;
}
else{
# void *self;
# FILE* fp;
# PREINIT:
# LSF_Base_lsfAcctRec *ar;
# SV *rv;
# PPCODE:
# if( (ar = ls_readrexlog(fp)) == NULL ){
# STATUS_NATIVE_SET(lserrno);
# SET_LSF_ERRMSG;
# XSRETURN_UNDEF;
# }
#void
#ar_lsfRu(self)
# LSF_Base_lsfAcctRec *self;
# PREINIT:
# SV* rv;
# PPCODE:
# rv = newRV_inc(&PL_sv_undef);
# sv_setref_iv(rv, "LSF::Base::rusagePtr",(IV)&self->lsfRu);
# XPUSHs(sv_2mortal(rv));
# XSRETURN(1);
LSF-Batch
view release on metacpan or search on metacpan
print "er_eventLog(self)\n";
print "\tLSF_Batch_eventRec *self\n";
print " PREINIT:\n";
print "\tchar *label;\n";
print "\tSV *rv;\n";
print " PPCODE:\n";
print "\tswitch(self->type){\n";
foreach $struct (@structures){
$label = $struct;
$label =~ s/Log$//;
LSF_Batch
view release on metacpan or search on metacpan
print "er_eventLog(self)\n";
print "\tLSF_Batch_eventRec *self\n";
print " PREINIT:\n";
print "\tchar *label;\n";
print "\tSV *rv;\n";
print " PPCODE:\n";
print "\tswitch(self->type){\n";
foreach $struct (@structures){
$label = $struct;
$label =~ s/Log$//;
LaTeX-BibTeX
view release on metacpan or search on metacpan
bt_stringlist *
names;
int i;
SV * sv_name;
PPCODE:
names = bt_split_list (string, delim, filename, line, description);
if (names == NULL)
XSRETURN_EMPTY; /* return empty list to perl */
EXTEND (sp, names->num_items);
Lab-VXI11
view release on metacpan or search on metacpan
clnt_destroy(client);
void
create_link(Lab::VXI11 client, long clientId, bool_t lockDevice, u_long lock_timeout, char *device)
PPCODE:
Create_LinkParms link_parms = {clientId, lockDevice, lock_timeout, device};
Create_LinkResp *link_resp;
link_resp = create_link_1(&link_parms, client);
check_resp(client, link_resp);
void
device_write(Lab::VXI11 client, Device_Link lid, u_long io_timeout, u_long lock_timeout, Device_Flags flags, SV *data)
PPCODE:
const char *bytes;
STRLEN len;
bytes = SvPV(data, len);
Device_WriteParms write_parms = {lid, io_timeout, lock_timeout, flags, {len, (char *) bytes}};
mXPUSHu(write_resp->size);
void
device_read(Lab::VXI11 client, Device_Link lid, u_long requestSize, u_long io_timeout, u_long lock_timeout, Device_Flags flags, char termChar)
PPCODE:
Device_ReadParms read_parms = {lid, requestSize, io_timeout, lock_timeout, flags, termChar};
Device_ReadResp *read_resp;
set_clnt_timeout(client, io_timeout);
read_resp = device_read_1(&read_parms, client);
void
device_readstb(Lab::VXI11 client, Device_Link lid, Device_Flags flags, u_long lock_timeout, u_long io_timeout)
PPCODE:
Device_GenericParms parms = {lid, flags, lock_timeout, io_timeout};
Device_ReadStbResp *resp;
set_clnt_timeout(client, io_timeout);
resp = device_readstb_1(&parms, client);
check_resp(client, resp);
mXPUSHu(resp->stb);
void
device_trigger(Lab::VXI11 client, Device_Link lid, Device_Flags flags, u_long lock_timeout, u_long io_timeout)
PPCODE:
Device_GenericParms parms = {lid, flags, lock_timeout, io_timeout};
Device_Error *resp;
set_clnt_timeout(client, io_timeout);
resp = device_trigger_1(&parms, client);
check_resp(client, resp);
mXPUSHi(resp->error);
void
device_clear(Lab::VXI11 client, Device_Link lid, Device_Flags flags, u_long lock_timeout, u_long io_timeout)
PPCODE:
Device_GenericParms parms = {lid, flags, lock_timeout, io_timeout};
Device_Error *resp;
set_clnt_timeout(client, io_timeout);
resp = device_clear_1(&parms, client);
check_resp(client, resp);
mXPUSHi(resp->error);
void
device_remote(Lab::VXI11 client, Device_Link lid, Device_Flags flags, u_long lock_timeout, u_long io_timeout)
PPCODE:
Device_GenericParms parms = {lid, flags, lock_timeout, io_timeout};
Device_Error *resp;
set_clnt_timeout(client, io_timeout);
resp = device_remote_1(&parms, client);
check_resp(client, resp);
void
device_local(Lab::VXI11 client, Device_Link lid, Device_Flags flags, u_long lock_timeout, u_long io_timeout)
PPCODE:
Device_GenericParms parms = {lid, flags, lock_timeout, io_timeout};
Device_Error *resp;
set_clnt_timeout(client, io_timeout);
resp = device_local_1(&parms, client);
check_resp(client, resp);
void
device_lock(Lab::VXI11 client, Device_Link lid, Device_Flags flags, u_long lock_timeout)
PPCODE:
Device_LockParms parms = {lid, flags, lock_timeout};
Device_Error *resp;
resp = device_lock_1(&parms, client);
check_resp(client, resp);
mXPUSHi(resp->error);
void
device_unlock(Lab::VXI11 client, Device_Link lid)
PPCODE:
Device_Error *resp;
resp = device_unlock_1(&lid, client);
check_resp(client, resp);
mXPUSHi(resp->error);
void
device_enable_srq(Lab::VXI11 client, Device_Link lid, bool_t enable, SV *handle)
PPCODE:
const char *bytes;
STRLEN len;
bytes = SvPV(handle, len);
Device_EnableSrqParms parms = {lid, enable, {len, (char *) bytes}};
Device_Error *resp;
void
device_docmd(Lab::VXI11 client, Device_Link lid, Device_Flags flags, u_long io_timeout, u_long lock_timeout, long cmd, bool_t network_order, long datasize, SV *data_in)
PPCODE:
const char *bytes;
STRLEN len;
bytes = SvPV(data_in, len);
Device_DocmdParms parms = {lid, flags, io_timeout, lock_timeout, cmd, network_order, datasize, {len, (char *) bytes}};
Device_DocmdResp *resp;
void
destroy_link(Lab::VXI11 client, Device_Link lid)
PPCODE:
Device_Error *resp;
resp = destroy_link_1(&lid, client);
check_resp(client, resp);
mXPUSHi(resp->error);
void
create_intr_chan(Lab::VXI11 client, u_long hostAddr, u_short hostPort, u_long progNum, u_long progVers, Device_AddrFamily progFamily)
PPCODE:
Device_RemoteFunc parms = {hostAddr, hostPort, progNum, progVers, progFamily};
Device_Error *resp;
resp = create_intr_chan_1(&parms, client);
check_resp(client, resp);
mXPUSHi(resp->error);
void
destroy_intr_chan(Lab::VXI11 client);
PPCODE:
Device_Error *resp;
resp = destroy_intr_chan_1(NULL, client);
check_resp(client, resp);
mXPUSHi(resp->error);
Lab-Zhinst
view release on metacpan or search on metacpan
#
void
ziAPIInit(const char *class)
PPCODE:
ZIConnection conn;
int rv = ziAPIInit(&conn);
mXPUSHi(rv);
if (rv == 0)
mXPUSHs(pointer_object(aTHX_ class, conn));
MODULE = Lab::Zhinst PACKAGE = Lab::Zhinst
void
ziAPIListImplementations()
PPCODE:
size_t buffer_len = 100;
char *buffer;
Newx(buffer, buffer_len, char);
int rv = ziAPIListImplementations(buffer, buffer_len);
mXPUSHi(rv);
# FIXME: ziAPIConnectEx not needed?
void
ziAPIGetConnectionAPILevel(Lab::Zhinst conn)
PPCODE:
ZIAPIVersion_enum apiLevel;
int rv = ziAPIGetConnectionAPILevel(conn, &apiLevel);
mXPUSHi(rv);
if (rv == 0)
mXPUSHi(apiLevel);
#
void
ziAPIListNodes(Lab::Zhinst conn, const char *path, uint32_t bufferSize, uint32_t flags)
PPCODE:
char *nodes;
Newx(nodes, bufferSize, char);
int rv = ziAPIListNodes(conn, path, nodes, bufferSize, flags);
mXPUSHi(rv);
if (rv == 0)
#
void
ziAPIGetValueD(Lab::Zhinst conn, const char *path)
PPCODE:
ZIDoubleData result;
int rv = ziAPIGetValueD(conn, path, &result);
mXPUSHi(rv);
if (rv == 0)
mXPUSHn(result);
void
ziAPIGetValueI(Lab::Zhinst conn, const char *path)
PPCODE:
IV result;
int rv = ziAPIGetValueI(conn, path, &result);
mXPUSHi(rv);
if (rv == 0)
mXPUSHi(result);
void
ziAPIGetDemodSample(Lab::Zhinst conn, const char *path)
PPCODE:
ZIDemodSample sample;
int rv = ziAPIGetDemodSample(conn, path, &sample);
mXPUSHi(rv);
if (rv == 0)
mXPUSHs(demod_sample_to_hash(aTHX_ &sample));
void
ziAPIGetDIOSample(Lab::Zhinst conn, const char *path)
PPCODE:
ZIDIOSample sample;
int rv = ziAPIGetDIOSample(conn, path, &sample);
mXPUSHi(rv);
if (rv == 0)
mXPUSHs(dio_sample_to_hash(aTHX_ &sample));
void
ziAPIGetAuxInSample(Lab::Zhinst conn, const char *path)
PPCODE:
ZIAuxInSample sample;
int rv = ziAPIGetAuxInSample(conn, path, &sample);
mXPUSHi(rv);
if (rv == 0)
mXPUSHs(aux_in_sample_to_hash(aTHX_ &sample));
void
ziAPIGetValueB(Lab::Zhinst conn, const char *path, unsigned int bufferSize)
PPCODE:
char *buffer;
Newx(buffer, bufferSize, char);
unsigned int length;
int rv = ziAPIGetValueB(conn, path, (unsigned char *) buffer, &length, bufferSize);
mXPUSHi(rv);
ziAPISetValueI(Lab::Zhinst conn, const char *path, IV value)
void
ziAPISetValueB(Lab::Zhinst conn, const char *path, SV *value)
PPCODE:
if (!SvOK(value)) {
croak("value is not a valid scalar");
}
const char *bytes;
STRLEN len;
int rv = ziAPISetValueB(conn, path, (unsigned char *) bytes, len);
mXPUSHi(rv);
void
ziAPISyncSetValueD(Lab::Zhinst conn, const char *path, ZIDoubleData value)
PPCODE:
ZIDoubleData result = value;
int rv = ziAPISyncSetValueD(conn, path, &result);
mXPUSHi(rv);
if (rv == 0)
mXPUSHn(result);
void
ziAPISyncSetValueI(Lab::Zhinst conn, const char *path, ZIIntegerData value)
PPCODE:
ZIIntegerData result = value;
int rv = ziAPISyncSetValueI(conn, path, &result);
mXPUSHi(rv);
if (rv == 0)
mXPUSHi(result);
void
ziAPISyncSetValueB(Lab::Zhinst conn, const char *path, SV *value)
PPCODE:
if (!SvOK(value)) {
croak("value is not a valid scalar");
}
const char *original;
STRLEN len;
MODULE = Lab::Zhinst PACKAGE = Lab::Zhinst
void
ziAPIAllocateEventEx()
PPCODE:
ZIEvent *event = ziAPIAllocateEventEx();
mXPUSHs(pointer_object(aTHX_ "Lab::Zhinst::ZIEvent", event));
MODULE = Lab::Zhinst PACKAGE = Lab::Zhinst::ZIEvent
IV
ziAPIUnSubscribe(Lab::Zhinst conn, const char *path)
void
ziAPIPollDataEx(Lab::Zhinst conn, Lab::Zhinst::ZIEvent ev, uint32_t timeOutMilliseconds)
PPCODE:
int rv = ziAPIPollDataEx(conn, ev, timeOutMilliseconds);
mXPUSHi(rv);
if (rv == 0)
mXPUSHs(zievent_to_hash(aTHX_ ev));
MODULE = Lab::Zhinst PACKAGE = Lab::Zhinst
void
ziAPIGetError(ZIResult_enum result)
PPCODE:
int base;
char *buffer;
int rv = ziAPIGetError(result, &buffer, &base);
mXPUSHi(rv);
if (rv == 0) {
MODULE = Lab::Zhinst PACKAGE = Lab::Zhinst PREFIX = ziAPI
void
ziAPIGetLastError(Lab::Zhinst conn, uint32_t bufferSize)
PPCODE:
char *buffer;
Newx(buffer, bufferSize, char);
int rv = ziAPIGetLastError(conn, buffer, bufferSize);
mXPUSHi(rv);
if (rv == 0)
MODULE = Lab::Zhinst PACKAGE = Lab::Zhinst PREFIX = ziAPI
void
ziAPIDiscoveryFind(Lab::Zhinst conn, const char *device_address)
PPCODE:
const char *device_id;
int rv = ziAPIDiscoveryFind(conn, device_address, &device_id);
mXPUSHi(rv);
if (rv == 0)
mXPUSHp(device_id, strlen(device_id));
void
ziAPIDiscoveryGet(Lab::Zhinst conn, const char *device_id)
PPCODE:
const char *props_json;
int rv = ziAPIDiscoveryGet(conn, device_id, &props_json);
mXPUSHi(rv);
if (rv == 0)
mXPUSHp(props_json, strlen(props_json));
Language-Befunge-Vector-XS
view release on metacpan or search on metacpan
get_all_components( self )
SV* self;
PREINIT:
IV dim, i, val;
AV* my_array;
PPCODE:
/* fetch the underlying array of the object */
my_array = (AV*)SvRV(self);
dim = av_len(my_array);
/* extend the return stack and populate it */
SV* self;
INIT:
IV dim, i;
SV* zero;
AV* my_array;
PPCODE:
/* fetch the underlying array of the object */
my_array = (AV*)SvRV(self);
dim = av_len(my_array);
/* clear each slot */
Language-Eforth
view release on metacpan or search on metacpan
lib/Language/Eforth.xs view on Meta::CPAN
void
drain(Language::Eforth self)
PREINIT:
cell_t value;
size_t depth, ss;
PPCODE:
depth = embed_depth(self);
if (depth) {
EXTEND(SP, ss = depth);
while (depth) {
embed_pop(self, &value);
lib/Language/Eforth.xs view on Meta::CPAN
pop(Language::Eforth self)
PREINIT:
cell_t value;
int status;
U8 gimme;
PPCODE:
status = embed_pop(self, &value);
gimme = GIMME_V;
if (gimme == G_VOID) {
XSRETURN(0);
} else if (gimme == G_SCALAR) {
lib/Language/Eforth.xs view on Meta::CPAN
void
push(Language::Eforth self, ...)
PREINIT:
int i, status;
SV *value;
PPCODE:
if (items < 2) croak("nothing to push");
for (i = 1; i < items; i++) {
value = ST(i);
if (!SvOK(value)) croak("value must be defined");
status = embed_push(self, SvUV(value));
Language-Prolog-Yaswi
view release on metacpan or search on metacpan
MY_dMY_CXT;
term_t q, arg0;
module_t m;
predicate_t predicate;
AV *refs, *cells;
PPCODE:
check_prolog(aTHX_ aMY_CXT);
test_no_query(aTHX_ aMY_CXT);
push_frame(aTHX_ aMY_CXT);
q=PL_new_term_ref();
if (pl_unify_perl_sv(aTHX_ q,
LaunchDarkly-Server
view release on metacpan or search on metacpan
fallback/const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
type = constant(aTHX_ s, len);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
switch (type) {
case PERL_constant_NOTFOUND:
Lexical-Importer
view release on metacpan or search on metacpan
Importer.xs view on Meta::CPAN
OUTPUT:
RETVAL
void
_import_lex_var(SV *classname, ...)
PPCODE:
PERL_UNUSED_VAR(classname);
PUSHMARK(SP);
/* the modified SP is intentionally lost here */
import('N', "variable");
SPAGAIN;
void
_unimport_lex_var(SV *classname, ...)
PPCODE:
PERL_UNUSED_VAR(classname);
PUSHMARK(SP);
/* the modified SP is intentionally lost here */
unimport('N', "variable");
SPAGAIN;
Importer.xs view on Meta::CPAN
OUTPUT:
RETVAL
void
_import_lex_sub(SV *classname, ...)
PPCODE:
PERL_UNUSED_VAR(classname);
PUSHMARK(SP);
/* the modified SP is intentionally lost here */
import('&', "subroutine");
SPAGAIN;
void
_unimport_lex_sub(SV *classname, ...)
PPCODE:
PERL_UNUSED_VAR(classname);
PUSHMARK(SP);
/* the modified SP is intentionally lost here */
unimport('&', "subroutine");
SPAGAIN;
Lexical-Types
view release on metacpan or search on metacpan
#if XSH_THREADSAFE
void
CLONE(...)
PROTOTYPE: DISABLE
PPCODE:
xsh_clone();
XSRETURN(0);
#endif
Lexical-Var
view release on metacpan or search on metacpan
lib/Lexical/Var.xs view on Meta::CPAN
wrap_op_checker(OP_RV2CV, THX_myck_rv2cv, &THX_nxck_rv2cv);
wrap_op_checker(OP_RV2GV, THX_myck_rv2gv, &THX_nxck_rv2gv);
void
import(SV *classname, ...)
PPCODE:
PERL_UNUSED_VAR(classname);
PUSHMARK(SP);
/* the modified SP is intentionally lost here */
import('N', "variable");
SPAGAIN;
void
unimport(SV *classname, ...)
PPCODE:
PERL_UNUSED_VAR(classname);
PUSHMARK(SP);
/* the modified SP is intentionally lost here */
unimport('N', "variable");
SPAGAIN;
MODULE = Lexical::Var PACKAGE = Lexical::Sub
void
import(SV *classname, ...)
PPCODE:
PERL_UNUSED_VAR(classname);
PUSHMARK(SP);
/* the modified SP is intentionally lost here */
import('&', "subroutine");
SPAGAIN;
void
unimport(SV *classname, ...)
PPCODE:
PERL_UNUSED_VAR(classname);
PUSHMARK(SP);
/* the modified SP is intentionally lost here */
unimport('&', "subroutine");
SPAGAIN;
Lib-Log4cplus
view release on metacpan or search on metacpan
const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
Lib-Pepper
view release on metacpan or search on metacpan
void
pepInitialize(pepcoreLibraryPath, configStructure, licenseStructure)
const char* pepcoreLibraryPath
SV* configStructure
SV* licenseStructure
PPCODE:
{
PEPFunctionResult result;
PEPHandle terminalTypeOptionList = pepInvalidHandle;
const char* configStr = (SvOK(configStructure) && SvPOK(configStructure)) ? SvPV_nolen(configStructure) : NULL;
const char* licenseStr = (SvOK(licenseStructure) && SvPOK(licenseStructure)) ? SvPV_nolen(licenseStructure) : NULL;
PEPFunctionResult
pepFinalize()
void
pepVersion()
PPCODE:
{
PEPFunctionResult result;
int64_t major = 0, minor = 0, service = 0, revision = 0, api = 0;
int64_t osArch = 0, releaseType = 0, configType = 0;
void
pepCreateInstance(terminalType, instanceId)
int64_t terminalType
int64_t instanceId
PPCODE:
{
PEPFunctionResult result;
PEPHandle instance = pepInvalidHandle;
result = pepCreateInstance(terminalType, instanceId, &instance);
pepConfigureWithCallback(hInstance, hInputOptions, callback_cv, userdata_sv)
PEPHandle hInstance
PEPHandle hInputOptions
SV* callback_cv
SV* userdata_sv
PPCODE:
{
PEPFunctionResult result;
PEPHandle outputOptions = pepInvalidHandle;
PepperCallbackData* callbackData = NULL;
void
pepPrepareOperation(hInstance, eOperation, hInputOptions)
PEPHandle hInstance
PEPOperation eOperation
PEPHandle hInputOptions
PPCODE:
{
PEPFunctionResult result;
PEPHandle operation = pepInvalidHandle;
PEPHandle outputOptions = pepInvalidHandle;
void
pepStartOperation(hInstance, eOperation, hInputOptions)
PEPHandle hInstance
PEPOperation eOperation
PEPHandle hInputOptions
PPCODE:
{
PEPFunctionResult result;
PEPHandle operation = pepInvalidHandle;
PEPHandle outputOptions = pepInvalidHandle;
void
pepExecuteOperation(hInstance, eOperation, hInputOptions)
PEPHandle hInstance
PEPOperation eOperation
PEPHandle hInputOptions
PPCODE:
{
PEPFunctionResult result;
PEPHandle operation = pepInvalidHandle;
PEPHandle outputOptions = pepInvalidHandle;
void
pepFinalizeOperation(hInstance, eOperation, hInputOptions)
PEPHandle hInstance
PEPOperation eOperation
PEPHandle hInputOptions
PPCODE:
{
PEPFunctionResult result;
PEPHandle operation = pepInvalidHandle;
PEPHandle outputOptions = pepInvalidHandle;
void
pepOperationStatus(hInstance, hOperation, bWaitForCompletion)
PEPHandle hInstance
PEPHandle hOperation
PEPBool bWaitForCompletion
PPCODE:
{
PEPFunctionResult result;
PEPBool status = pepFalse;
result = pepOperationStatus(hInstance, hOperation, bWaitForCompletion, &status);
void
pepUtility(hInstance, hInputOptions)
PEPHandle hInstance
PEPHandle hInputOptions
PPCODE:
{
PEPFunctionResult result;
PEPHandle outputOptions = pepInvalidHandle;
result = pepUtility(hInstance, hInputOptions, &outputOptions);
void
pepAuxiliary(hInstance, hInputOptions)
PEPHandle hInstance
PEPHandle hInputOptions
PPCODE:
{
PEPFunctionResult result;
PEPHandle operation = pepInvalidHandle;
PEPHandle outputOptions = pepInvalidHandle;
###############################################################################
void
pepDownloadLicense(hInputOptions)
PEPHandle hInputOptions
PPCODE:
{
PEPFunctionResult result;
PEPHandle outputOptions = pepInvalidHandle;
result = pepDownloadLicense(hInputOptions, &outputOptions);
# OPTION LIST MANAGEMENT
###############################################################################
void
pepOptionListCreate()
PPCODE:
{
PEPFunctionResult result;
PEPHandle list = pepInvalidHandle;
result = pepOptionListCreate(&list);
void
pepOptionListGetStringElement(hOptionList, pKey)
PEPHandle hOptionList
const char* pKey
PPCODE:
{
PEPFunctionResult result;
const char* value = NULL;
result = pepOptionListGetStringElement(hOptionList, pKey, &value);
void
pepOptionListGetIntElement(hOptionList, pKey)
PEPHandle hOptionList
const char* pKey
PPCODE:
{
PEPFunctionResult result;
int64_t value = 0;
result = pepOptionListGetIntElement(hOptionList, pKey, &value);
void
pepOptionListGetChildOptionListElement(hOptionList, pKey)
PEPHandle hOptionList
const char* pKey
PPCODE:
{
PEPFunctionResult result;
PEPHandle childHandle = pepInvalidHandle;
result = pepOptionListGetChildOptionListElement(hOptionList, pKey, &childHandle);
PEPHandle hChildOptionList
void
pepOptionListGetElementList(hOptionList)
PEPHandle hOptionList
PPCODE:
{
PEPFunctionResult result;
const char* elementList = NULL;
result = pepOptionListGetElementList(hOptionList, &elementList);
LibJIT
view release on metacpan or search on metacpan
const-xs.inc view on Meta::CPAN
/* NV nv; Uncomment this if you need to return NVs */
/* const char *pv; Uncomment this if you need to return PVs */
INPUT:
SV * sv;
const char * s = SvPV(sv, len);
PPCODE:
/* Change this to constant(aTHX_ s, len, &iv, &nv);
if you need to return both NVs and IVs */
type = constant(aTHX_ s, len, &iv);
/* Return 1 or 2 items. First is error message, or undef if no error.
Second, if present, is found value */
( run in 2.188 seconds using v1.01-cache-2.11-cpan-71847e10f99 )