Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 2.626 )
Senna
view release on metacpan or search on metacpan
lib/Senna.xs view on Meta::CPAN
unsigned int nrecords_lexicon;
unsigned int file_size_lexicon;
unsigned int inv_seg_size;
unsigned int inv_chunk_size;
sen_rc rc;
PPCODE:
index = XS_STATE(sen_index *, self);
rc = sen_index_info(index,
&key_size, &flags, &initial_n_segments, &encoding,
&nrecords_keys, &file_size_keys, &nrecords_lexicon,
&file_size_lexicon, &inv_seg_size, &inv_chunk_size
lib/Senna.xs view on Meta::CPAN
sen_select_optarg *optarg = NULL;
sen_sel_operator op = SvOK(op_sv) ? SvIV(op_sv) : 0;
char *query = NULL;
int need_optarg_free = 0;
int need_records_free = 0;
PPCODE:
index = XS_STATE(sen_index *, self);
if ( SvOK(query_sv) ) {
query = SvPV(query_sv, query_len);
}
lib/Senna.xs view on Meta::CPAN
SRecords_xs_next(self)
SV *self;
PREINIT:
sen_records *r;
sen_rc rc;
PPCODE:
r = XS_STATE(sen_records *, self);
if (GIMME_V == G_SCALAR) {
/* If we're being called in scalar context, then just return if
* we have a next record or not
lib/Senna.xs view on Meta::CPAN
sen_rc rc;
sen_set *set;
unsigned int key_size;
unsigned int value_size;
unsigned int n_entries;
PPCODE:
set = XS_STATE(sen_set *, self);
rc = sen_set_info(set, &key_size, &value_size, &n_entries);
if (rc != sen_success)
croak ("Failed to call sen_set_info: %d", rc);
lib/Senna.xs view on Meta::CPAN
#else
size_t max_tagged_len;
#endif
int i;
sen_rc rc;
PPCODE:
snip = XS_STATE(sen_perl_snip *, self);
sen_snip_exec(
snip->snip,
string,
#if (SENNA_MAJOR_VERSION >= 1)
lib/Senna.xs view on Meta::CPAN
DESTROY(self)
SV *self;
PREINIT:
sen_perl_snip *snip;
int i;
PPCODE:
snip = XS_STATE(sen_perl_snip *, self);
sen_snip_close(snip->snip);
for(i = 0; i < snip->open_tags_size; i++) {
Safefree(snip->open_tags[i]);
lib/Senna.xs view on Meta::CPAN
SOSort_compar_arg(self)
SV *self;
PREINIT:
sen_sort_optarg *optarg;
void **args;
PPCODE:
optarg = XS_STATE(sen_sort_optarg *, self);
/* The CV is always placed in the second element of ->func_arg */
args = (void **) optarg->compar_arg;
if (GIMME_V == G_SCALAR) {
AV *av;
lib/Senna.xs view on Meta::CPAN
void
SOSelect_weight_vector(self)
SV *self;
PREINIT:
sen_select_optarg *optarg;
PPCODE:
optarg = XS_STATE(sen_select_optarg *, self);
if (optarg->vector_size <= 0)
return;
if (GIMME_V == G_SCALAR) {
lib/Senna.xs view on Meta::CPAN
SOSelect_func_arg(self)
SV *self;
PREINIT:
sen_select_optarg *optarg;
void **args;
PPCODE:
optarg = XS_STATE(sen_select_optarg *, self);
/* The CV is always placed in the second element of ->func_arg */
args = (void **) optarg->func_arg;
if (GIMME_V == G_SCALAR) {
AV *av;
Sentinel
view release on metacpan or search on metacpan
lib/Sentinel.xs view on Meta::CPAN
SV *get_cb = NULL;
SV *set_cb = NULL;
SV *obj = NULL;
SV *retval;
PPCODE:
/* Parse name => value argument pairs */
for(i = 0; i < items; i += 2) {
char *argname = SvPV_nolen(ST(i));
SV *argvalue = ST(i+1);
Sereal-Decoder
view release on metacpan or search on metacpan
SV *opt;
SV *into;
PREINIT:
dMY_CXT;
srl_decoder_t *dec= NULL;
PPCODE:
if (SvROK(src))
croak("We can't decode a reference as Sereal!");
/* Support no opt at all, undef, hashref */
if (opt != NULL) {
SvGETMAGIC(opt);
Sereal-Encoder
view release on metacpan or search on metacpan
SV *src;
HV *opt;
PREINIT:
srl_encoder_t *enc;
dMY_CXT;
PPCODE:
enc = srl_build_encoder_struct(aTHX_ opt, MY_CXT.options);
assert(enc != NULL);
/* Avoid copy by stealing string buffer if it is not too large.
* This makes sense in the functional interface since the string
* buffer isn't ever going to be reused. */
SV *hdr_user_data_src;
HV *opt;
PREINIT:
srl_encoder_t *enc;
dMY_CXT;
PPCODE:
if (!SvOK(hdr_user_data_src))
hdr_user_data_src = NULL;
enc = srl_build_encoder_struct(aTHX_ opt, MY_CXT.options);
assert(enc != NULL);
/* Avoid copy by stealing string buffer if it is not too large.
Sereal-Merger
view release on metacpan or search on metacpan
void
append(mrg, src)
srl_merger_t *mrg;
SV *src
PPCODE:
srl_merger_append(aTHX_ mrg, src);
void
append_all(mrg, src)
srl_merger_t *mrg;
AV *src
PPCODE:
srl_merger_append_all(aTHX_ mrg, src);
SV*
finish(mrg, user_header = NULL)
srl_merger_t *mrg;
Sereal-Path
view release on metacpan or search on metacpan
Iterator/Iterator.xs view on Meta::CPAN
UV length;
int blessed;
const char *classname;
STRLEN classname_length;
PPCODE:
type = srl_iterator_info(aTHX_ iter, &length, &classname, &classname_length);
blessed = (type & SRL_ITERATOR_INFO_BLESSED) == SRL_ITERATOR_INFO_BLESSED;
EXTEND(SP, blessed ? 3 : 2);
PUSHs(sv_2mortal(newSVuv(type)));
Sereal-Splitter
view release on metacpan or search on metacpan
Splitter.xs view on Meta::CPAN
OUTPUT: RETVAL
void
DESTROY(splitter)
Sereal::Splitter splitter;
PPCODE:
srl_destroy_splitter(aTHX_ splitter);
SV*
next_chunk(splitter)
Sereal::Splitter splitter;
Set-IntSpan-Fast-XS
view release on metacpan or search on metacpan
int
_find_pos(self, val, low = 0)
AV *self;
IV val = SvIV(ST(1));
IV low = ( items == 3 ) ? SvIV( ST( 2 ) ) : 0;
PPCODE:
{
XSRETURN_IV( __find_pos(self, val, low ) );
}
AV *
Set-Object
view release on metacpan or search on metacpan
void
new(pkg, ...)
SV* pkg;
PPCODE:
{
SV* self;
ISET* s;
I32 item;
void
insert(self, ...)
SV* self;
PPCODE:
ISET* s = INT2PTR(ISET*, SvIV(SvRV(self)));
I32 item;
int inserted = 0;
for (item = 1; item < items; ++item)
void
remove(self, ...)
SV* self;
PPCODE:
ISET* s = INT2PTR(ISET*, SvIV(SvRV(self)));
I32 item;
int removed = 0;
void
includes(self, ...)
SV* self;
PPCODE:
ISET* s = INT2PTR(ISET*, SvIV(SvRV(self)));
I32 hash, index, item;
SV **el_iter, **el_last;
BUCKET* bucket;
void
members(self)
SV* self
PPCODE:
ISET* s = INT2PTR(ISET*, SvIV(SvRV(self)));
BUCKET* bucket_iter = s->bucket;
BUCKET* bucket_last = bucket_iter + s->buckets;
void
_STORABLE_thaw(obj, cloning, serialized, ...)
SV* obj;
PPCODE:
{
ISET* s;
I32 item;
SV* isv;
void
CLONE(...)
PROTOTYPE: DISABLE
PREINIT:
ISET *old_s;
PPCODE:
{
dMY_CXT;
old_s = MY_CXT.s;
}
{
Set-Product-XS
view release on metacpan or search on metacpan
AV **in;
SV **out;
CV *cv;
HV *stash;
GV *gv;
PPCODE:
cv = sv_2cv(code, &stash, &gv, 0);
if (! cv)
croak("Not a subroutine reference");
if (2 > items)
Shardcache-Client-Fast
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:
ShiftJIS-CP932-MapUTF
view release on metacpan or search on metacpan
U8 *s, *e, *p, *d, *m, *m_e, uni[UTF8_MAXLEN + 1];
UV uv;
struct leading lb;
U8* (*app_uv)(U8*, UV);
bool mod_g, mod_s, mod_t;
PPCODE:
STMT_ASSIGN_CVREF_AND_SRC(funcname_to[ix])
if (SvUTF8(src)) {
src = sv_mortalcopy(src);
sv_utf8_downgrade(src, 0);
}
U8 *s, *e, *p, *d, *m, *m_e, mbc[3];
U16 j, *t;
UV uv;
UV (*ord_uv)(U8 *, STRLEN, STRLEN *);
bool mod_g, mod_s, mod_f;
PPCODE:
STMT_ASSIGN_CVREF_AND_SRC(funcname_fm[ix])
if (ix == 0 && !SvUTF8(src)) {
src = sv_mortalcopy(src);
sv_utf8_upgrade(src);
}
ShiftJIS-String
view release on metacpan or search on metacpan
issjis(...)
PREINIT:
I32 i;
U8 *s;
STRLEN byte;
PPCODE:
for (i = 0; i < items; i++) {
s = (U8*)SvPV(ST(i), byte);
if (!issjis(s, byte))
XSRETURN_NO;
}
PREINIT:
U8 *s, *e, *p, *p_ini, *p_fin;
STRLEN sbyte;
I32 slen, ini, fin, cnt;
int except;
PPCODE:
s = SvROK(src)
? (U8*)SvPV_force(SvRV(src), sbyte)
: (U8*)SvPV(src, sbyte);
slen = length(s,sbyte);
PREINIT:
U8 *s, *p, *e, *d;
STRLEN byte;
SV *dst;
I32 cnt = 0;
PPCODE:
s = SvROK(src)
? (U8*)SvPV_force(SvRV(src), byte)
: (U8*)SvPV(src, byte);
dst = byte ? newSV((ix == 1) ? byte : 2 * byte) : newSVpvn("",0);
U8 *s, *p, *e, *d;
STRLEN byte;
SV *dst;
I32 cnt = 0;
U8* trail;
PPCODE:
s = SvROK(src)
? (U8*)SvPV_force(SvRV(src), byte)
: (U8*)SvPV(src, byte);
dst = byte ? newSV(2 * byte) : newSVpvn("",0);
U8 *s, *p, *e, *d;
STRLEN byte;
SV *dst;
U16 uv;
I32 cnt = 0;
PPCODE:
s = SvROK(src)
? (U8*)SvPV_force(SvRV(src), byte)
: (U8*)SvPV(src, byte);
dst = byte ? newSV(byte) : newSVpvn("",0);
PREINIT:
U8 *s, *p, *e, *d;
STRLEN byte;
SV *dst;
I32 cnt = 0;
PPCODE:
s = SvROK(src)
? (U8*)SvPV_force(SvRV(src), byte)
: (U8*)SvPV(src, byte);
dst = byte ? newSV(2 * byte) : newSVpvn("",0);
PREINIT:
U8 *s, *p, *e, *d;
STRLEN byte;
SV *dst;
I32 cnt = 0;
PPCODE:
s = SvROK(src)
? (U8*)SvPV_force(SvRV(src), byte)
: (U8*)SvPV(src, byte);
dst = byte ? newSV(byte) : newSVpvn("",0);
PREINIT:
U8 *s, *p, *e, *d;
STRLEN byte;
SV *dst;
I32 cnt = 0;
PPCODE:
s = SvROK(src)
? (U8*)SvPV_force(SvRV(src), byte)
: (U8*)SvPV(src, byte);
dst = byte ? newSV(byte) : newSVpvn("",0);
U8 lastL = 0, iniL, iniT, finL, finT;
STRLEN sbyte, dbyte, dstcur;
SV *dst;
U16 fr, to;
int isReverse, doReverse, isrange;
PPCODE:
isReverse = SvTRUE(rev);
s = (U8*)SvPV(src, sbyte);
dbyte = sbyte + 1;
U8 *p, *e, *s, *d, *tr, *m;
STRLEN idx;
STRLEN byte, trbyte, modbyte;
U8 fr[2], *to, tolast[2], pre[2], tmp[2];
STRLEN fbyte, tbyte, lbyte, prebyte, tmpbyte;
PPCODE:
s = SvROK(src)
? (U8*)SvPV_force(SvRV(src), byte)
: (U8*)SvPV(src, byte);
tr = (U8*)SvPV(trans, trbyte);
PREINIT:
U8 *s, *e, *p, *sep, *anc, *last;
STRLEN byte, sepbyte, ch;
int wantarray;
I32 cnt = 0;
PPCODE:
wantarray = (GIMME_V == G_ARRAY);
s = (U8*)SvPV(src, byte);
if (!byte)
ShiftJIS-X0213-MapUTF
view release on metacpan or search on metacpan
U8 *s, *e, *p, *d, uni[UTF8_MAXLEN + 1];
UV uv, u_temp;
struct leading lb;
U8* (*app_uv)(U8*, UV);
int id_utf, use2004;
PPCODE:
use2004 = ix < NUM_toUTF;
id_utf = ix % NUM_toUTF;
STMT_ASSIGN_CVREF_AND_SRC(funcname_to[ix])
if (SvUTF8(src)) {
U8 *s, *e, *p, *d, mbc[3];
U16 j, *tbl_row, **tbl_plain;
UV uv, uv2;
UV (*ord_uv)(U8 *, STRLEN, STRLEN *);
int id_utf, use2004;
PPCODE:
use2004 = ix < NUM_fromUTF;
id_utf = ix % NUM_fromUTF;
STMT_ASSIGN_CVREF_AND_SRC(funcname_fm[ix])
if (id_utf == 0 && !SvUTF8(src)) {
Shout
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:
/* 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 */
Smart-Match
view release on metacpan or search on metacpan
lib/Smart/Match/Overload.xs view on Meta::CPAN
MODULE = Smart::Match::Overload PACKAGE = Smart::Match::Overload
int
_boolean(self, ...)
SV* self;
PPCODE:
dUNDERBAR;
if (UNDERBAR != DEFSV) {
SAVESPTR(DEFSV);
DEFSV = UNDERBAR;
}
Socket-Class
view release on metacpan or search on metacpan
Bluetooth.xs view on Meta::CPAN
PREINIT:
bdaddr_t addr[256];
int r;
my_thread_var_t *tv;
char tmp[20];
PPCODE:
r = bt_device_list( addr, sizeof( addr ) / sizeof( bdaddr_t ) );
if( r == SOCKET_ERROR ) {
tv = items > 0 ? my_thread_var_find( ST(0) ) : NULL;
if( tv != NULL )
tv->last_errno = Socket_errno();
Bluetooth.xs view on Meta::CPAN
char tmp[256], *s1;
STRLEN l1;
int r;
bdaddr_t addr;
my_thread_var_t *tv;
PPCODE:
if( items > 1 ) {
s1 = SvPVbyte( ST(1), l1 );
if( l1 == sizeof( bdaddr_t ) )
r = bt_device_name( (bdaddr_t *) s1, tmp, sizeof( tmp ) - 1 );
else {
Bluetooth.xs view on Meta::CPAN
char tmp[256], *s1;
STRLEN l1;
int r;
bdaddr_t addr;
my_thread_var_t *tv;
PPCODE:
if( items > 1 ) {
s1 = SvPVbyte( ST(1), l1 );
if( l1 == sizeof( bdaddr_t ) )
r = bt_service_list( (bdaddr_t *) s1 );
else {
Socket-Mmsg
view release on metacpan or search on metacpan
void
sendmmsg (psock, msg_array_ref)
PerlIO * psock
SV * msg_array_ref
PPCODE:
sendmultimsg(psock, msg_array_ref);
return;
void
recvmmsg (psock, msg_count, msg_len, tspec)
PerlIO * psock
int msg_count
int msg_len
float tspec
PPCODE:
recvmultimsg(psock, msg_count, msg_len, tspec);
return;
Socket-More-Interface
view release on metacpan or search on metacpan
Interface.xs view on Meta::CPAN
struct ifaddrs *next;
int ret;
HV* h;
UV count=0;
PPCODE:
ret=getifaddrs(&a);
if(ret<0){
switch(GIMME_V){
case G_SCALAR:
Interface.xs view on Meta::CPAN
SV *name;
INIT:
char *p;
unsigned int ret;
int len;
PPCODE:
if(SvOK(name)&&SvPOK(name)){
len=SvCUR(name);
p=SvGROW(name, len+1);
p[len]='\0';
Interface.xs view on Meta::CPAN
SV *result=newSV(IF_NAMESIZE);
char *p=SvPVX(result);
char *ret;
PPCODE:
if(SvOK(index)){
ret=if_indextoname(SvUV(index), p);
if(ret == p){
SvPOK_on(result);
Interface.xs view on Meta::CPAN
INIT:
UV count=0;
struct if_nameindex *results, *next;
PPCODE:
results=if_nameindex();
if(results ==NULL){
Socket-More-Lookup
view release on metacpan or search on metacpan
int len;
SV *temp;
bool return_av;
PPCODE:
h.ai_flags=0;
h.ai_family=0;
h.ai_socktype=0;
h.ai_protocol=0;
h.ai_addrlen=0;
char *service;
int fl;
int addrlen;
struct sockaddr *addr;
PPCODE:
//Ensure outputs are not readonly
if(SvREADONLY(hostname) || SvREADONLY(servicename)){
Perl_croak(aTHX_ "%s", PL_no_modify);
Socket-MsgHdr
view release on metacpan or search on metacpan
SV* cmsv;
INIT:
struct msghdr dummy;
struct cmsghdr *cm;
STRLEN len;
PPCODE:
dummy.msg_control = (struct cmsghdr *) SvPV(cmsv, len);
dummy.msg_controllen = len;
if (!len)
XSRETURN_EMPTY;
Socket-Netlink
view release on metacpan or search on metacpan
lib/Socket/Netlink.xs view on Meta::CPAN
SV *addr
PREINIT:
struct sockaddr_nl snl;
PPCODE:
if(SvCUR(addr) != sizeof snl)
croak("Expected %d byte address", sizeof snl);
Copy(SvPVbyte_nolen(addr), &snl, sizeof snl, char);
lib/Socket/Netlink.xs view on Meta::CPAN
PREINIT:
struct nlmsghdr nlmsghdr;
STRLEN msglen;
PPCODE:
if(!SvPOK(msg))
croak("Expected a string message");
msglen = SvCUR(msg);
lib/Socket/Netlink.xs view on Meta::CPAN
SV *msg
PREINIT:
struct nlmsgerr nlmsgerr;
PPCODE:
if(!SvPOK(msg))
croak("Expected a string message");
if(SvCUR(msg) != sizeof(nlmsgerr))
croak("Expected %d bytes of message", sizeof(nlmsgerr));
lib/Socket/Netlink.xs view on Meta::CPAN
INIT:
STRLEN bufflen;
char *buffer;
PPCODE:
if(!SvPOK(body))
croak("Expected a string body");
buffer = SvPVbyte(body, bufflen);
Socket-Packet
view release on metacpan or search on metacpan
lib/Socket/Packet.xs view on Meta::CPAN
PREINIT:
struct sockaddr_ll sll;
char *addrbytes;
STRLEN addrlen;
PPCODE:
if (DO_UTF8(addr) && !sv_utf8_downgrade(addr, 1))
croak("Wide character in Socket::Packet::pack_sockaddr_ll");
addrbytes = SvPVbyte(addr, addrlen);
lib/Socket/Packet.xs view on Meta::CPAN
PREINIT:
STRLEN sa_len;
char *sa_bytes;
struct sockaddr_ll sll;
PPCODE:
/* variable size of structure, because of variable length of addr bytes */
sa_bytes = SvPVbyte(sa, sa_len);
if(sa_len < sll_min)
croak("Socket address too small; found %d bytes, expected at least %d", sa_len, sll_min);
if(sa_len > sll_max)
lib/Socket/Packet.xs view on Meta::CPAN
PREINIT:
struct packet_mreq mreq;
char *addr_bytes;
STRLEN addr_len;
PPCODE:
if (DO_UTF8(addr) && !sv_utf8_downgrade(addr, 1))
croak("Wide character in Socket::Packet::pack_sockaddr_ll");
addr_bytes = SvPVbyte(addr, addr_len);
lib/Socket/Packet.xs view on Meta::CPAN
PREINIT:
STRLEN data_len;
char *data_bytes;
struct packet_mreq mreq;
PPCODE:
data_bytes = SvPVbyte(data, data_len);
if(data_len != sizeof(mreq))
croak("packet_mreq buffer incorrect size; found %d bytes, expected %d", data_len, sizeof(mreq));
Copy(data_bytes, &mreq, data_len, char);
lib/Socket/Packet.xs view on Meta::CPAN
PREINIT:
STRLEN stats_len;
char *stats_bytes;
struct tpacket_stats statsbuf;
PPCODE:
stats_bytes = SvPVbyte(stats, stats_len);
if(stats_len != sizeof(statsbuf))
croak("tpacket_stats buffer incorrect size; found %d bytes, expected %d", stats_len, sizeof(statsbuf));
Copy(stats_bytes, &statsbuf, stats_len, char);
lib/Socket/Packet.xs view on Meta::CPAN
PREINIT:
int fd;
int result;
struct timeval tv;
PPCODE:
fd = PerlIO_fileno(sock);
if(ioctl(fd, SIOCGSTAMP, &tv) == -1) {
if(GIMME_V == G_ARRAY)
return;
else
lib/Socket/Packet.xs view on Meta::CPAN
PREINIT:
int fd;
int result;
struct timespec ts;
PPCODE:
#ifdef SIOCGSTAMPNS
fd = PerlIO_fileno(sock);
if(ioctl(fd, SIOCGSTAMPNS, &ts) == -1) {
if(GIMME_V == G_ARRAY)
return;
lib/Socket/Packet.xs view on Meta::CPAN
PREINIT:
int fd;
struct ifreq req;
PPCODE:
#ifdef SIOCGIFINDEX
fd = PerlIO_fileno(sock);
strncpy(req.ifr_name, ifname, IFNAMSIZ);
if(ioctl(fd, SIOCGIFINDEX, &req) == -1)
XSRETURN_UNDEF;
lib/Socket/Packet.xs view on Meta::CPAN
PREINIT:
int fd;
struct ifreq req;
PPCODE:
#ifdef SIOCGIFNAME
fd = PerlIO_fileno(sock);
req.ifr_ifindex = ifindex;
if(ioctl(fd, SIOCGIFNAME, &req) == -1)
XSRETURN_UNDEF;
lib/Socket/Packet.xs view on Meta::CPAN
char *bufferp;
struct sockaddr_storage addr;
socklen_t addrlen;
int len;
PPCODE:
fd = PerlIO_fileno(sock);
if(!SvOK(buffer))
sv_setpvn(buffer, "", 0);
lib/Socket/Packet.xs view on Meta::CPAN
int version;
struct tpacket_req req;
size_t size;
char *addr;
PPCODE:
#ifdef HAVE_RX_RING
fd = PerlIO_fileno(sock);
#ifdef HAVE_TPACKET2
version = TPACKET_V2;
if(setsockopt(fd, SOL_PACKET, PACKET_VERSION, &version, sizeof version) != 0)
lib/Socket/Packet.xs view on Meta::CPAN
#endif
void
get_ring_frame_status(sock)
InputStream sock
PPCODE:
#ifdef HAVE_RX_RING
{
struct packet_rxring_state *state = get_rxring_state((SV*)sv_2io(ST(0)));
char *addr = frame_ptr(state);
#if defined(HAVE_TPACKET2)
lib/Socket/Packet.xs view on Meta::CPAN
SV *buffer
HV *info
PREINIT:
PPCODE:
#ifdef HAVE_RX_RING
{
struct packet_rxring_state *state = get_rxring_state((SV*)sv_2io(ST(0)));
char *addr = frame_ptr(state);
unsigned int len;
lib/Socket/Packet.xs view on Meta::CPAN
#endif
void
done_ring_frame(sock)
InputStream sock
PPCODE:
#ifdef HAVE_RX_RING
{
struct packet_rxring_state *state = get_rxring_state((SV*)sv_2io(ST(0)));
char *addr = frame_ptr(state);
#if defined(HAVE_TPACKET2)
Socket
view release on metacpan or search on metacpan
}
void
unpack_sockaddr_in(sin_sv)
SV * sin_sv
PPCODE:
{
STRLEN sockaddrlen;
struct sockaddr_in addr;
SV *ip_address_sv;
char * sin;
}
void
unpack_sockaddr_in6(sin6_sv)
SV * sin6_sv
PPCODE:
{
#ifdef HAS_SOCKADDR_IN6
STRLEN addrlen;
struct sockaddr_in6 sin6;
char * addrbytes;
}
void
unpack_ip_mreq(mreq_sv)
SV * mreq_sv
PPCODE:
{
#ifdef HAS_IP_MREQ
struct ip_mreq mreq;
STRLEN mreqlen;
char * mreqbytes = SvPVbyte(mreq_sv, mreqlen);
}
void
unpack_ip_mreq_source(mreq_sv)
SV * mreq_sv
PPCODE:
{
#if defined(HAS_IP_MREQ_SOURCE) && defined (IP_ADD_SOURCE_MEMBERSHIP)
struct ip_mreq_source mreq;
STRLEN mreqlen;
char * mreqbytes = SvPVbyte(mreq_sv, mreqlen);
}
void
unpack_ipv6_mreq(mreq_sv)
SV * mreq_sv
PPCODE:
{
#ifdef HAS_IPV6_MREQ
struct ipv6_mreq mreq;
STRLEN mreqlen;
char * mreqbytes = SvPVbyte(mreq_sv, mreqlen);
Socket6
view release on metacpan or search on metacpan
void
gethostbyname2(host, af)
char * host;
int af;
PPCODE:
{
#ifdef HAVE_GETHOSTBYNAME2
struct hostent *phe;
int count, i;
}
void
unpack_sockaddr_in6(sin_sv)
SV * sin_sv
PPCODE:
{
#ifdef INET6_ADDRSTRLEN
STRLEN sockaddrlen;
struct sockaddr_in6 addr;
unsigned short port;
}
void
unpack_sockaddr_in6_all(sin_sv)
SV * sin_sv
PPCODE:
{
#ifdef INET6_ADDRSTRLEN
STRLEN sockaddrlen;
struct sockaddr_in6 addr;
unsigned short port;
char * port
int family
int socktype
int protocol
int flags
PPCODE:
{
#ifdef HAVE_GETADDRINFO
struct addrinfo hints, * res;
int err;
int count;
void
getnameinfo(sin_sv, flags = 0)
SV * sin_sv
int flags;
PPCODE:
{
#ifdef HAVE_GETNAMEINFO
STRLEN sockaddrlen;
struct sockaddr * sin = (struct sockaddr *)SvPV(sin_sv,sockaddrlen);
char host[NI_MAXHOST];
int err;
char **p;
SV *temp, *address_ref, *alias_ref;
AV *address_list, *alias_list;
#endif
PPCODE:
{
#ifdef HAVE_GETIPNODEBYNAME
he = getipnodebyname(hostname, family, flags, &err);
if (err == 0) {
SV *temp, *address_ref, *alias_ref;
AV *address_list, *alias_list;
struct in6_addr addr;
char *addr_buffer;
#endif
PPCODE:
{
#ifdef HAVE_GETIPNODEBYADDR
addr_buffer = SvPV(address_sv, addrlen);
switch(family) {
Solaris-ACL
view release on metacpan or search on metacpan
# in $Solaris::ACL::error.
void
getfacl(file_name)
SV * file_name;
PPCODE:
{
char *file_string; /* c-string version of file_name */
int file_string_length; /* need to pass a variable to SvPV */
HV *acl_hash, *default_acl_hash, *current_acl_hash;
HV *user_hash, *default_user_hash, **current_user_hash;
void
setfacl(file_name, acl_hashref, ...)
SV *file_name;
SV *acl_hashref;
PPCODE:
{
char *file_string; /* c-string version of file_name */
int file_string_length; /* need to pass a variable to SvPV */
HV *acl_hash, *def_acl_hash;
Solaris-DevLog
view release on metacpan or search on metacpan
char *ctlbuf;
char *databuf;
struct strbuf ctl, data;
SV * sv_mid, * sv_sid, * sv_level, * sv_flags,
* sv_ltime, * sv_ttime, * sv_seq_no, * sv_pri;
PPCODE:
flags = 0;
/* set up the control buffer */
ctl.maxlen = ctl.len = sizeof(lc);
ctl.buf = (char *) &lc;
Solaris-Kvm
view release on metacpan or search on metacpan
char *p;
char *n;
char *t;
char errstr[1024];
int i, fd, ii, count;
PPCODE:
hash = newHV();
ret = (SV*)newRV_noinc((SV*)hash);
stash = gv_stashpv(class,TRUE);
sv_bless(ret,stash);
MAGIC *mg;
SV *ref;
STRLEN plen;
char *pval;
int i;
PPCODE:
mg = mg_find(SvRV(self), 'P');
if(!mg) { croak("lost P magic"); }
ref = mg->mg_obj;
PUSHMARK(SP);
XPUSHs(ref);
kvm_dev_t *kp;
kvm_var_t *kv;
struct nlist *nl;
char *t;
int i;
PPCODE:
hash = (HV*)SvRV(self);
k = SvPV(key, klen);
mg = mg_find(SvRV(self),'~');
if(!mg) { croak("lost ~ magic"); }
kp = (kvm_dev_t*)SvIVX(mg->mg_obj);
FIRSTKEY(self)
SV *self;
PREINIT:
HV *hash;
HE *he;
PPCODE:
hash = (HV*)SvRV(self);
hv_iterinit(hash);
if (he = hv_iternext(hash)) {
EXTEND(sp, 1);
PUSHs(hv_iterkeysv(he));
SV *self;
SV *lastkey;
PREINIT:
HV *hash;
HE *he;
PPCODE:
hash = (HV*)SvRV(self);
if (he = hv_iternext(hash)) {
EXTEND(sp, 1);
PUSHs(hv_iterkeysv(he));
}
SV *ret;
char *pval;
STRLEN plen;
kvm_var_t *kv;
int i;
PPCODE:
hash = (HV*)SvRV(self);
pval = SvPV(prop, plen);
var = hv_fetch(hash, pval, plen, FALSE);
if(var) {
Solaris-Lgrp
view release on metacpan or search on metacpan
RETURN_UNDEF_IF_FAIL;
OUTPUT:
RETVAL
#
# Functions below convert C arrays into Perl lists. They use XS PPCODE
# directive to avoid implicit RETVAL assignments and manipulate perl
# stack directly.
#
# When called in scalar context functions return the number of elements
# in the list or undef on failure.
lgrp_cookie_t cookie;
lgrp_id_t lgrp;
PREINIT:
lgrp_id_t *lgrps;
int count;
PPCODE:
errno = 0;
if ((count = lgrp_children(cookie, lgrp, NULL, 0)) < 0)
LGRP_BADVAL();
if (GIMME_V == G_SCALAR)
lgrp_cookie_t cookie;
lgrp_id_t lgrp;
PREINIT:
lgrp_id_t *lgrps;
int count;
PPCODE:
errno = 0;
if ((count = lgrp_parents(cookie, lgrp, NULL, 0)) < 0)
LGRP_BADVAL();
if (GIMME_V == G_SCALAR)
lgrp_id_t lgrp;
lgrp_content_t content;
PREINIT:
int ncpus;
processorid_t *cpus;
PPCODE:
errno = 0;
if ((ncpus = lgrp_cpus(cookie, lgrp, NULL, 0, content)) < 0)
LGRP_BADVAL();
if (GIMME_V == G_SCALAR)
void
lgrp_resources(cookie, lgrp, type)
lgrp_cookie_t cookie;
lgrp_id_t lgrp;
int type;
PPCODE:
LGRP_RESOURCES(cookie, lgrp, type);
Solaris
view release on metacpan or search on metacpan
Kstat/Kstat.xs view on Meta::CPAN
SV*
FIRSTKEY(self)
SV* self;
PREINIT:
HE *he;
PPCODE:
self = SvRV(self);
read_kstats((HV*)self, FALSE);
hv_iterinit((HV*)self);
if (he = hv_iternext((HV*)self))
{
Kstat/Kstat.xs view on Meta::CPAN
NEXTKEY(self, lastkey)
SV* self;
SV* lastkey;
PREINIT:
HE *he;
PPCODE:
self = SvRV(self);
if (he = hv_iternext((HV*)self))
{
EXTEND(sp, 1);
PUSHs(hv_iterkeysv(he));
( run in 2.626 seconds using v1.01-cache-2.11-cpan-4e7a2411597 )