Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 2.276 )
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:
Layout-Flex
view release on metacpan or search on metacpan
fm_std14_init();
void
compute(class, ...)
SV * class
PPCODE:
{
lf_ctx_t ctx;
lf_item_t *lf_items = NULL;
lf_rect_t *rects = NULL;
AV *items_av = NULL;
}
void
font_metrics_measure(class, ...)
SV *class
PPCODE:
{
SV *fm_sv = NULL;
NV size = 12.0;
NV line_h = 0.0;
HV *hv;
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 */
LibTracker-Client
view release on metacpan or search on metacpan
void
DESTROY (obj)
SV* obj
PREINIT:
I32* temp;
PPCODE:
/* this is stolen from Inline::C documentation */
temp = PL_markstack_ptr++;
DESTROY(obj);
if(PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
Lingua-AR-MacArabic
view release on metacpan or search on metacpan
MacArabic.xs view on Meta::CPAN
SV *src, *dst;
STRLEN srclen;
U8 *s, *e, *p, uni[UTF8_MAXLEN + 1];
UV uv;
STDCHAR curdir, predir;
PPCODE:
if (0 < items && SvROK(ST(0))) {
croak(PkgName " 1st argument is REF, but handler for decode is NG.");
}
src = (0 < items) ? ST(0) : &PL_sv_undef;
MacArabic.xs view on Meta::CPAN
STDCHAR b, *t, **table;
UV uv;
STDCHAR dir;
bool has_cv = FALSE;
bool has_pv = FALSE;
PPCODE:
ref = NULL;
if (0 < items && SvROK(ST(0))) {
ref = SvRV(ST(0));
if (SvTYPE(ref) == SVt_PVCV)
has_cv = TRUE;
Lingua-CollinsParser
view release on metacpan or search on metacpan
lib/Lingua/CollinsParser.xs view on Meta::CPAN
void
parse_sentence (self, words_in, tags_in)
SV *self
SV *words_in
SV *tags_in
PPCODE:
{
int i, j, best, numwords;
sentence_type *s;
SV *output, **fetched;
AV *words, *tags;
lib/Lingua/CollinsParser.xs view on Meta::CPAN
}
void dump_events_hash (self, file)
SV *self
char *file
PPCODE:
{
PERL_UNUSED_VAR(self);
hash_dump(&new_hash, file);
}
void undump_events_hash (self, file)
SV *self
char *file
PPCODE:
{
hash_table *my_hash;
PERL_UNUSED_VAR(self);
hash_undump(&my_hash, file);
new_hash.num = my_hash->num;
Lingua-FA-MacFarsi
view release on metacpan or search on metacpan
MacFarsi.xs view on Meta::CPAN
SV *src, *dst;
STRLEN srclen;
U8 *s, *e, *p, uni[UTF8_MAXLEN + 1];
UV uv;
STDCHAR curdir, predir;
PPCODE:
if (0 < items && SvROK(ST(0))) {
croak(PkgName " 1st argument is REF, but handler for decode is NG.");
}
src = (0 < items) ? ST(0) : &PL_sv_undef;
MacFarsi.xs view on Meta::CPAN
STDCHAR b, *t, **table;
UV uv;
STDCHAR dir;
bool has_cv = FALSE;
bool has_pv = FALSE;
PPCODE:
ref = NULL;
if (0 < items && SvROK(ST(0))) {
ref = SvRV(ST(0));
if (SvTYPE(ref) == SVt_PVCV)
has_cv = TRUE;
Lingua-HE-MacHebrew
view release on metacpan or search on metacpan
MacHebrew.xs view on Meta::CPAN
SV *src, *dst;
STRLEN srclen;
U8 *s, *e, *p;
STDCHAR *str, *utf_string;
STDCHAR curdir, predir;
PPCODE:
if (0 < items && SvROK(ST(0))) {
croak(PkgName " 1st argument is REF, but handler for decode is NG.");
}
src = (0 < items) ? ST(0) : &PL_sv_undef;
MacHebrew.xs view on Meta::CPAN
struct macbidi_contra *p_contra, *cel_contra, **row_contra;
UV uv;
STDCHAR dir;
bool has_cv = FALSE;
bool has_pv = FALSE;
PPCODE:
ref = NULL;
if (0 < items && SvROK(ST(0))) {
ref = SvRV(ST(0));
if (SvTYPE(ref) == SVt_PVCV)
has_cv = TRUE;
Lingua-Identify-CLD2
view release on metacpan or search on metacpan
xsp/CLD2.xsp view on Meta::CPAN
char* content_language_hint
char* tld_hint
int encoding_hint
SV* language_hint
bool returnVectors
PPCODE:
char *buffer_str;
STRLEN buffer_length;
buffer_str = SvPVutf8(buffer, buffer_length);
CLDHints cld_hints_struct;
Lingua-JA-MacJapanese
view release on metacpan or search on metacpan
MacJapanese.xs view on Meta::CPAN
bool has_pv = 0;
STDCHAR **lb, *tb;
UV uv;
U8 unibuf[UTF8_MAXLEN + 1];
STRLEN ulen;
PPCODE:
ref = NULL;
if (0 < items && SvROK(ST(0))) {
ref = SvRV(ST(0));
if (SvTYPE(ref) == SVt_PVCV)
has_cv = TRUE;
MacJapanese.xs view on Meta::CPAN
U16 mc, *t;
struct mbc_contra *p_contra, *cel_contra, **row_contra;
UV uv;
bool has_cv = 0;
bool has_pv = 0;
PPCODE:
ref = NULL;
if (0 < items && SvROK(ST(0))) {
ref = SvRV(ST(0));
if (SvTYPE(ref) == SVt_PVCV)
has_cv = TRUE;
Lingua-KO-Hangul-Util
view release on metacpan or search on metacpan
U8 *s, *p, *e, *d;
UV uv;
STRLEN srclen, dstlen, retlen;
LKHU_CompStruct *i, *complist;
bool fcomposed;
PPCODE:
s = (U8*)sv_2pvunicode(src,&srclen);
e = s + srclen;
dstlen = srclen + 1; /* equal or shorter */
dst = newSV(dstlen);
PREINIT:
SV *dst;
U8 *s, *p, *e, *d;
UV lastuv, nextuv, lindex, vindex, tindex;
STRLEN srclen, dstlen, curlen, retlen;
PPCODE:
s = (U8*)sv_2pvunicode(src,&srclen);
e = s + srclen;
dstlen = srclen + 1; /* equal or shorter */
dst = newSV(dstlen);
UV sindex, lindex, vindex, tindex;
SV *decomp;
U8 *t, temp[3 * UTF8_MAXLEN + 1];
STRLEN tlen;
int notwantarray;
PPCODE:
notwantarray = (GIMME_V != G_ARRAY);
if (! Hangul_IsS(code)) {
if (notwantarray)
XSRETURN_UNDEF;
else
UV uv
UV uv2
PROTOTYPE: $$
PREINIT:
UV ret_uv;
PPCODE:
ret_uv = compositeHangul(uv, uv2);
if (ret_uv)
XPUSHs(sv_2mortal(newSVuv(ret_uv)));
else
XSRETURN_UNDEF;
Lingua-KO-MacKorean
view release on metacpan or search on metacpan
MacKorean.xs view on Meta::CPAN
STRLEN srclen, mblen;
U8 *s, *e, *p;
bool has_cv = 0;
bool has_pv = 0;
STDCHAR **lb, *tb;
PPCODE:
ref = NULL;
if (0 < items && SvROK(ST(0))) {
ref = SvRV(ST(0));
if (SvTYPE(ref) == SVt_PVCV)
has_cv = TRUE;
MacKorean.xs view on Meta::CPAN
U16 mc, *t;
struct mbc_contra *p_contra, *cel_contra, **row_contra;
UV uv;
bool has_cv = 0;
bool has_pv = 0;
PPCODE:
ref = NULL;
if (0 < items && SvROK(ST(0))) {
ref = SvRV(ST(0));
if (SvTYPE(ref) == SVt_PVCV)
has_cv = TRUE;
Lingua-LinkParser
view release on metacpan or search on metacpan
LinkParser.xs view on Meta::CPAN
Linkage linkage
int index
PREINIT:
int j;
const char **names;
PPCODE:
names = linkage_get_link_domain_names(linkage, index);
for (j=0; j<linkage_get_link_num_domains(linkage, index); ++j) {
XPUSHs(newSVpv(names[j],0));
}
LinkParser.xs view on Meta::CPAN
call_linkage_get_words(linkage)
Linkage linkage
PREINIT:
int j;
const char **words;
PPCODE:
words = linkage_get_words(linkage);
for (j=0; j<linkage_get_num_words(linkage); ++j) {
XPUSHs(newSVpv(words[j],0));
}
Lingua-RU-Money-XS
view release on metacpan or search on metacpan
MODULE = Lingua::RU::Money::XS PACKAGE = Lingua::RU::Money::XS
void
rur2words(SV *amount)
PROTOTYPE: $
PPCODE:
ST(0) = money2words(aTHX_ SvNV(amount), true, false);
XSRETURN(1);
void
all2words(SV *amount)
PROTOTYPE: $
PPCODE:
ST(0) = money2words(aTHX_ SvNV(amount), true, true);
XSRETURN(1);
( run in 2.276 seconds using v1.01-cache-2.11-cpan-4e7a2411597 )