Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 2.338 )
Math-Vector-Real-XS
view release on metacpan or search on metacpan
mvr v0
mvr v1
SV *rev = NO_INIT
PREINIT:
I32 len, i;
PPCODE:
len = mvr_len(aTHX_ v0);
mvr_check_len(aTHX_ v1, len);
mvr_add_me(aTHX_ v0, v1, len);
XSRETURN(1);
mvr v0
mvr v1
SV *rev = NO_INIT
PREINIT:
I32 len, i;
PPCODE:
len = mvr_len(aTHX_ v0);
mvr_check_len(aTHX_ v1, len);
mvr_subtract_me(aTHX_ v0, v1, len);
XSRETURN(1);
SV *sv1
SV *rev = NO_INIT
PREINIT:
I32 len, i;
mvr v1;
PPCODE:
/* fprintf(stderr, "using mul operator from XS\n"); fflush(stderr); */
len = mvr_len(aTHX_ v0);
if (SvROK(sv1) && (SvTYPE(v1 = (AV*)SvRV(sv1)) == SVt_PVAV)) {
NV acu = 0;
mvr_check_len(aTHX_ v1, len);
SV *sv1
SV *rev = NO_INIT
PREINIT:
int len, i;
NV nv1;
PPCODE:
if (SvROK(sv1) && (SvTYPE(SvRV(sv1)) == SVt_PVAV))
Perl_croak(aTHX_ "can not multiply by a vector in place as the result is not a vector");
nv1 = SvNV(sv1);
len = mvr_len(aTHX_ v0);
for (i = 0; i <= len; i++) {
RETVAL
void
box(klass, ...)
SV *klass = NO_INIT
PPCODE:
if (items <= 1) XSRETURN(0);
else {
I32 len, j;
mvr min, max;
mvr v = mvr_from_sv(aTHX_ ST(1));
mvr v1
PREINIT:
I32 len, i;
mvr p, n;
NV f, nr;
PPCODE:
len = mvr_len(aTHX_ v0);
mvr_check_len(aTHX_ v1, len);
nr = mvr_norm(aTHX_ v0, len);
if (nr == 0) Perl_croak(aTHX_ "Illegal division by zero");
p = mvr_new(aTHX_ len);
canonical_base(klass, dim)
SV *klass = NO_INIT
I32 dim
PREINIT:
I32 j;
PPCODE:
if (dim <= 0) Perl_croak(aTHX_ "negative dimension");
EXTEND(SP, dim);
for (j = 0; j < dim; j++) {
mvr v = mvr_new(aTHX_ dim - 1);
ST(j) = sv_newmortal();
mvr dir
PREINIT:
I32 len, i;
mvr u, v, w;
NV n;
PPCODE:
len = mvr_len(aTHX_ dir);
if (len != 2) Perl_croak(aTHX_ "rotation_base_3d requires a 3D vector");
n = mvr_norm(aTHX_ dir, len);
if (n == 0) Perl_croak(aTHX_ "Illegal division by zero");
EXTEND(SP, 3);
mvr v
NV r
PREINIT:
I32 len, i, to;
NV r2;
PPCODE:
len = mvr_len(aTHX_ v);
r2 = r * r;
for (to = 0, i = 2; i < items; i++) {
mvr e = mvr_from_sv(aTHX_ ST(i));
mvr_check_len(aTHX_ e, len);
Math-decNumber
view release on metacpan or search on metacpan
decNumber.xs view on Meta::CPAN
#============| Destructor
void
decNumberDESTROY( number )
decNumber * number
PPCODE:
// fprintf( stderr, "***> DESTROY %x\n", number);
DECNUM_FREE(number);
MODULE = Math::decNumber PACKAGE = Math::decNumber PREFIX = decNumber
Math-ematica
view release on metacpan or search on metacpan
MLINK link
PREINIT:
char * name;
long_st nargs;
SV * symbol;
PPCODE:
if (!MLGetFunction(link, (kcharpp_ct) &name, &nargs)) {
XSRETURN_UNDEF;
}
symbol = make_symbol(name);
MLDisownSymbol(link, name);
MLINK link
PREINIT:
doublep_nt array;
long_st len;
long_st i;
PPCODE:
if (!MLGetRealList(link, &array, &len)) {
XSRETURN_UNDEF;
}
EXTEND(sp, len);
for (i=0;i<len;i++) {
XSRETURN(len);
void
symbol(name)
SV * name
PPCODE:
ST(0) = sv_2mortal(newRV_noinc(newSVsv(name)));
sv_bless(ST(0), gv_stashpv(SYMNAME,1));
XSRETURN(1);
mlapi_result
MaxMind-DB-Reader-XS
view release on metacpan or search on metacpan
lib/MaxMind/DB/Reader/XS.xs view on Meta::CPAN
MMDB_s *mmdb
U32 node_number
PREINIT:
MMDB_search_node_s node;
int status;
PPCODE:
status = MMDB_read_node(mmdb, node_number, &node);
if (MMDB_SUCCESS != status) {
const char *error = MMDB_strerror(status);
croak(
"MaxMind::DB::Reader::XS - Error trying to read node %i: %s",
Media-LibMTP-API
view release on metacpan or search on metacpan
lib/Media/LibMTP/API.xs view on Meta::CPAN
void
_devices(self)
MLA_RawDeviceList self
PREINIT:
int i;
PPCODE:
EXTEND(SP, self->numdevs);
for (i = 0; i < self->numdevs; ++i) {
SV* sv = sv_newmortal();
sv_setref_pv(sv, "Media::LibMTP::API::RawDevice",
(void*)(self->devices + i));
Medusa-XS
view release on metacpan or search on metacpan
lib/Medusa/XS.xs view on Meta::CPAN
const char *method;
STRLEN method_len;
const char *pkg;
STRLEN pkg_len;
GV *gv;
PPCODE:
/* Get the CV from the coderef */
if (!SvROK(coderef) || SvTYPE(SvRV(coderef)) != SVt_PVCV) {
croak("wrap_sub: argument must be a code reference");
}
cv = (CV *)SvRV(coderef);
lib/Medusa/XS.xs view on Meta::CPAN
# XSUB: _apply_deferred_wraps - Re-install wrappers queued on 5.10 #
# ------------------------------------------------------------------ #
void
_apply_deferred_wraps()
PPCODE:
medusa_check_apply_wraps(aTHX_ NULL);
XSRETURN(0);
# ------------------------------------------------------------------ #
# XSUB: log_message - Full XS logging implementation #
lib/Medusa/XS.xs view on Meta::CPAN
void
log_message(...)
PREINIT:
HV *params;
int i;
PPCODE:
/* Build params hash from @_ */
if (items % 2 != 0) {
croak("log_message: odd number of arguments");
}
params = newHV();
lib/Medusa/XS.xs view on Meta::CPAN
void
init_logger()
PREINIT:
HV *log_config;
SV **svp;
PPCODE:
log_config = get_hv("Medusa::XS::LOG", 0);
if (!log_config) {
XSRETURN(0);
}
lib/Medusa/XS.xs view on Meta::CPAN
const char *caller_pkg;
HV *caller_stash;
AV *isa;
GV *isa_gv;
int i;
PPCODE:
/* Check for odd number of args (after class name) */
if ((items - 1) % 2 != 0) {
croak("odd number of params passed in import");
}
lib/Medusa/XS.xs view on Meta::CPAN
const char *pkg_name;
STRLEN pkg_len;
HV *audited;
int i;
bool found_audit = FALSE;
PPCODE:
/* Check if any attribute is "Audit" */
for (i = 2; i < items; i++) {
STRLEN len;
const char *attr = SvPV(ST(i), len);
if (len >= 5 && strncmp(attr, "Audit", 5) == 0) {
lib/Medusa/XS.xs view on Meta::CPAN
SV *coderef
PREINIT:
CV *cv;
HV *audited;
bool is_audited_cv = FALSE;
PPCODE:
PERL_UNUSED_VAR(pkg);
if (!SvROK(coderef) || SvTYPE(SvRV(coderef)) != SVt_PVCV) {
XSRETURN(0);
}
Memcached-libmemcached
view release on metacpan or search on metacpan
t/lib/ExtUtils/ParseXS.pm view on Meta::CPAN
my $END = "!End!\n\n"; # "impossible" keyword (multiple newline)
# Match an XS keyword
$BLOCK_re= '\s*(' . join('|', qw(
REQUIRE BOOT CASE PREINIT INPUT INIT CODE PPCODE OUTPUT
CLEANUP ALIAS ATTRS PROTOTYPES PROTOTYPE VERSIONCHECK INCLUDE
SCOPE INTERFACE INTERFACE_MACRO C_ARGS POSTCALL OVERLOAD FALLBACK
)) . "|$END)\\s*:";
t/lib/ExtUtils/ParseXS.pm view on Meta::CPAN
s/^/&/ if $in_out{$_};
}
$func_args = join(", ", @func_args);
@args_match{@args} = @args_num;
$PPCODE = grep(/^\s*PPCODE\s*:/, @line);
$CODE = grep(/^\s*CODE\s*:/, @line);
# Detect CODE: blocks which use ST(n)= or XST_m*(n,v)
# to set explicit return values.
$EXPLICIT_RETURN = ($CODE &&
("@line" =~ /(\bST\s*\([^;]*=) | (\bXST_m\w+\s*\()/x ));
t/lib/ExtUtils/ParseXS.pm view on Meta::CPAN
# the if of this else
print Q(<<"EOF");
# PERL_UNUSED_VAR(cv); /* -W */
EOF
#gcc -Wall: if an xsub has PPCODE is used
#it is possible none of ST, XSRETURN or XSprePUSH macros are used
#hence `ax' (setup by dXSARGS) is unused
#XXX: could breakup the dXSARGS; into dSP;dMARK;dITEMS
#but such a move could break third-party extensions
print Q(<<"EOF") if $PPCODE;
# PERL_UNUSED_VAR(ax); /* -Wall */
EOF
print Q(<<"EOF") if $PPCODE;
# SP -= items;
EOF
# Now do a block of some sort.
t/lib/ExtUtils/ParseXS.pm view on Meta::CPAN
process_keyword("INIT|ALIAS|ATTRS|PROTOTYPE|INTERFACE_MACRO|INTERFACE|C_ARGS|OVERLOAD") ;
print delete $deferred{pre_call};
print delete $deferred{auto_length_init};
if (check_keyword("PPCODE")) {
print_section();
death ("PPCODE must be last thing") if @line;
print "\tLEAVE;\n" if $ScopeThisXSUB;
print "\tPUTBACK;\n\treturn;\n";
} elsif (check_keyword("CODE")) {
print_section() ;
} elsif (defined($class) and $func_name eq "DESTROY") {
t/lib/ExtUtils/ParseXS.pm view on Meta::CPAN
process_keyword("CLEANUP|ALIAS|ATTRS|PROTOTYPE|OVERLOAD") ;
print Q(<<"EOF") if $ScopeThisXSUB;
# ]]
EOF
print Q(<<"EOF") if $ScopeThisXSUB and not $PPCODE;
# LEAVE;
EOF
# print function trailer
print Q(<<"EOF");
t/lib/ExtUtils/ParseXS.pm view on Meta::CPAN
# if (errbuf[0])
# Perl_croak(aTHX_ errbuf);
EOF
if ($xsreturn) {
print Q(<<"EOF") unless $PPCODE;
# XSRETURN($xsreturn);
EOF
} else {
print Q(<<"EOF") unless $PPCODE;
# XSRETURN_EMPTY;
EOF
}
print Q(<<"EOF");
Memphis
view release on metacpan or search on metacpan
xs/MemphisMap.xs view on Meta::CPAN
gdouble minlat = 0,
minlon = 0,
maxlat = 0,
maxlon = 0;
PPCODE:
memphis_map_get_bounding_box(map, &minlat, &minlon, &maxlat, &maxlon);
EXTEND(SP, 4);
PUSHs(sv_2mortal(newSVnv(minlat)));
PUSHs(sv_2mortal(newSVnv(minlon)));
PUSHs(sv_2mortal(newSVnv(maxlat)));
Mesos
view release on metacpan or search on metacpan
xsp/ExecutorDriver.xsp view on Meta::CPAN
%{
static void
_xs_init(SV* self, mesos::perl::MesosChannel* channel)
PPCODE:
if (SvROK(self) && SvTYPE(SvRV(self)) == SVt_PVHV) {
// make sure channel ref gets incremented
mesos::perl::ProxyExecutor* proxy = new mesos::perl::ProxyExecutor(channel->share());
mesos::perl::ExecutorDriver* driver = new mesos::perl::ExecutorDriver(proxy);
sv_magic(SvRV(self), Nullsv, PERL_MAGIC_ext,
MicroECC
view release on metacpan or search on metacpan
MicroECC.xs view on Meta::CPAN
int pubkey_len, privkey_len;
uint8_t *pubkey, *privkey;
uECC_Curve curve;
int res;
PPCODE:
curve = get_curve(curve_id);
pubkey_len = uECC_curve_public_key_size(curve);
privkey_len = uECC_curve_private_key_size(curve);
pubkey = (uint8_t *)malloc(pubkey_len);
privkey = (uint8_t *)malloc(privkey_len);
Mojo-Base-XS
view release on metacpan or search on metacpan
/* Get the const hash key struct from the global storage */
/* ix is the magic integer variable that is set by the perl guts for us.
* We uses it to identify the currently running alias of the accessor. Gollum! */
const autoxs_hashkey readfrom = CXSAccessor_hashkeys[ix];
SV** svp;
PPCODE:
CXAH_OPTIMIZE_ENTERSUB(accessor);
ACCESSOR_BODY
void
accessor(self, ...)
/* Get the const hash key struct from the global storage */
/* ix is the magic integer variable that is set by the perl guts for us.
* We uses it to identify the currently running alias of the accessor. Gollum! */
const autoxs_hashkey readfrom = CXSAccessor_hashkeys[ix];
SV** svp;
PPCODE:
ACCESSOR_BODY
void
attr(caller_obj, name, ...)
PREINIT:
int iStack;
HV* hash;
SV* obj;
const char* classname;
PPCODE:
CXAH_OPTIMIZE_ENTERSUB(constructor);
CONSTRUCTOR_BODY
void
PREINIT:
int iStack;
HV* hash;
SV* obj;
const char* classname;
PPCODE:
CONSTRUCTOR_BODY
void
newxs_constructor(name)
char* name;
PPCODE:
INSTALL_NEW_CV(name, CXAH(constructor_init));
void
newxs_attr(name)
char* name;
PPCODE:
INSTALL_NEW_CV(name, CXAH(attr));
MongoDB-Async
view release on metacpan or search on metacpan
void
decode_bson(sv)
SV *sv
PREINIT:
buffer buf;
PPCODE:
buf.start = SvPV_nolen(sv);
buf.pos = buf.start;
buf.end = buf.start + SvCUR(sv);
while(buf.pos < buf.end) {
void
encode_bson(obj)
SV *obj
PREINIT:
buffer buf;
PPCODE:
CREATE_BUF(INITIAL_BUF_SIZE);
perl_mongo_sv_to_bson(&buf, obj, NO_PREP);
perl_mongo_serialize_size(buf.start, &buf);
XPUSHs(sv_2mortal(newSVpvn(buf.start, buf.pos-buf.start)));
Safefree(buf.start);
void
read_flags()
PPCODE:
read_flags();
Moose
view release on metacpan or search on metacpan
xs/HasMethods.xs view on Meta::CPAN
SV *const class_name = HeVAL( hv_fetch_ent(obj, KEY_FOR(package), 0, HASH_FOR(package)) );
HV *const stash = gv_stashsv(class_name, 0);
UV current;
SV *cache_flag;
SV *map_ref;
PPCODE:
if (!stash) {
mXPUSHs(newRV_noinc((SV *)newHV()));
return;
}
Mouse
view release on metacpan or search on metacpan
xs-src/Mouse.xs view on Meta::CPAN
}
void
linearized_isa(SV* self)
PPCODE:
{
/* MOUSE_xc_stash() is not available because the xc system depends on
linearized_isa() */
HV* const stash = mouse_get_namespace(aTHX_ self);
AV* const linearized_isa = mro_get_linear_isa(stash);
xs-src/Mouse.xs view on Meta::CPAN
}
}
void
get_all_attributes(SV* self)
PPCODE:
{
AV* const xc = mouse_get_xc(aTHX_ self);
AV* const all_attrs = MOUSE_xc_attrall(xc);
I32 const len = AvFILLp(all_attrs) + 1;
I32 i;
xs-src/Mouse.xs view on Meta::CPAN
get_before_modifiers(SV* self, SV* name)
ALIAS:
get_before_method_modifiers = MOUSE_M_BEFORE
get_around_method_modifiers = MOUSE_M_AROUND
get_after_method_modifiers = MOUSE_M_AFTER
PPCODE:
{
AV* const storage = mouse_get_modifier_storage(aTHX_ self,
(enum mouse_modifier_t)ix, name);
I32 const len = av_len(storage) + 1;
if(GIMME_V == G_ARRAY) {
Mozilla-nsID
view release on metacpan or search on metacpan
void m3(SV *obj)
INIT:
nsID *id;
int i;
PPCODE:
id = (nsID *) SvIV(SvRV(obj));
for (i = 0; i < sizeof(id->m3); i++) {
XPUSHs(sv_2mortal(newSVnv(id->m3[i])));
}
MsgPack-Raw
view release on metacpan or search on metacpan
xs/Unpacker.xs view on Meta::CPAN
PREINIT:
msgpack_unpacked u;
msgpack_unpack_return ret;
PPCODE:
msgpack_unpacked_init (&u);
ret = msgpack_unpacker_next (&self->unpacker, &u);
switch (ret)
{
case MSGPACK_UNPACK_SUCCESS:
Msql-Mysql-modules
view release on metacpan or search on metacpan
dbd/dbd.xs.in view on Meta::CPAN
void
_ListDBs(drh, host, port=NULL)
SV * drh
char * host
char * port
PPCODE:
{
#if defined(DBD_MYSQL)
MYSQL mysql;
dbh_t sock = &mysql;
#elif defined(DBD_MSQL)
dbd/dbd.xs.in view on Meta::CPAN
char* dbname
char* host
char* port
char* user
char* password
PPCODE:
{
dbh_t sock;
int result;
#if defined(DBD_MYSQL)
MYSQL mysql;
dbd/dbd.xs.in view on Meta::CPAN
void
type_info_all(dbh)
SV* dbh
PPCODE:
{
/* static AV* types = NULL; */
/* if (!types) { */
/* D_imp_dbh(dbh); */
/* if (!(types = dbd_db_type_info_all(dbh, imp_dbh))) { */
dbd/dbd.xs.in view on Meta::CPAN
#endif
void
_ListDBs(dbh)
SV* dbh
PPCODE:
D_imp_dbh(dbh);
result_t res;
row_t cur;
res = MyListDbs(imp_dbh->svsock);
if (!res && (!MyReconnect(imp_dbh->svsock, dbh)
dbd/dbd.xs.in view on Meta::CPAN
void
_ListTables(dbh)
SV * dbh
PPCODE:
D_imp_dbh(dbh);
result_t res;
row_t cur;
res = MyListTables(imp_dbh->svsock);
if (!res && (!MyReconnect(imp_dbh->svsock, dbh)
dbd/dbd.xs.in view on Meta::CPAN
quote(dbh, str, type=NULL)
SV* dbh
SV* str
SV* type
PROTOTYPE: $$;$
PPCODE:
{
SV* quoted = dbd_db_quote(dbh, str, type);
ST(0) = quoted ? sv_2mortal(quoted) : str;
XSRETURN(1);
}
dbd/dbd.xs.in view on Meta::CPAN
void
getsequenceinfo(dbh, table)
SV* dbh
char* table
PROTOTYPE: $$
PPCODE:
{
m_seq* seq;
D_imp_dbh(dbh);
seq = msqlGetSequenceInfo(imp_dbh->svsock, table);
if (!seq) {
MtCmd
view release on metacpan or search on metacpan
OUTPUT:
RETVAL
int
exec(...)
PPCODE:
int gimme = GIMME_V;
int debug = 0;
int is_object;
SV* sv;
HV* myhash;
MySQL-Dump-Parser-XS
view release on metacpan or search on metacpan
lib/MySQL/Dump/Parser/XS.xs view on Meta::CPAN
PROTOTYPES: DISABLE
void
new(...)
PPCODE:
{
if (items != 1) {
croak("Invalid argument count: %d", items);
}
const char *klass = SvPV_nolen(ST(0));
lib/MySQL/Dump/Parser/XS.xs view on Meta::CPAN
XSRETURN(1);
}
void
reset(...)
PPCODE:
{
if (items != 1) {
croak("Invalid argument count: %d", items);
}
HV* state = (HV*)SvRV(ST(0));
lib/MySQL/Dump/Parser/XS.xs view on Meta::CPAN
XSRETURN(0);
}
void
parse(...)
PPCODE:
{
if (items != 2) {
croak("Invalid argument count: %d", items);
}
HV* state = (HV*)SvRV(ST(0));
lib/MySQL/Dump/Parser/XS.xs view on Meta::CPAN
XSRETURN(size);
}
void
current_target_table(...)
PPCODE:
{
if (items != 1) {
croak("Invalid argument count: %d", items);
}
HV* state = (HV*)SvRV(ST(0));
lib/MySQL/Dump/Parser/XS.xs view on Meta::CPAN
XSRETURN(1);
}
void
columns(...)
PPCODE:
{
if (items != 2) {
croak("Invalid argument count: %d", items);
}
HV* state = (HV*)SvRV(ST(0));
lib/MySQL/Dump/Parser/XS.xs view on Meta::CPAN
XSRETURN(size);
}
void
tables(...)
PPCODE:
{
if (items != 1) {
croak("Invalid argument count: %d", items);
}
NIS
view release on metacpan or search on metacpan
yp_unbind(domain)
char * domain
void
yp_get_default_domain()
PPCODE:
{
char *domain;
int status;
status = yp_get_default_domain(&domain);
void
yp_match(domain, map, key)
char * domain
char * map
SV * key
PPCODE:
{
char *inkey;
STRLEN inkeylen;
char *outval;
int outvallen;
void
yp_first(domain, map)
char * domain
char * map
PPCODE:
{
char *outkey;
int outkeylen;
char *outval;
int outvallen;
void
yp_next(domain, map, key)
char * domain
char * map
SV * key
PPCODE:
{
char *inkey;
STRLEN inkeylen;
char *outkey;
int outkeylen;
void
yp_all(domain, map)
char * domain
char * map
PPCODE:
{
struct ypall_callback callback;
struct callbackdata data;
int status;
void
yp_order(domain, map)
char * domain
char * map
PPCODE:
{
unsigned long order;
int status;
status = yp_order(domain, map, &order);
void
yp_master(domain, map)
char * domain
char * map
PPCODE:
{
char *name;
int status;
status = yp_master(domain, map, &name);
NISPlus
view release on metacpan or search on metacpan
# see the manual pages on these functions for a description of what they do
void
nis_getnames(name)
nis_name name
PPCODE:
{
nis_name * names;
nis_name * names_first;
names_first = names = nis_getnames(name);
unsigned long ttl
char * type
unsigned char sep
char * path
SV * data
PPCODE:
{
nis_object object;
nis_result *res;
int pos;
SV **val;
SV * data
nis_name owner
nis_name group
unsigned long access
unsigned long ttl
PPCODE:
{
nis_result *table;
nis_result *res;
nis_object entry;
void
nis_remove_entry(name, flags)
nis_name name
unsigned long flags
PPCODE:
{
nis_result *res;
if ((res = nis_remove_entry(name, (nis_object *)NULL, flags)) ==
(nis_result *)NULL)
void
nis_modify_entry(name, data, flags)
nis_name name
SV * data
unsigned long flags
PPCODE:
{
nis_result *table;
nis_result *res, *lres;
nis_object *entry;
nis_name tname;
# list the names of the table entries
void
name_list(name)
nis_name name
PPCODE:
{
nis_result *res;
res = nis_list(name, 0, (int(*)())NULL, (void *)NULL);
void
entry_list(name, tableref)
nis_name name
SV * tableref
PPCODE:
{
nis_result *res;
res=nis_list(name, MASTER_ONLY, (int(*)())NULL, (void *)NULL);
}
void
nis_first_entry(name)
nis_name name
PPCODE:
{
nis_result *res;
u_int num;
res=nis_first_entry(name);
void
nis_next_entry(name, cookie)
nis_name name
netobj cookie
PPCODE:
{
nis_result *res;
u_int num;
res=nis_next_entry(name, &cookie);
# return information about an entry object
void
entry_info(path)
nis_name path
PPCODE:
{
nis_result *res;
res = lookup(path);
if (res == (nis_result *)NULL) XPUSHs(sv_newmortal());
# return information about a table object
void
table_info(path)
nis_name path
PPCODE:
{
nis_result *res;
res = lookup(path);
if (res == (nis_result *)NULL) XPUSHs(sv_newmortal());
void
entry_setinfo(name, data)
nis_name name
SV * data
PPCODE:
{
nis_result *res, *res2;
res = nis_list(name, MASTER_ONLY, (int(*)())NULL, (void *)NULL);
if (res == (nis_result *)NULL) XPUSHs(sv_newmortal());
void
table_setinfo(path, data)
nis_name path
SV * data
PPCODE:
{
nis_result *res, *res2;
SV **sv;
res = lookup(path);
# return the type of an object (e.g. TABLE, ENTRY, etc)
void
obj_type(path)
nis_name path
PPCODE:
{
nis_result *res;
res = lookup(path);
if (res == (nis_result *)NULL) XPUSHs(sv_newmortal());
NPRG
view release on metacpan or search on metacpan
Wingraph.xs view on Meta::CPAN
char *s;
PREINIT:
SIZE sz;
int rv;
long x,y;
PPCODE:
rv=GetTextExtentPoint32(dc,s,strlen(s),&sz);
EXTEND(sp,2);
PUSHs(sv_2mortal(newSViv(sz.cx)));
PUSHs(sv_2mortal(newSViv(sz.cy)));
NanoMsg-Raw
view release on metacpan or search on metacpan
void
_symbols ()
PREINIT:
int i;
PPCODE:
for (i = 0; i <= av_len(symbol_names); i++)
mXPUSHs(SvREFCNT_inc(*av_fetch(symbol_names, i, 0)));
BOOT:
symbol_names = newAV();
Neo4j-Bolt
view release on metacpan or search on metacpan
lib/Neo4j/Bolt/Cxn.xs view on Meta::CPAN
void
reset_ (cxn_ref)
SV * cxn_ref
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
reset_(cxn_ref);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
lib/Neo4j/Bolt/Cxn.xs view on Meta::CPAN
void
DESTROY (cxn_ref)
SV * cxn_ref
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
DESTROY(cxn_ref);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Net--RabbitMQ
view release on metacpan or search on metacpan
RabbitMQ.xs view on Meta::CPAN
int durable = 0;
int exclusive = 0;
int auto_delete = 1;
amqp_table_t arguments = AMQP_EMPTY_TABLE;
amqp_bytes_t queuename_b = AMQP_EMPTY_BYTES;
PPCODE:
if(queuename && strcmp(queuename, "")) queuename_b = amqp_cstring_bytes(queuename);
if(options) {
int_from_hv(options, passive);
int_from_hv(options, durable);
int_from_hv(options, exclusive);
Net-ADNS
view release on metacpan or search on metacpan
open_queries(self)
adns_state self
PREINIT:
int n;
SV *wrapper;
PPCODE:
adns_forallqueries_begin(self);
for ( n = 0;
adns_forallqueries_next(self, (void**)(&wrapper));
n++)
XPUSHs(sv_2mortal(newSVsv(wrapper)));
PREINIT:
fd_set rfds, wfds, efds;
int maxfd = 0;
struct timeval *tv_mod = 0;
struct timeval tv_buf, now;
PPCODE:
FD_ZERO(&rfds); FD_ZERO(&wfds); FD_ZERO(&efds);
gettimeofday(&now, NULL);
adns_beforeselect(self,
&maxfd, &rfds, &wfds, &efds,
&tv_mod, &tv_buf, &now);
Net-AMQP-RabbitMQ
view release on metacpan or search on metacpan
RabbitMQ.xs view on Meta::CPAN
int exclusive = 0;
int auto_delete = 1;
amqp_table_t arguments = amqp_empty_table;
amqp_bytes_t queuename_b = amqp_empty_bytes;
amqp_queue_declare_ok_t *r = (amqp_queue_declare_ok_t*)NULL;
PPCODE:
assert_amqp_connected(conn);
if(queuename && strcmp(queuename, "")) queuename_b = amqp_cstring_bytes(queuename);
if(options) {
int_from_hv(options, passive);
Net-Async-Redis-XS
view release on metacpan or search on metacpan
PROTOTYPES: DISABLE
AV *
decode_buffer(SV *this, SV *p)
PPCODE:
/* Plain bytestring required: no magic, no UTF-8, no nonsense */
if(!SvPOK(p))
croak("expected a string");
if(SvUTF8(p))
sv_utf8_downgrade(p, true);
Net-BART
view release on metacpan or search on metacpan
lib/Net/BART/XS.xs view on Meta::CPAN
void
lookup(self, ip_str)
SV *self
const char *ip_str
PPCODE:
bart_table_t *t = INT2PTR(bart_table_t*, SvIV(SvRV(self)));
uint8_t addr[16];
int is_ipv6 = parse_ip_str(aTHX_ ip_str, addr);
int found = 0;
void *val = bart_lookup(t, addr, is_ipv6, &found);
lib/Net/BART/XS.xs view on Meta::CPAN
void
get(self, prefix_str)
SV *self
const char *prefix_str
PPCODE:
bart_table_t *t = INT2PTR(bart_table_t*, SvIV(SvRV(self)));
uint8_t addr[16];
int addr_len, prefix_len;
int is_ipv6 = parse_prefix_str(aTHX_ prefix_str, addr, &addr_len, &prefix_len);
int found = 0;
lib/Net/BART/XS.xs view on Meta::CPAN
void
delete(self, prefix_str)
SV *self
const char *prefix_str
PPCODE:
bart_table_t *t = INT2PTR(bart_table_t*, SvIV(SvRV(self)));
uint8_t addr[16];
int addr_len, prefix_len;
int is_ipv6 = parse_prefix_str(aTHX_ prefix_str, addr, &addr_len, &prefix_len);
bart_node_t *root = is_ipv6 ? t->root6 : t->root4;
Net-BGPdump
view release on metacpan or search on metacpan
RETVAL
void
file_type(THIS)
Net::BGPdump THIS
PPCODE:
switch (THIS->f->format) {
case 0:
// not opened
break;
case 1:
int ipv6
time_t lo_time
time_t hi_time
PREINIT:
BGPDUMP_ENTRY *entry;
PPCODE:
do {
entry = bgpdump_read_next(THIS);
if (entry == NULL)
continue;
if (lo_time > 0 && entry->time < lo_time)
int ipv6
time_t lo_time
time_t hi_time
PREINIT:
BGPDUMP_ENTRY *entry;
PPCODE:
do {
entry = bgpdump_read_next(THIS);
if (entry == NULL)
continue;
if (lo_time > 0 && entry->time < lo_time)
( run in 2.338 seconds using v1.01-cache-2.11-cpan-4e7a2411597 )