Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 2.020 )
Inline-ASM
view release on metacpan or search on metacpan
if ($rtype eq 'void') {
print XS <<END;
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
$function($arg_name_list);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Inline-C
view release on metacpan or search on metacpan
lib/Inline/C.pm view on Meta::CPAN
if ($o->{CONFIG}{_TESTING}) {
$XS .= <<END;
PREINIT:
PerlIO* stream;
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
$function($arg_name_list);
stream = PerlIO_open(\"$dir/void_test\", \"a\");
if (stream == NULL) warn(\"%s\\n\", \"Unable to open $dir/void_test for appending\");
if (PL_markstack_ptr != temp) {
lib/Inline/C.pm view on Meta::CPAN
}
else {
$XS .= <<END;
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
$function($arg_name_list);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
Inline-Python
view release on metacpan or search on metacpan
PyObject *keys;
int len;
int i;
AV* const functions = newAV();
HV* const classes = newHV();
PPCODE:
mod = PyImport_AddModule(PYPKG);
dict = PyModule_GetDict(mod);
keys = PyMapping_Keys(dict);
len = PyObject_Length(dict);
PyObject *globals;
PyObject *locals;
PyObject *py_result;
int context;
SV* ret = NULL;
PPCODE:
Printf(("py_eval: code: %s\n", str));
/* doc: if the module wasn't already loaded, you will get an empty
* module object. */
main_module = PyImport_AddModule("__main__");
if(main_module == NULL) {
PyObject *py_retval = NULL;
PyObject *tuple = NULL;
SV* ret = NULL;
PPCODE:
Printf(("py_call_function\n"));
Printf(("package: %s\n", PYPKG));
Printf(("function: %s\n", FNAME));
PyObject *py_retval = NULL;
PyObject *tuple = NULL;
SV* ret = NULL;
PPCODE:
Printf(("py_call_function_ref\n"));
if (!PyCallable_Check(func)) {
croak("'%p' is not a callable object", func);
PyObject *py_retval; /* the return value */
int i;
int is_string;
SV *ret;
PPCODE:
Printf(("eval_python_method\n"));
if (SvROK(_inst) && SvTYPE(SvRV(_inst))==SVt_PVMG) {
inst = (PyObject*)SvIV(SvRV(_inst));
PyObject *inst;
char *key_name;
STRLEN len;
PPCODE:
Printf(("get_object_data py_has_attr\n"));
if (SvROK(_inst) && SvTYPE(SvRV(_inst))==SVt_PVMG) {
inst = (PyObject*)SvIV(SvRV(_inst));
char *key_name;
STRLEN len;
PyObject *py_retval; /* the return value */
SV *ret;
PPCODE:
Printf(("get_object_data py_get_attr\n"));
if (SvROK(_inst) && SvTYPE(SvRV(_inst))==SVt_PVMG) {
inst = (PyObject*)SvIV(SvRV(_inst));
PyObject *inst, *py_value;
char *key_name;
STRLEN len;
PPCODE:
Printf(("set_attr\n"));
if (SvROK(_inst) && SvTYPE(SvRV(_inst))==SVt_PVMG) {
inst = (PyObject*)SvIV(SvRV(_inst));
#undef NUM_FIXED_ARGS
#define NUM_FIXED_ARGS 0
void
py_finalize()
PPCODE:
Py_Finalize();
XSRETURN_EMPTY;
Inline-Ruby
view release on metacpan or search on metacpan
void
my_rb_eval(str)
char* str
PREINIT:
SV* pl_retval;
PPCODE:
Printf(("About to evaluate some Ruby code:\n"));
Printf(("%s\n", str));
Printf(("__END__"));
#ifdef rb_set_errinfo
rb_set_errinfo(Qnil); /* reset GET_THREAD()->errinfo */
my_rb_call_function(FNAME, ...)
char* FNAME
PREINIT:
VALUE argv;
SV* pl_retval;
PPCODE:
Printf(("rb_call_function(\"%s\")\n", FNAME));
INIT_RUBY_ARGV(argv);
pl_retval = call_ruby_method(Qnil, FNAME, NULL, argv);
#if defined CHECK_CONTEXT && defined FLATTEN_ARRAYS
FLATTEN_RETVAL(pl_retval);
char* mname
PREINIT:
VALUE klass;
VALUE argv;
SV* pl_retval;
PPCODE:
Printf(("rb_call_class_method('%s', '%s', ...)\n",KLASS,mname));
INIT_RUBY_ARGV(argv);
klass = rb_str_new2(KLASS);
pl_retval = call_ruby_method(klass, mname, NULL, argv);
PREINIT:
VALUE inst;
VALUE argv;
SV* pl_retval;
SV* iter;
PPCODE:
Printf(("rb_call_instance_method(%p, '%s', ...)\n",
_inst, mname));
if (isa_InlineRubyWrapper(_inst)) {
inst = UNWRAP_RUBY_OBJ(_inst);
Inline-SLang
view release on metacpan or search on metacpan
HV *hashref;
AV *arrayref;
char *name;
int i, sflag;
PPCODE:
/* create the hash array to store the results in */
hashref = (HV *) sv_2mortal( (SV *) newHV() );
/*
* assume that the max number of types is 256
char *outname;
char *slbuffer;
size_t blen;
int flag;
PPCODE:
/* not bothered anout 2 extra chars due to %s %s in format */
blen = strlen(slformat)+2*strlen(inname);
Newz( "", slbuffer, blen, char );
snprintf( slbuffer, blen, slformat, inname, inname );
SV * item
PREINIT:
SLtype sltype;
int slflag;
SV * out;
PPCODE:
sltype = pltype( item, &slflag );
switch( sltype ) {
case SLANG_NULL_TYPE: out = newSVpv( "Null_Type", 0 ); break;
case SLANG_INT_TYPE: out = newSVpv( "Integer_Type", 0 ); break;
PREINIT:
int dims[SLARRAY_MAX_DIMS];
AV *aref;
SV * out;
int i, ndim;
PPCODE:
aref = (AV *) SvRV( in );
ndim = 1 + av_len(aref);
Printf( ("Creating an empty array (%d dim) with size ", ndim) );
for( i = 0; i < ndim; i++ ) {
int dsize = SvIV( *av_fetch( aref, i, 0 ) );
void
_sl_eval( str )
char * str
PPCODE:
Printf( ("----------------------------------------------------------------------\n") );
Printf( ("sl_eval: code: %s\n", str ) );
Printf( ("----------------------------------------------------------------------\n") );
/*
char * qualname
PREINIT:
int i;
PPCODE:
Printf( ("sl_call_function called:\n function: %s\n", qualname ) );
/*
* We could remove this check - ie assume that if we've got this
* far then eveything 'should' be fine
Inline-Struct
view release on metacpan or search on metacpan
lib/Inline/Struct.pm view on Meta::CPAN
$field(object, ...)
$cname *object
PREINIT:
SV *retval = newSViv(0);
int mortalise_retval = 0;
PPCODE:
ENTER;
SAVETMPS;
if (items == 1) {
@{[typeconv($o, "object->$field", "retval", $type, "output_expr", undef, $field)]}
@{[
Inline-Tcl
view release on metacpan or search on metacpan
Tcl_Obj *listPtr, *elemObjPtr;
Tcl_Obj **objvPtr;
char *result;
int objc,i;
AV* functions = newAV();
PPCODE:
/*
* Get the pattern and find the "effective namespace" in which to
* list commands.
*/
char *result;
SV* ret = NULL;
char *command;
int cmdlen;
int len;
PPCODE:
cmdlen = 0;
for (i=1; i<items; i++) {
result = Pl2Tcl(ST(i));
InlineX-C2XS
view release on metacpan or search on metacpan
expected_c.txt view on Meta::CPAN
void
DESTROY (obj)
SV * obj
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
DESTROY(obj);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
expected_c.txt view on Meta::CPAN
SV * obj
char * filename
int want_hole
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
to_file(obj, filename, want_hole);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
expected_c.txt view on Meta::CPAN
SV * obj
SV * pg
int hole
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
remove_add_polygon(obj, pg, hole);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
expected_c.txt view on Meta::CPAN
void
get_polygons (obj)
SV * obj
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
get_polygons(obj);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
InlineX-CPP2XS
view release on metacpan or search on metacpan
demos/cpp/Inherit.xs view on Meta::CPAN
void
Foo::set_secret(s)
int s
PREINIT:
I32 * __temp_markstack_ptr;
PPCODE:
__temp_markstack_ptr = PL_markstack_ptr++;
THIS->set_secret(s);
if (PL_markstack_ptr != __temp_markstack_ptr) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = __temp_markstack_ptr;
demos/cpp/Inherit.xs view on Meta::CPAN
void
Bar::set_secret(s)
int s
PREINIT:
I32 * __temp_markstack_ptr;
PPCODE:
__temp_markstack_ptr = PL_markstack_ptr++;
THIS->set_secret(s);
if (PL_markstack_ptr != __temp_markstack_ptr) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = __temp_markstack_ptr;
Internals
view release on metacpan or search on metacpan
Internals.xs view on Meta::CPAN
void
IsWriteProtected(ref)
SV * ref
PPCODE:
{
SV *obj;
if ( INTERNALS_REFERENCE(ref,obj) )
{
Internals.xs view on Meta::CPAN
void
SetReadOnly(ref)
SV * ref
PPCODE:
{
SV *obj;
if ( INTERNALS_REFERENCE(ref,obj) )
{
Internals.xs view on Meta::CPAN
void
SetReadWrite(ref)
SV * ref
PPCODE:
{
SV *obj;
if ( INTERNALS_REFERENCE(ref,obj) )
{
Internals.xs view on Meta::CPAN
void
GetRefCount(ref)
SV * ref
PPCODE:
{
SV *obj;
if ( INTERNALS_REFERENCE(ref,obj) )
{
Internals.xs view on Meta::CPAN
void
SetRefCount(ref,val)
SV * ref
SV * val
PPCODE:
{
SV *obj;
U32 cnt;
if ( INTERNALS_REFERENCE(ref,obj) )
Isam
view release on metacpan or search on metacpan
isisaminfo1(fd)
int fd
PREINIT:
struct dictinfo di;
int cc;
PPCODE:
cc = isindexinfo(fd,&di,0);
EXTEND(SP, 5);
PUSHs(sv_2mortal(newSViv(cc)));
PUSHs(sv_2mortal(newSViv(di.di_nkeys)));
PUSHs(sv_2mortal(newSViv(di.di_recsize)));
int idx
PREINIT:
struct keydesc kd;
int cc;
int i, j;
PPCODE:
cc = isindexinfo(fd,&kd,idx);
EXTEND(SP,1+2+3*kd.k_nparts);
PUSHs(sv_2mortal(newSViv(cc)));
PUSHs(sv_2mortal(newSViv(kd.k_flags)));
PUSHs(sv_2mortal(newSViv(kd.k_nparts)));
JCM-Net-Patricia
view release on metacpan or search on metacpan
Patricia.xs view on Meta::CPAN
SV * data
PROTOTYPE: $$$$$
PREINIT:
prefix_t prefix;
JCM__Net__PatriciaNode node;
PPCODE:
Fill_Prefix(prefix, family, addr, bits, tree->maxbits);
node = patricia_lookup(tree, &prefix);
if (NULL != node) {
/* { */
if (node->data) {
Patricia.xs view on Meta::CPAN
int bits
PROTOTYPE: $$$$
PREINIT:
prefix_t prefix;
JCM__Net__PatriciaNode node;
PPCODE:
Fill_Prefix(prefix, family, addr, bits, tree->maxbits);
node = patricia_search_best(tree, &prefix);
if (NULL != node) {
XPUSHs((SV *)node->data);
} else {
Patricia.xs view on Meta::CPAN
int bits
PROTOTYPE: $$$$
PREINIT:
prefix_t prefix;
JCM__Net__PatriciaNode node;
PPCODE:
Fill_Prefix(prefix, family, addr, bits, tree->maxbits);
node = patricia_search_best(tree, &prefix);
if (NULL != node) {
if (node->prefix->family == AF_INET) {
XPUSHs(sv_2mortal(
Patricia.xs view on Meta::CPAN
int bits
PROTOTYPE: $$$$
PREINIT:
prefix_t prefix;
JCM__Net__PatriciaNode node;
PPCODE:
Fill_Prefix(prefix, family, addr, bits, tree->maxbits);
node = patricia_search_exact(tree, &prefix);
if (NULL != node) {
XPUSHs((SV *)node->data);
} else {
Patricia.xs view on Meta::CPAN
int bits
PROTOTYPE: $$$$
PREINIT:
prefix_t prefix;
JCM__Net__PatriciaNode node;
PPCODE:
Fill_Prefix(prefix, family, addr, bits, tree->maxbits);
node = patricia_search_exact(tree, &prefix);
if (NULL != node) {
XPUSHs(sv_mortalcopy((SV *)node->data));
deref_data(node->data);
Patricia.xs view on Meta::CPAN
patricia_node_t *node = NULL;
struct frozen_header frozen_header;
struct frozen_node *frozen_nodes, *frozen_node;
size_t n = 0, i = 0, nd = 0;
SV *frozen_patricia;
PPCODE:
if (SvTRUE(cloning))
XSRETURN_UNDEF;
/* I do not know enough of patricia.c to
* decide whether inactive nodes can
Patricia.xs view on Meta::CPAN
struct frozen_node *frozen_node;
struct _patricia_tree_t *tree;
patricia_node_t *node = NULL, *child, **fixup;
int n, n_calculated, i, d_index, l_index, r_index;
STRLEN len;
PPCODE:
if (SvTRUE(cloning))
XSRETURN_UNDEF;
tree = calloc(1, sizeof(*tree));
frozen_patricia = (struct frozen_patricia*)SvPV(serialized, len);
JSON-SIMD
view release on metacpan or search on metacpan
bool_stash = 0;
bool_false = 0;
bool_true = 0;
void new (char *klass)
PPCODE:
{
SV *pv = NEWSV (0, sizeof (JSON));
SvPOK_only (pv);
json_init ((JSON *)SvPVX (pv));
XPUSHs (sv_2mortal (sv_bless (
strEQ (klass, "JSON::SIMD") ? JSON_STASH : gv_stashpv (klass, 1)
)));
}
void boolean_values (JSON *self, SV *v_false = 0, SV *v_true = 0)
PPCODE:
self->flags &= ~F_CORE_BOOLS;
self->v_false = newSVsv (v_false);
self->v_true = newSVsv (v_true);
XPUSHs (ST (0));
void get_boolean_values (JSON *self)
PPCODE:
if (self->v_false && self->v_true)
{
EXTEND (SP, 2);
PUSHs (self->v_false);
PUSHs (self->v_true);
}
void core_bools (JSON *self, int enable = 1)
PPCODE:
if (enable)
{
self->flags |= F_CORE_BOOLS;
self->v_false = newSVsv (&PL_sv_no);
self->v_true = newSVsv (&PL_sv_yes);
self->v_true = 0;
}
XPUSHs (ST (0));
void get_core_bools (JSON *self)
PPCODE:
{
int result = self->flags & F_CORE_BOOLS;
#if PERL_VERSION_GE(5,36,0)
if (self->v_false && self->v_true && SvIsBOOL(self->v_false) && SvIsBOOL(self->v_true))
{
relaxed = F_RELAXED
allow_unknown = F_ALLOW_UNKNOWN
allow_tags = F_ALLOW_TAGS
use_simdjson = F_USE_SIMDJSON
encode_core_bools = F_ENCODE_CORE_BOOLS
PPCODE:
{
if (enable)
self->flags |= ix;
else
self->flags &= ~ix;
get_relaxed = F_RELAXED
get_allow_unknown = F_ALLOW_UNKNOWN
get_allow_tags = F_ALLOW_TAGS
get_use_simdjson = F_USE_SIMDJSON
get_encode_core_bools = F_ENCODE_CORE_BOOLS
PPCODE:
XPUSHs (boolSV (self->flags & ix));
void max_depth (JSON *self, U32 max_depth = 0x80000000UL)
PPCODE:
self->max_depth = max_depth;
XPUSHs (ST (0));
U32 get_max_depth (JSON *self)
CODE:
RETVAL = self->max_depth;
OUTPUT:
RETVAL
void max_size (JSON *self, U32 max_size = 0)
PPCODE:
self->max_size = max_size;
XPUSHs (ST (0));
int get_max_size (JSON *self)
CODE:
RETVAL = self->max_size;
OUTPUT:
RETVAL
void filter_json_object (JSON *self, SV *cb = &PL_sv_undef)
PPCODE:
{
SvREFCNT_dec (self->cb_object);
self->cb_object = SvOK (cb) ? newSVsv (cb) : 0;
XPUSHs (ST (0));
}
void filter_json_single_key_object (JSON *self, SV *key, SV *cb = &PL_sv_undef)
PPCODE:
{
if (!self->cb_sk_object)
self->cb_sk_object = newHV ();
if (SvOK (cb))
XPUSHs (ST (0));
}
void encode (JSON *self, SV *scalar)
PPCODE:
PUTBACK; scalar = encode_json (scalar, self); SPAGAIN;
XPUSHs (scalar);
void decode (JSON *self, SV *jsonstr)
PPCODE:
PUTBACK; jsonstr = decode_json (jsonstr, self, 0, 0); SPAGAIN;
XPUSHs (jsonstr);
void decode_prefix (JSON *self, SV *jsonstr)
PPCODE:
{
SV *sv;
STRLEN offset;
PUTBACK; sv = decode_json (jsonstr, self, &offset, 0); SPAGAIN;
EXTEND (SP, 2);
PUSHs (sv);
PUSHs (sv_2mortal (newSVuv (ptr_to_index (jsonstr, SvPV_nolen (jsonstr) + offset))));
}
void decode_at_pointer (JSON *self, SV *jsonstr, SV *path)
PPCODE:
PUTBACK; jsonstr = decode_json (jsonstr, self, 0, path); SPAGAIN;
XPUSHs (jsonstr);
void incr_parse (JSON *self, SV *jsonstr = 0)
PPCODE:
{
if (!self->incr_text)
self->incr_text = newSVpvn ("", 0);
/* if utf8-ness doesn't match the decoder, need to upgrade/downgrade */
SvREFCNT_dec (self->incr_text);
PROTOTYPES: ENABLE
void encode_json (SV *scalar)
PPCODE:
{
JSON json;
json_init (&json);
json.flags |= F_UTF8;
PUTBACK; scalar = encode_json (scalar, &json); SPAGAIN;
XPUSHs (scalar);
}
void decode_json (SV *jsonstr)
PPCODE:
{
JSON json;
json_init (&json);
json.flags |= F_UTF8;
PUTBACK; jsonstr = decode_json (jsonstr, &json, 0, 0); SPAGAIN;
XPUSHs (jsonstr);
}
void simdjson_version ()
PPCODE:
{
SV *version_info;
PUTBACK; version_info = simdjson_get_version(); SPAGAIN;
XPUSHs (version_info);
}
void is_core_bool (SV *scalar)
PPCODE:
{
#if PERL_VERSION_GE(5,36,0)
XPUSHs( boolSV( SvIsBOOL( scalar )));
#else
XPUSHs( boolSV( 0 ));
JSON-SL
view release on metacpan or search on metacpan
OUTPUT: RETVAL
void
PLJSONSL_set_jsonpointer(PLJSONSL *pjsn, AV *paths)
PPCODE:
pljsonsl_set_jsonpointer(pjsn, paths);
SV *
PLJSONSL_root(PLJSONSL *pjsn)
CODE:
void
PLJSONSL_feed(PLJSONSL *pjsn, SV *input)
ALIAS:
incr_parse =1
PPCODE:
{
dRESULT_VARS;
pljsonsl_feed_incr(pjsn, input);
RETURN_RESULTS(pjsn);
}
void
PLJSONSL_fetch(PLJSONSL *pjsn)
PPCODE:
{
dRESULT_VARS;
RETURN_RESULTS(pjsn);
}
PLJSONSL_decode_json(SV *input)
PREINIT:
PLJSONSL* pjsn;
dRESULT_VARS;
PPCODE:
pjsn = pljsonsl_get_and_initialize_global(aTHX);
pljsonsl_feed_oneshot(pjsn, input);
pjsn->curhk = NULL;
pjsn->keep_pos = 0;
JSON-Schema-Fast
view release on metacpan or search on metacpan
void
validate(compiled, data)
SV *compiled
SV *data
PPCODE:
{
jsf_compiled_t *C = jsf_compiled_of(aTHX_ compiled);
AV *errs = (AV *)sv_2mortal((SV *)newAV());
int ok = jsf_run(aTHX_ C, data, errs);
if (GIMME_V == G_ARRAY) {
# list context: (1) if valid, else (0, \@errors); scalar context: the boolean.
void
validate(self, data)
SV *self
SV *data
PPCODE:
{
jsf_compiled_t *C = jsf_compiled_of(aTHX_ self);
AV *errs = (AV *)sv_2mortal((SV *)newAV());
int ok = jsf_run(aTHX_ C, data, errs);
if (GIMME_V == G_ARRAY) {
JSON-XS-ByteString
view release on metacpan or search on metacpan
ByteString.xs view on Meta::CPAN
MODULE = JSON::XS::ByteString PACKAGE = JSON::XS::ByteString
void
encode_json(SV * data)
PPCODE:
visited_p = 0;
STRLEN need_size = estimate_normal(data);
SV * out_sv = sv_2mortal(newSV(need_size));
SvPOK_only(out_sv);
visited_p = 0;
ByteString.xs view on Meta::CPAN
*SvEND(out_sv) = 0;
PUSHs(out_sv);
void
encode_json_unblessed(SV * data)
PPCODE:
visited_p = 0;
STRLEN need_size = estimate_unblessed(data);
SV * out_sv = sv_2mortal(newSV(need_size));
SvPOK_only(out_sv);
visited_p = 0;
ByteString.xs view on Meta::CPAN
*SvEND(out_sv) = 0;
PUSHs(out_sv);
void
decode_json(SV * json)
PPCODE:
unsigned char *str, *str_end, *str_adv;
STRLEN len;
SV * out = NULL;
str = (unsigned char*) SvPV(json, len);
str_end = str + len;
ByteString.xs view on Meta::CPAN
else
PUSHs(sv_2mortal(out));
void
decode_json_safe(SV * json)
PPCODE:
unsigned char *str, *str_end, *str_adv;
STRLEN len;
SV * out = NULL;
str = (unsigned char*) SvPV(json, len);
str_end = str + len;
JSON-XS
view release on metacpan or search on metacpan
bool_stash = 0;
bool_false = 0;
bool_true = 0;
void new (char *klass)
PPCODE:
{
SV *pv = NEWSV (0, sizeof (JSON));
SvPOK_only (pv);
json_init ((JSON *)SvPVX (pv));
XPUSHs (sv_2mortal (sv_bless (
strEQ (klass, "JSON::XS") ? JSON_STASH : gv_stashpv (klass, 1)
)));
}
void boolean_values (JSON *self, SV *v_false = 0, SV *v_true = 0)
PPCODE:
self->v_false = newSVsv (v_false);
self->v_true = newSVsv (v_true);
XPUSHs (ST (0));
void get_boolean_values (JSON *self)
PPCODE:
if (self->v_false && self->v_true)
{
EXTEND (SP, 2);
PUSHs (self->v_false);
PUSHs (self->v_true);
allow_blessed = F_ALLOW_BLESSED
convert_blessed = F_CONV_BLESSED
relaxed = F_RELAXED
allow_unknown = F_ALLOW_UNKNOWN
allow_tags = F_ALLOW_TAGS
PPCODE:
{
if (enable)
self->flags |= ix;
else
self->flags &= ~ix;
get_allow_blessed = F_ALLOW_BLESSED
get_convert_blessed = F_CONV_BLESSED
get_relaxed = F_RELAXED
get_allow_unknown = F_ALLOW_UNKNOWN
get_allow_tags = F_ALLOW_TAGS
PPCODE:
XPUSHs (boolSV (self->flags & ix));
void max_depth (JSON *self, U32 max_depth = 0x80000000UL)
PPCODE:
self->max_depth = max_depth;
XPUSHs (ST (0));
U32 get_max_depth (JSON *self)
CODE:
RETVAL = self->max_depth;
OUTPUT:
RETVAL
void max_size (JSON *self, U32 max_size = 0)
PPCODE:
self->max_size = max_size;
XPUSHs (ST (0));
int get_max_size (JSON *self)
CODE:
RETVAL = self->max_size;
OUTPUT:
RETVAL
void filter_json_object (JSON *self, SV *cb = &PL_sv_undef)
PPCODE:
{
SvREFCNT_dec (self->cb_object);
self->cb_object = SvOK (cb) ? newSVsv (cb) : 0;
XPUSHs (ST (0));
}
void filter_json_single_key_object (JSON *self, SV *key, SV *cb = &PL_sv_undef)
PPCODE:
{
if (!self->cb_sk_object)
self->cb_sk_object = newHV ();
if (SvOK (cb))
XPUSHs (ST (0));
}
void encode (JSON *self, SV *scalar)
PPCODE:
PUTBACK; scalar = encode_json (scalar, self); SPAGAIN;
XPUSHs (scalar);
void decode (JSON *self, SV *jsonstr)
PPCODE:
PUTBACK; jsonstr = decode_json (jsonstr, self, 0); SPAGAIN;
XPUSHs (jsonstr);
void decode_prefix (JSON *self, SV *jsonstr)
PPCODE:
{
SV *sv;
STRLEN offset;
PUTBACK; sv = decode_json (jsonstr, self, &offset); SPAGAIN;
EXTEND (SP, 2);
PUSHs (sv);
PUSHs (sv_2mortal (newSVuv (ptr_to_index (jsonstr, SvPV_nolen (jsonstr) + offset))));
}
void incr_parse (JSON *self, SV *jsonstr = 0)
PPCODE:
{
if (!self->incr_text)
self->incr_text = newSVpvn ("", 0);
/* if utf8-ness doesn't match the decoder, need to upgrade/downgrade */
SvREFCNT_dec (self->incr_text);
PROTOTYPES: ENABLE
void encode_json (SV *scalar)
PPCODE:
{
JSON json;
json_init (&json);
json.flags |= F_UTF8;
PUTBACK; scalar = encode_json (scalar, &json); SPAGAIN;
XPUSHs (scalar);
}
void decode_json (SV *jsonstr)
PPCODE:
{
JSON json;
json_init (&json);
json.flags |= F_UTF8;
PUTBACK; jsonstr = decode_json (jsonstr, &json, 0); SPAGAIN;
JSPL
view release on metacpan or search on metacpan
RETVAL
void
jsvisitor(sv)
SV *sv
PPCODE:
if(SvOK(sv) && SvROK(sv) && (sv = SvRV(sv)) && SvMAGICAL(sv)) {
MAGIC *mg = mg_find(sv, PERL_MAGIC_jsvis);
while(mg) {
if(mg->mg_type == PERL_MAGIC_jsvis && mg->mg_private == 0x4a53) {
jsv_mg *jsvis = (jsv_mg *)mg->mg_ptr;
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));
( run in 2.020 seconds using v1.01-cache-2.11-cpan-4e7a2411597 )