Result:
found more than 1151 distributions - search limited to the first 2001 files matching your query
( run in 1.244 )
Clownfish-CFC
view release on metacpan or search on metacpan
lib/Clownfish/CFC.xs view on Meta::CPAN
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Base
void
DESTROY(self)
CFCBase *self;
PPCODE:
CFCBase_decref((CFCBase*)self);
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Model::CBlock
lib/Clownfish/CFC.xs view on Meta::CPAN
void
_set_or_get(self, ...)
CFCCBlock *self;
ALIAS:
get_contents = 2
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *contents = CFCCBlock_get_contents(self);
retval = newSVpvn(contents, strlen(contents));
lib/Clownfish/CFC.xs view on Meta::CPAN
RETVAL = S_cfcbase_to_perlref(klass);
OUTPUT: RETVAL
void
_clear_registry(...)
PPCODE:
CHY_UNUSED_VAR(items);
CFCClass_clear_registry();
void
add_child(self, child)
CFCClass *self;
CFCClass *child;
PPCODE:
CFCClass_add_child(self, child);
void
add_member_var(self, var)
CFCClass *self;
CFCVariable *var;
PPCODE:
CFCClass_add_member_var(self, var);
void
add_function(self, func)
CFCClass *self;
CFCFunction *func;
PPCODE:
CFCClass_add_function(self, func);
void
add_method(self, method)
CFCClass *self;
CFCMethod *method;
PPCODE:
CFCClass_add_method(self, method);
void
grow_tree(self)
CFCClass *self;
PPCODE:
CFCClass_grow_tree(self);
void
add_inert_var(self, var)
CFCClass *self;
CFCVariable *var;
PPCODE:
CFCClass_add_inert_var(self, var);
SV*
function(self, sym)
CFCClass *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
OUTPUT: RETVAL
void
resolve_types(self)
CFCClass *self;
PPCODE:
CFCClass_resolve_types(self);
void
_set_or_get(self, ...)
CFCClass *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
tree_to_ladder = 42
fresh_methods = 44
fresh_member_vars = 46
privacy_symbol = 48
included = 50
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *value = CFCClass_get_exposure(self);
retval = newSVpvn(value, strlen(value));
lib/Clownfish/CFC.xs view on Meta::CPAN
get_brief = 4
get_long = 6
get_param_names = 8
get_param_docs = 10
get_retval = 12
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *description = CFCDocuComment_get_description(self);
retval = newSVpvn(description, strlen(description));
lib/Clownfish/CFC.xs view on Meta::CPAN
void
add_block(self, block)
CFCFile *self;
CFCBase *block;
PPCODE:
CFCFile_add_block(self, block);
void
_set_or_get(self, ...)
CFCFile *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
classes = 14
get_source_dir = 16
included = 18
get_parcel = 20
get_path = 22
PPCODE:
{
START_SET_OR_GET_SWITCH
case 1:
CFCFile_set_modified(self, !!SvTRUE(ST(1)));
break;
lib/Clownfish/CFC.xs view on Meta::CPAN
CFCFileSpec *self;
ALIAS:
get_source_dir = 2
get_path_part = 4
included = 6
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *value = CFCFileSpec_get_source_dir(self);
retval = newSVpv(value, strlen(value));
lib/Clownfish/CFC.xs view on Meta::CPAN
OUTPUT: RETVAL
void
resolve_types(self)
CFCFunction *self;
PPCODE:
CFCFunction_resolve_types(self);
SV*
_various_function_syms(self, klass)
CFCFunction *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
get_return_type = 2
get_param_list = 4
get_docucomment = 6
inline = 8
void = 10
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
CFCType *type = CFCFunction_get_return_type(self);
retval = S_cfcbase_to_perlref(type);
lib/Clownfish/CFC.xs view on Meta::CPAN
void
add_source_dir(self, source_dir)
CFCHierarchy *self;
const char *source_dir;
PPCODE:
CFCHierarchy_add_source_dir(self, source_dir);
void
add_include_dir(self, include_dir)
CFCHierarchy *self;
const char *include_dir;
PPCODE:
CFCHierarchy_add_include_dir(self, include_dir);
void
build(self)
CFCHierarchy *self;
PPCODE:
CFCHierarchy_build(self);
void
read_host_data_json(self)
CFCHierarchy *self;
PPCODE:
CFCHierarchy_read_host_data_json(self, "perl");
int
propagate_modified(self, ...)
CFCHierarchy *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
OUTPUT: RETVAL
void
write_log(self)
CFCHierarchy *self;
PPCODE:
CFCHierarchy_write_log(self);
void
_set_or_get(self, ...)
CFCHierarchy *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
get_source_dest = 6
files = 8
ordered_classes = 10
get_source_dirs = 12
get_include_dirs = 14
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *value = CFCHierarchy_get_dest(self);
retval = newSVpv(value, strlen(value));
lib/Clownfish/CFC.xs view on Meta::CPAN
void
override(self, other)
CFCMethod *self;
CFCMethod *other;
PPCODE:
CFCMethod_override(self, other);
SV*
finalize(self)
CFCMethod *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
OUTPUT: RETVAL
void
resolve_types(self)
CFCMethod *self;
PPCODE:
CFCMethod_resolve_types(self);
void
exclude_from_host(self)
CFCMethod *self;
PPCODE:
CFCMethod_exclude_from_host(self);
SV*
_various_method_syms(self, invoker)
CFCMethod *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
final = 16
self_type = 18
set_host_alias = 19
get_host_alias = 20
excluded_from_host = 22
PPCODE:
{
START_SET_OR_GET_SWITCH
case 12:
retval = newSViv(CFCMethod_abstract(self));
break;
lib/Clownfish/CFC.xs view on Meta::CPAN
void
add_param(self, variable, value_sv)
CFCParamList *self;
CFCVariable *variable;
SV *value_sv;
PPCODE:
const char *value = SvOK(value_sv) ? SvPV_nolen(value_sv) : NULL;
CFCParamList_add_param(self, variable, value);
void
resolve_types(self)
CFCParamList *self;
PPCODE:
CFCParamList_resolve_types(self);
void
_set_or_get(self, ...)
CFCParamList *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
get_initial_values = 4
variadic = 6
num_vars = 8
to_c = 10
name_list = 12
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
AV *av = newAV();
CFCVariable **vars = CFCParamList_get_variables(self);
lib/Clownfish/CFC.xs view on Meta::CPAN
void
register(self)
CFCParcel *self;
PPCODE:
CFCParcel_register(self);
int
equals(self, other)
CFCParcel *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
void
add_inherited_parcel(self, inherited)
CFCParcel *self;
CFCParcel *inherited;
PPCODE:
CFCParcel_add_inherited_parcel(self, inherited);
int
has_prereq(self, parcel)
CFCParcel *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
void
add_struct_sym(self, struct_sym)
CFCParcel *self;
const char *struct_sym;
PPCODE:
CFCParcel_add_struct_sym(self, struct_sym);
SV*
lookup_struct_sym(self, struct_sym)
CFCParcel *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
RETVAL = S_cfcbase_to_perlref(parcel);
OUTPUT: RETVAL
void
reap_singletons(...)
PPCODE:
CHY_UNUSED_VAR(items);
CFCParcel_reap_singletons();
void
_set_or_get(self, ...)
lib/Clownfish/CFC.xs view on Meta::CPAN
get_prereqs = 14
included = 16
prereq_parcels = 20
inherited_parcels = 22
get_xs_module = 24
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *name = CFCParcel_get_name(self);
retval = newSVpvn(name, strlen(name));
lib/Clownfish/CFC.xs view on Meta::CPAN
_set_or_get(self, ...)
CFCPrereq *self;
ALIAS:
get_name = 2
get_version = 4
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *name = CFCPrereq_get_name(self);
retval = newSVpvn(name, strlen(name));
lib/Clownfish/CFC.xs view on Meta::CPAN
get_name = 10
public = 18
private = 20
parcel = 22
local = 24
PPCODE:
{
START_SET_OR_GET_SWITCH
case 8: {
const char *exposure = CFCSymbol_get_exposure(self);
retval = newSVpvn(exposure, strlen(exposure));
lib/Clownfish/CFC.xs view on Meta::CPAN
OUTPUT: RETVAL
void
resolve(self)
CFCType *self;
PPCODE:
CFCType_resolve(self);
void
_set_or_get(self, ...)
CFCType *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
is_composite = 30
get_width = 32
incremented = 34
decremented = 36
get_array = 38
PPCODE:
{
START_SET_OR_GET_SWITCH
case 1:
CFCType_set_specifier(self, SvPV_nolen(ST(1)));
break;
lib/Clownfish/CFC.xs view on Meta::CPAN
void
write_if_changed(path, content_sv)
const char *path;
SV *content_sv;
PPCODE:
STRLEN len;
char *content = SvPV(content_sv, len);
CFCUtil_write_if_changed(path, content, len);
int
lib/Clownfish/CFC.xs view on Meta::CPAN
OUTPUT: RETVAL
void
resolve_type(self)
CFCVariable *self;
PPCODE:
CFCVariable_resolve_type(self);
SV*
global_c(self, klass)
CFCVariable *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
CFCVariable *self;
ALIAS:
get_type = 2
local_c = 4
local_declaration = 8
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
CFCType *type = CFCVariable_get_type(self);
retval = S_cfcbase_to_perlref(type);
lib/Clownfish/CFC.xs view on Meta::CPAN
_set_or_get(self, ...)
CFCVersion *self;
ALIAS:
get_major = 2
get_vstring = 4
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2:
retval = newSVuv(CFCVersion_get_major(self));
break;
lib/Clownfish/CFC.xs view on Meta::CPAN
void
copy_headers(self, dest_dir)
CFCBindCore *self;
const char *dest_dir;
PPCODE:
CFCBindCore_copy_headers(self, dest_dir);
void
write_host_data_json(self, dest_dir)
CFCBindCore *self;
const char *dest_dir;
PPCODE:
CFCBindCore_write_host_data_json(self, dest_dir, "perl");
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Binding::Core::Function
lib/Clownfish/CFC.xs view on Meta::CPAN
_write_h(file, dest, header, footer)
CFCFile *file;
const char *dest;
const char *header;
const char *footer;
PPCODE:
CFCBindFile_write_h(file, dest, header, footer);
MODULE = Clownfish PACKAGE = Clownfish::CFC::Binding::Perl
SV*
lib/Clownfish/CFC.xs view on Meta::CPAN
OUTPUT: RETVAL
void
write_host_code(self)
CFCPerl *self;
PPCODE:
CFCPerl_write_host_code(self);
void
write_hostdefs(self)
CFCPerl *self;
PPCODE:
CFCPerl_write_hostdefs(self);
void
_write_bindings(self, boot_class, sv)
CFCPerl *self;
const char *boot_class;
SV *sv;
PPCODE:
CFCParcel **parcels = (CFCParcel**)
S_av_to_array_of_cfcbase(sv, "Clownfish::CFC::Model::Parcel");
CFCPerl_write_bindings(self, boot_class, parcels);
FREEMEM(parcels);
void
write_xs_typemap(self)
CFCPerl *self;
PPCODE:
CFCPerl_write_xs_typemap(self);
MODULE = Clownfish PACKAGE = Clownfish::CFC::Binding::Perl::Subroutine
lib/Clownfish/CFC.xs view on Meta::CPAN
use_labeled_params = 4
perl_name = 6
get_param_list = 8
c_name = 10
c_name_list = 12
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *value = CFCPerlSub_get_class_name(self);
retval = newSVpvn(value, strlen(value));
lib/Clownfish/CFC.xs view on Meta::CPAN
void
register(unused, binding)
SV *unused;
CFCPerlClass *binding;
PPCODE:
CHY_UNUSED_VAR(unused);
CFCPerlClass_add_to_registry(binding);
SV*
singleton(unused_sv, class_name)
lib/Clownfish/CFC.xs view on Meta::CPAN
RETVAL = S_array_of_cfcbase_to_av((CFCBase**)registry);
OUTPUT: RETVAL
void
_clear_registry(...)
PPCODE:
CHY_UNUSED_VAR(items);
CFCPerlClass_clear_registry();
void
_bind_method(self, alias_sv, meth_sv)
CFCPerlClass *self;
SV *alias_sv;
SV *meth_sv;
PPCODE:
const char *alias = SvOK(alias_sv) ? SvPVutf8_nolen(alias_sv) : NULL;
const char *meth = SvOK(meth_sv) ? SvPVutf8_nolen(meth_sv) : NULL;
CFCPerlClass_bind_method(self, alias, meth);
void
_bind_constructor(self, alias_sv, init_sv)
CFCPerlClass *self;
SV *alias_sv;
SV *init_sv;
PPCODE:
const char *alias = SvOK(alias_sv) ? SvPVutf8_nolen(alias_sv) : NULL;
const char *init = SvOK(init_sv) ? SvPVutf8_nolen(init_sv) : NULL;
CFCPerlClass_bind_constructor(self, alias, init);
void
exclude_method(self, method)
CFCPerlClass *self;
const char *method;
PPCODE:
CFCPerlClass_exclude_method(self, method);
void
exclude_constructor(self)
CFCPerlClass *self;
PPCODE:
CFCPerlClass_exclude_constructor(self);
void
append_xs(self, xs)
CFCPerlClass *self;
const char *xs;
PPCODE:
CFCPerlClass_append_xs(self, xs);
SV*
method_bindings(unused, klass)
SV *unused;
lib/Clownfish/CFC.xs view on Meta::CPAN
get_class_name = 2
get_client = 4
get_xs_code = 6
set_pod_spec = 7
get_pod_spec = 8
PPCODE:
{
START_SET_OR_GET_SWITCH
case 2: {
const char *value = CFCPerlClass_get_class_name(self);
retval = newSVpvn(value, strlen(value));
lib/Clownfish/CFC.xs view on Meta::CPAN
void
add_class_alias(self, alias)
CFCPerlClass *self;
const char *alias;
PPCODE:
CFCPerlClass_add_class_alias(self, alias);
SV*
get_class_aliases(self)
CFCPerlClass *self;
lib/Clownfish/CFC.xs view on Meta::CPAN
CFCPerlPod *self;
const char *alias;
SV *method_sv;
SV *sample_sv;
SV *pod_sv;
PPCODE:
const char *method = SvPOK(method_sv) ? SvPVutf8_nolen(method_sv) : NULL;
const char *sample = SvPOK(sample_sv) ? SvPVutf8_nolen(sample_sv) : NULL;
const char *pod = SvPOK(pod_sv) ? SvPVutf8_nolen(pod_sv) : NULL;
CFCPerlPod_add_method(self, alias, method, sample, pod);
lib/Clownfish/CFC.xs view on Meta::CPAN
CFCPerlPod *self;
SV *alias_sv;
SV *func_sv;
SV *sample_sv;
SV *pod_sv;
PPCODE:
const char *alias = SvPOK(alias_sv) ? SvPVutf8_nolen(alias_sv) : NULL;
const char *func = SvPOK(func_sv) ? SvPVutf8_nolen(func_sv) : NULL;
const char *sample = SvPOK(sample_sv) ? SvPVutf8_nolen(sample_sv) : NULL;
const char *pod = SvPOK(pod_sv) ? SvPVutf8_nolen(pod_sv) : NULL;
CFCPerlPod_add_constructor(self, alias, func, sample, pod);
lib/Clownfish/CFC.xs view on Meta::CPAN
ALIAS:
set_synopsis = 1
get_synopsis = 2
set_description = 3
get_description = 4
PPCODE:
{
START_SET_OR_GET_SWITCH
case 1: {
const char *val = SvOK(ST(1)) ? SvPVutf8_nolen(ST(1)) : NULL;
CFCPerlPod_set_synopsis(self, val);
lib/Clownfish/CFC.xs view on Meta::CPAN
OUTPUT: RETVAL
void
_write_xs_typemap(hierarchy)
CFCHierarchy *hierarchy;
PPCODE:
CFCPerlTypeMap_write_xs_typemap(hierarchy);
MODULE = Clownfish::CFC PACKAGE = Clownfish::CFC::Parser
lib/Clownfish/CFC.xs view on Meta::CPAN
void
set_parcel(self, parcel)
CFCParser *self;
CFCParcel *parcel;
PPCODE:
CFCParser_set_parcel(self, parcel);
void
set_class_name(self, class_name)
CFCParser *self;
const char *class_name;
PPCODE:
CFCParser_set_class_name(self, class_name);
SV*
get_parcel(self)
CFCParser *self;
Cocoa-NetworkChange
view release on metacpan or search on metacpan
src/NetworkChange.xs view on Meta::CPAN
PROTOTYPES: DISABLE
void
on_network_change(SV* sv_connect_cb, ...)
PPCODE:
{
SV* connect_cb = get_sv("Cocoa::NetworkChange::__connect_cb", GV_ADD);
sv_setsv(connect_cb, sv_connect_cb);
if (items > 1) {
CodeBase
view release on metacpan or search on metacpan
CodeBase.xs view on Meta::CPAN
char buffer[256];
FIELD4 *field;
char field_type;
int n_fields;
PPCODE:
CB_TRACE(1, ("fieldinfo(\"%s\")\n", SELF));
CB_TRACE(1, ("fieldinfo returns ("));
cb_errno = CB_SUCCESS;
n_fields = d4numFields(self->data4);
CodeBase.xs view on Meta::CPAN
PREINIT:
const FIELD4 *field;
const char *field_name;
int field_no, n_fields;
PPCODE:
CB_TRACE(1, ("names(\"%s\"\n", SELF));
cb_errno = CB_SUCCESS;
n_fields = d4numFields(self->data4);
CB_TRACE(1, ("names returns ("));
EXTEND(sp, n_fields);
CodeBase.xs view on Meta::CPAN
char buffer[256];
char fieldtype;
Boolean only_named_fields = (items > 1);
int n_fields;
PPCODE:
CB_TRACE(1, ("values(\"%s\")\n", SvPV(ST(0),na)));
CB_TRACE(1, ("values returns ("));
cb_errno = CB_SUCCESS;
n_fields = (only_named_fields ? items - 1 : d4numFields(self->data4));
CodeBase.xs view on Meta::CPAN
SV *ref;
TAG4INFO *tag4info;
int tag_no;
char *value;
PPCODE:
#if S4VERSION < 6000
if (index_name == NULL)
{
index_name = d4fileName(self->data4);
}
CodeBase.xs view on Meta::CPAN
PREINIT:
TAG4 *tag = NULL;
int n_tags = 0;
PPCODE:
CB_TRACE(1, ("tags(\"%s\")\n", SELF));
CB_TRACE(1, ("tags returns ("));
cb_errno = CB_SUCCESS;
while ((tag = d4tagNext(self->data4, tag)) != NULL)
{
Colouring-In-XS
view release on metacpan or search on metacpan
lib/Colouring/In/XS.xs view on Meta::CPAN
RETVAL
void
colour(self)
SV * self
PPCODE:
int i;
AV * colour = (AV*)SvRV(*hv_fetch((HV*)SvRV(self), "colour", 6, 0));
int len = av_len(colour);
EXTEND(SP, len + 1);
for (i = 0; i <= len; i++) {
Comedi-Lib
view release on metacpan or search on metacpan
void
lib_perror (str)
const char * str
PREINIT:
I32* temp;
PPCODE:
temp = PL_markstack_ptr++;
lib_perror(str);
if (PL_markstack_ptr != temp) {
/* truly void, because dXSARGS not invoked */
PL_markstack_ptr = temp;
CommonMark
view release on metacpan or search on metacpan
CommonMark.xs view on Meta::CPAN
cmark_iter_next(cmark_iter *iter)
PREINIT:
I32 gimme;
cmark_node *old_node;
cmark_event_type ev_type;
PPCODE:
gimme = GIMME_V;
old_node = cmark_iter_get_node(iter);
ev_type = cmark_iter_next(iter);
if (ev_type != CMARK_EVENT_DONE) {
Compress-Bzip2
view release on metacpan or search on metacpan
SV *perlobj;
char *class, *param;
STRLEN lnclass, lnparam;
int setting;
PPCODE:
{
int i;
perlobj = NULL;
obj = NULL;
STRLEN ln, lnfilename, lnclass;
bzFile* obj;
SV *perlobj;
PPCODE:
{
int i;
perlobj=NULL;
obj=NULL;
Compress::Bzip2 obj
int abandon
PROTOTYPE: $;$
PPCODE:
{
int i, ret, amt_collected;
char *inp;
int error_flag = 0;
Compress::Bzip2 obj
int flag
PROTOTYPE: $;$
PPCODE:
{
int i, ret, amt_collected;
char *inp;
if ( obj->open_status != OPEN_STATUS_READSTREAM && obj->open_status != OPEN_STATUS_WRITESTREAM ) {
SV *perlobj = NULL;
char *param;
STRLEN lnparam;
int setting;
PPCODE:
{
int i;
if (items % 2) croak("Compress::Bzip2::%s has odd parameter count", ix==0 ? "bzdeflateInit" : "compress_init");
Compress::Bzip2 obj
SV *buffer
PROTOTYPE: $$
PPCODE:
{
char *firstp, *outp;
SV *outbuf = NULL;
STRLEN outbufl = 0;
SV *perlobj = NULL;
char *param;
STRLEN lnparam;
int setting;
PPCODE:
{
int i;
if (items % 2)
croak("Compress::Bzip2::%s has odd parameter count", ix==0 ? "bzinflateInit" : "decompress_init");
Compress::Bzip2 obj
SV *buffer
PROTOTYPE: $$
PPCODE:
{
char *firstp, *outp;
SV *outbuf = NULL;
STRLEN outbufl = 0;
Compress-Deflate7
view release on metacpan or search on metacpan
Deflate7.xs view on Meta::CPAN
unsigned int fb
unsigned int cycles
PREINIT:
STRLEN len;
char* data;
PPCODE:
data = SvPVbyte(sv, len);
mXPUSHs(internalZlib7(data, len, algo, pass, fb, cycles));
void
_deflate7(sv, algo, pass, fb, cycles)
Deflate7.xs view on Meta::CPAN
unsigned int fb
unsigned int cycles
PREINIT:
STRLEN len;
char* data;
PPCODE:
data = SvPVbyte(sv, len);
mXPUSHs(internalDeflate7(data, len, algo, pass, fb, cycles));
Compress-LZF
view release on metacpan or search on metacpan
set_serializer(package, mstore, mretrieve)
SV * package
SV * mstore
SV * mretrieve
PROTOTYPE: $$$
PPCODE:
SvSetSV (serializer_package , package );
SvSetSV (serializer_mstore , mstore );
SvSetSV (serializer_mretrieve, mretrieve);
SvREFCNT_dec (storable_mstore ); storable_mstore = 0;
SvREFCNT_dec (storable_mretrieve); storable_mretrieve = 0;
compress(data)
SV * data
ALIAS:
compress_best = 1
PROTOTYPE: $
PPCODE:
XPUSHs (sv_2mortal (compress_sv (data, 0, MAGIC_U, ix)));
void
decompress(data)
SV * data
PROTOTYPE: $
PPCODE:
XPUSHs (sv_2mortal (decompress_sv (data, 0)));
void
sfreeze(sv)
SV * sv
sfreeze_c = 2
sfreeze_best = 4
sfreeze_cr_best = 5
sfreeze_c_best = 6
PROTOTYPE: $
PPCODE:
{
int best = ix & 4;
ix &= 3;
SvGETMAGIC (sv);
void
sthaw(sv)
SV * sv
PROTOTYPE: $
PPCODE:
{
STRLEN svlen;
int deref = 0;
SvGETMAGIC (sv);
Compress-LZMA-Simple
view release on metacpan or search on metacpan
PREINIT:
STRLEN isiz;
const char *ibuf;
char *obuf;
int osiz;
PPCODE:
sv = (SV *)SvRV(sv);
ibuf = SvPV(sv, isiz);
obuf = lzma_compress(ibuf, (int)isiz, &osiz);
if(obuf){
XPUSHs(newRV_noinc(newSVpvn(obuf, osiz)));
PREINIT:
STRLEN isiz;
const char *ibuf;
char *obuf;
int osiz;
PPCODE:
sv = (SV *)SvRV(sv);
ibuf = SvPV(sv, isiz);
obuf = lzma_decompress(ibuf, (int)isiz, &osiz);
if(obuf){
XPUSHs(newRV_noinc(newSVpvn(obuf, osiz)));
Compress-Raw-Bzip2
view release on metacpan or search on metacpan
const char * className
int appendOut
int blockSize100k
int workfactor
int verbosity
PPCODE:
{
int err ;
deflateStream s ;
#if 0
/* if (trace) */
int appendOut
int consume
int small
int verbosity
int limitOutput
PPCODE:
{
int err = BZ_OK ;
inflateStream s ;
#if 0
if (trace)
Compress-Raw-Lzma
view release on metacpan or search on metacpan
lzma_alone_encoder(Class, flags, bufsize, filters)
const char * Class
int flags
uLong bufsize
AV* filters
PPCODE:
{
lzma_ret err = LZMA_OK;
deflateStream s = NULL;
if ((s = InitStream() )) {
const char * Class
int flags
uLong bufsize
AV* filters
bool forZip
PPCODE:
{
lzma_ret err = LZMA_OK;
deflateStream s = NULL;
if ((s = InitStream() )) {
setupFilters(s, filters, NULL);
const char * Class
int flags
uLong bufsize
AV* filters
lzma_check check
PPCODE:
{
lzma_ret err = LZMA_OK;
deflateStream s = NULL;
if ((s = InitStream() )) {
const char * Class
int flags
int preset
lzma_check check
uLong bufsize
PPCODE:
{
lzma_ret err = LZMA_OK;
deflateStream s = NULL;
if ((s = InitStream())) {
uint64_t memlimit
uLong bufsize
ALIAS:
lzma_stream_decoder = 1
lzma_alone_decoder = 2
PPCODE:
{
int err = LZMA_OK ;
inflateStream s = NULL;
if ((s = InitStream() )) {
if (ix == 0)
const char* Class
int flags
uLong bufsize
AV* filters
const char* properties
PPCODE:
{
int err = LZMA_OK ;
inflateStream s = NULL;
if ((s = InitStream() )) {
Compress-Raw-Zlib
view release on metacpan or search on metacpan
int windowBits
int memLevel
int strategy
uLong bufsize
SV* dictionary
PPCODE:
int err ;
deflateStream s ;
if (trace)
warn("in _deflateInit(level=%d, method=%d, windowBits=%d, memLevel=%d, strategy=%d, bufsize=%ld dictionary=%p)\n",
int windowBits
uLong bufsize
SV * dictionary
ALIAS:
_inflateScanInit = 1
PPCODE:
int err = Z_OK ;
inflateStream s ;
#ifndef MAGIC_APPEND
if (ix == 1)
int method
int windowBits
int memLevel
int strategy
uLong bufsize
PPCODE:
{
#ifndef MAGIC_APPEND
flags = flags;
level = level ;
method = method;
Compress-Stream-Zstd
view release on metacpan or search on metacpan
lib/Compress/Stream/Zstd.xs view on Meta::CPAN
const char* src;
STRLEN src_len;
SV* dest;
char* dst;
size_t bound, ret;
PPCODE:
if (SvROK(source)) {
source = SvRV(source);
}
if (!SvOK(source)) {
XSRETURN_UNDEF;
lib/Compress/Stream/Zstd.xs view on Meta::CPAN
STRLEN src_len;
unsigned long long dest_len;
SV* dest;
char* dst;
size_t ret;
PPCODE:
if (SvROK(source)) {
source = SvRV(source);
}
if (!SvOK(source)) {
XSRETURN_UNDEF;
lib/Compress/Stream/Zstd.xs view on Meta::CPAN
const char* src;
STRLEN src_len;
SV* dest;
char* dst;
size_t bound, ret;
PPCODE:
if (!SvOK(source)) {
XSRETURN_UNDEF;
}
src = SvPVbyte(source, src_len);
bound = ZSTD_compressBound(src_len);
lib/Compress/Stream/Zstd.xs view on Meta::CPAN
const char* src;
STRLEN src_len;
SV* dest;
char* dst;
size_t bound, ret;
PPCODE:
if (!SvOK(source)) {
XSRETURN_UNDEF;
}
src = SvPVbyte(source, src_len);
bound = ZSTD_compressBound(src_len);
lib/Compress/Stream/Zstd.xs view on Meta::CPAN
STRLEN src_len;
unsigned long long dest_len;
SV* dest;
char* dst;
size_t ret;
PPCODE:
if (!SvOK(source)) {
XSRETURN_UNDEF;
}
src = SvPVbyte(source, src_len);
dest_len = ZSTD_getFrameContentSize(src, src_len);
lib/Compress/Stream/Zstd.xs view on Meta::CPAN
STRLEN src_len;
unsigned long long dest_len;
SV* dest;
char* dst;
size_t ret;
PPCODE:
if (!SvOK(source)) {
XSRETURN_UNDEF;
}
src = SvPVbyte(source, src_len);
dest_len = ZSTD_getFrameContentSize(src, src_len);
Compress-Zstd
view release on metacpan or search on metacpan
lib/Compress/Zstd.xs view on Meta::CPAN
const char* src;
STRLEN src_len;
SV* dest;
char* dst;
size_t bound, ret;
PPCODE:
if (SvROK(source)) {
source = SvRV(source);
}
if (!SvOK(source)) {
XSRETURN_UNDEF;
lib/Compress/Zstd.xs view on Meta::CPAN
STRLEN src_len;
SV* dest;
char* dst;
size_t bound, ret;
ZSTDMT_CCtx* cctx;
PPCODE:
if (SvROK(source)) {
source = SvRV(source);
}
if (!SvOK(source)) {
XSRETURN_UNDEF;
lib/Compress/Zstd.xs view on Meta::CPAN
STRLEN src_len;
unsigned long long dest_len;
SV* dest;
char* dst;
size_t ret;
PPCODE:
if (SvROK(source)) {
source = SvRV(source);
}
if (!SvOK(source)) {
XSRETURN_UNDEF;
lib/Compress/Zstd.xs view on Meta::CPAN
const char* src;
STRLEN src_len;
SV* dest;
char* dst;
size_t bound, ret;
PPCODE:
if (!SvOK(source)) {
XSRETURN_UNDEF;
}
src = SvPVbyte(source, src_len);
bound = ZSTD_compressBound(src_len);
lib/Compress/Zstd.xs view on Meta::CPAN
const char* src;
STRLEN src_len;
SV* dest;
char* dst;
size_t bound, ret;
PPCODE:
if (!SvOK(source)) {
XSRETURN_UNDEF;
}
src = SvPVbyte(source, src_len);
bound = ZSTD_compressBound(src_len);
lib/Compress/Zstd.xs view on Meta::CPAN
STRLEN src_len;
unsigned long long dest_len;
SV* dest;
char* dst;
size_t ret;
PPCODE:
if (!SvOK(source)) {
XSRETURN_UNDEF;
}
src = SvPVbyte(source, src_len);
dest_len = ZSTD_getFrameContentSize(src, src_len);
lib/Compress/Zstd.xs view on Meta::CPAN
STRLEN src_len;
unsigned long long dest_len;
SV* dest;
char* dst;
size_t ret;
PPCODE:
if (!SvOK(source)) {
XSRETURN_UNDEF;
}
src = SvPVbyte(source, src_len);
dest_len = ZSTD_getFrameContentSize(src, src_len);
Compress-unLZMA
view release on metacpan or search on metacpan
uncompressdata(content, size, sizeout, properties)
char *content
unsigned int size
unsigned int sizeout
unsigned char *properties
PPCODE:
char sz[800] = { 0 };
Content *pIn, *pOut;
int code = 0;
SV *errsv;
XSRETURN(1);
void
uncompressfile(filename)
char *filename
PPCODE:
char sz[800] = { 0 };
int code = 0;
unsigned int size = 0;
Content *pContent;
SV *errsv;
Config-Augeas
view release on metacpan or search on metacpan
lib/Config/Augeas.xs view on Meta::CPAN
const char* expr
const char* value
PREINIT:
int created ;
int ret ;
PPCODE:
created = 1 ;
ret = aug_defnode(aug, name, expr, value, &created ) ;
if (ret >= 0 ) {
XPUSHs(sv_2mortal(newSVnv(ret)));
XPUSHs(sv_2mortal(newSVnv(created)));
lib/Config/Augeas.xs view on Meta::CPAN
int i ;
int ret ;
int cnt;
char die_msg[1024] ;
char tmp_msg[128];
PPCODE:
cnt = aug_match(aug, pattern, &matches);
if (cnt == -1) {
sprintf(die_msg, "aug_match error with pattern '%s':\n",pattern);
Convert-BER-XS
view release on metacpan or search on metacpan
void
ber_decode (SV *ber, SV *profile = &PL_sv_undef)
ALIAS:
ber_decode_prefix = 1
PPCODE:
{
cur_profile = SvPROFILE (profile);
STRLEN len;
buf = (U8 *)SvPVbyte (ber, len);
cur = buf;
error ("trailing garbage after BER value");
}
void
ber_is (SV *tuple, SV *klass = &PL_sv_undef, SV *tag = &PL_sv_undef, SV *flags = &PL_sv_undef, SV *data = &PL_sv_undef)
PPCODE:
{
if (!SvOK (tuple))
XSRETURN_NO;
if (!SvROK (tuple) || SvTYPE (SvRV (tuple)) != SVt_PVAV)
? &PL_sv_yes : &PL_sv_undef);
}
void
ber_is_seq (SV *tuple)
PPCODE:
{
if (!SvOK (tuple))
XSRETURN_UNDEF;
AV *av = ber_tuple (tuple);
? AvARRAY (av)[BER_DATA] : &PL_sv_undef);
}
void
ber_is_int (SV *tuple, SV *value = &PL_sv_undef)
PPCODE:
{
if (!SvOK (tuple))
XSRETURN_NO;
AV *av = ber_tuple (tuple);
: &PL_sv_undef);
}
void
ber_is_oid (SV *tuple, SV *oid = &PL_sv_undef)
PPCODE:
{
if (!SvOK (tuple))
XSRETURN_NO;
AV *av = ber_tuple (tuple);
#############################################################################
void
ber_encode (SV *tuple, SV *profile = &PL_sv_undef)
PPCODE:
{
cur_profile = SvPROFILE (profile);
buf_sv = sv_2mortal (NEWSV (0, 256));
SvPOK_only (buf_sv);
set_buf (buf_sv);
Convert-Binary-C
view release on metacpan or search on metacpan
xsubs/arg.xs view on Meta::CPAN
CBC::arg(...)
PREINIT:
CBC_METHOD(arg);
int i;
PPCODE:
CT_DEBUG_METHOD;
CHECK_VOID_CONTEXT;
for (i = 1; i < items; i++)
Convert-IBM390
view release on metacpan or search on metacpan
char * instring;
char * outstring_wk;
/* To avoid allocating small amounts of storage: */
char shorty[SHORTY_SIZE];
PPCODE:
instring = SvPV(instring_sv, ilength);
#ifdef DEBUG390
fprintf(stderr, "*D* asc2eb: beginning; length %d\n", ilength);
#endif
if (ilength <= SHORTY_SIZE) {
char * instring;
char * outstring_wk;
/* To avoid allocating small amounts of storage: */
char shorty[SHORTY_SIZE];
PPCODE:
instring = SvPV(instring_sv, ilength);
#ifdef DEBUG390
fprintf(stderr, "*D* eb2asc: beginning; length %d\n", ilength);
#endif
if (ilength <= SHORTY_SIZE) {
char * instring;
char * outstring_wk;
/* To avoid allocating small amounts of storage: */
char shorty[SHORTY_SIZE];
PPCODE:
instring = SvPV(instring_sv, ilength);
#ifdef DEBUG390
fprintf(stderr, "*D* eb2ascp: beginning; length %d\n", ilength);
#endif
if (ilength <= SHORTY_SIZE) {
char *aptr;
double adouble;
/* The eb_work area is long, but what the heck? Memory is cheap. */
char eb_work[32800];
PPCODE:
#ifdef DEBUG390
fprintf(stderr, "*D* packeb: beginning\n");
#endif
ii = 1;
oi = 0;
/*float afloat;*/
double adouble;
/* The eb_work area is long, but what the heck? Memory is cheap. */
char eb_work[32800];
PPCODE:
#ifdef DEBUG390
fprintf(stderr, "*D* unpackeb: beginning\n");
#endif
s = sbegin = SvPV(ebrecord, rlen);
strend = s + rlen;
Convert-Scalar
view release on metacpan or search on metacpan
OUTPUT:
RETVAL
void
utf8_on (SV *scalar)
PPCODE:
if (SvREADONLY (scalar))
croak ("Convert::Scalar::utf8_on called on read only scalar");
SvGETMAGIC (scalar);
SvUTF8_on (scalar);
RETCOPY (scalar);
void
utf8_off (SV *scalar)
PPCODE:
if (SvREADONLY (scalar))
croak ("Convert::Scalar::utf8_off called on read only scalar");
SvGETMAGIC (scalar);
SvUTF8_off (scalar);
OUTPUT:
RETVAL
void
utf8_upgrade (SV *scalar)
PPCODE:
if (SvREADONLY (scalar))
croak ("Convert::Scalar::utf8_upgrade called on read only scalar");
sv_utf8_upgrade(scalar);
RETCOPY (scalar);
OUTPUT:
RETVAL
void
utf8_encode (SV *scalar)
PPCODE:
if (SvREADONLY (scalar))
croak ("Convert::Scalar::utf8_encode called on read only scalar");
sv_utf8_encode (scalar);
RETCOPY (scalar);
OUTPUT:
RETVAL
void
grow (SV *scalar, STRLEN newlen)
PPCODE:
sv_grow (scalar, newlen);
if (GIMME_V != G_VOID)
XPUSHs (sv_2mortal (SvREFCNT_inc (scalar)));
void
extend (SV *scalar, STRLEN addlen = 64)
PPCODE:
{
extend (scalar, addlen);
if (GIMME_V != G_VOID)
XPUSHs (sv_2mortal (SvREFCNT_inc (scalar)));
Convert-UUlib
view release on metacpan or search on metacpan
UULoadFile (fname, id = 0, delflag = 0, partno = -1)
char * fname
char * id
int delflag
int partno
PPCODE:
{
int count;
IV ret;
RELEASE;
UUGetFileListItem (num)
int num
void
GetFileList ()
PPCODE:
{
uulist *iter;
for (iter = UUGlobalFileList; iter; iter = iter->NEXT)
XPUSHs (sv_setref_pv (sv_newmortal (), "Convert::UUlib::Item", iter));
# methods accessing internal data(!)
void
parts (li)
uulist *li
PPCODE:
{
struct _uufile *p = li->thisfile;
while (p)
{
CookBookA
view release on metacpan or search on metacpan
void
set_blue( self , val )
ex1_struct *self
int val
PPCODE:
self->blue = val;
char *
red(self)
ex1_struct *self
void
set_red(self,val)
ex1_struct *self
char *val
PPCODE:
strcpy( self->red, val );
MODULE = CookBookA::Ex1 PACKAGE = CookBookA::Ex1B
Coro-Mysql
view release on metacpan or search on metacpan
PROTOTYPES: ENABLE
void
_use_ev ()
PPCODE:
{
static int onceonly;
if (!onceonly)
{
Coro
view release on metacpan or search on metacpan
Coro/State.xs view on Meta::CPAN
RETVAL
void
list ()
PROTOTYPE:
PPCODE:
{
struct coro *coro;
for (coro = coro_first; coro; coro = coro->next)
if (coro->hv)
XPUSHs (sv_2mortal (newRV_inc ((SV *)coro->hv)));
Coro/State.xs view on Meta::CPAN
OUTPUT:
RETVAL
void
times (Coro::State self)
PPCODE:
{
struct coro *current = SvSTATE (coro_current);
if (ecb_expect_false (current == self))
{
Coro/State.xs view on Meta::CPAN
CORO_EXECUTE_SLF_XS (slf_init_pool_handler);
void
async_pool (SV *cv, ...)
PROTOTYPE: &@
PPCODE:
{
HV *hv = (HV *)av_pop (av_async_pool);
AV *av = newAV ();
SV *cb = ST (0);
int i;
Coro/State.xs view on Meta::CPAN
RETVAL
void
rouse_wait (...)
PROTOTYPE: ;$
PPCODE:
CORO_EXECUTE_SLF_XS (slf_init_rouse_wait);
void
on_enter (SV *block)
ALIAS:
Coro/State.xs view on Meta::CPAN
CODE:
CORO_EXECUTE_SLF_XS (slf_init_semaphore_wait);
void
try (SV *self)
PPCODE:
{
AV *av = (AV *)SvRV (self);
SV *count_sv = AvARRAY (av)[0];
IV count = SvIVX (count_sv);
Coro/State.xs view on Meta::CPAN
XSRETURN_NO;
}
void
waiters (SV *self)
PPCODE:
{
AV *av = (AV *)SvRV (self);
int wcount = AvFILLp (av) + 1 - 1;
if (GIMME_V == G_SCALAR)
Coro/State.xs view on Meta::CPAN
MODULE = Coro::State PACKAGE = Coro::SemaphoreSet
void
_may_delete (SV *sem, int count, unsigned int extra_refs)
PPCODE:
{
AV *av = (AV *)SvRV (sem);
if (SvREFCNT ((SV *)av) == 1 + extra_refs
&& AvFILLp (av) == 0 /* no waiters, just count */
Coro/State.xs view on Meta::CPAN
OUTPUT:
RETVAL
NV
gettimeofday ()
PPCODE:
{
UV tv [2];
u2time (aTHX_ tv);
EXTEND (SP, 2);
PUSHs (sv_2mortal (newSVuv (tv [0])));
Cpanel-JSON-XS
view release on metacpan or search on metacpan
# called
#ifdef USE_ITHREADS
void CLONE (...)
PPCODE:
MY_CXT_CLONE; /* possible declaration */
init_MY_CXT(aTHX_ &MY_CXT);
/* skip implicit PUTBACK, returning @_ to caller, more efficient*/
return;
void END(...)
PREINIT:
dMY_CXT;
SV * sv;
PPCODE:
sv = MY_CXT.sv_json;
MY_CXT.sv_json = NULL;
if (sv && SvOK (sv))
SvREFCNT_dec_NN (sv);
/* skip implicit PUTBACK, returning @_ to caller, more efficient*/
return;
void new (char *klass)
PREINIT:
HV *stash;
PPCODE:
dMY_CXT;
SV *pv = NEWSV (0, sizeof (JSON));
SvPOK_only (pv);
json_init ((JSON *)SvPVX (pv));
if (SvROK (ST(0))) {
unblessed_bool = F_UNBLESSED_BOOL
allow_dupkeys = F_ALLOW_DUPKEYS
require_types = F_REQUIRE_TYPES
type_all_string = F_TYPE_ALL_STRING
dupkeys_as_arrayref = F_DUPKEYS_AS_AREF
PPCODE:
if (enable)
self->flags |= ix;
else
self->flags &= ~ix;
# Turning on DUPKEYS_AS_AREF also turns on ALLOW_DUPKEYS
get_unblessed_bool = F_UNBLESSED_BOOL
get_allow_dupkeys = F_ALLOW_DUPKEYS
get_require_types = F_REQUIRE_TYPES
get_type_all_string = F_TYPE_ALL_STRING
get_dupkeys_as_arrayref = F_DUPKEYS_AS_AREF
PPCODE:
XPUSHs (boolSV (self->flags & ix));
void indent_length (JSON *self, int val = INDENT_STEP)
PPCODE:
if (0 <= val && val <= 15) {
self->indent_length = val;
} else {
warn("The acceptable range of indent_length() is 0 to 15.");
}
RETVAL = self->indent_length;
OUTPUT:
RETVAL
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 stringify_infnan (JSON *self, IV infnan_mode = 1)
PPCODE:
if (infnan_mode > 3 || infnan_mode < 0) {
croak ("invalid stringify_infnan mode %d. Must be 0, 1, 2 or 3", (int)infnan_mode);
}
self->infnan_mode = (unsigned char)infnan_mode;
XPUSHs (ST (0));
RETVAL = (int)self->infnan_mode;
OUTPUT:
RETVAL
void sort_by (JSON *self, SV* cb = &PL_sv_yes)
PPCODE:
{
SvREFCNT_dec (self->cb_sort_by);
self->cb_sort_by = SvOK (cb) ? newSVsv (cb) : 0;
if (self->cb_sort_by)
self->flags |= F_CANONICAL;
XPUSHs (ST (0));
}
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, SV *typesv = &PL_sv_undef)
PPCODE:
PUTBACK; scalar = encode_json (aTHX_ scalar, self, typesv); SPAGAIN;
XPUSHs (scalar);
void decode (JSON *self, SV *jsonstr, SV *typesv = NULL)
PPCODE:
PUTBACK; jsonstr = decode_json (aTHX_ jsonstr, self, 0, typesv); SPAGAIN;
XPUSHs (jsonstr);
void decode_prefix (JSON *self, SV *jsonstr, SV *typesv = NULL)
PPCODE:
{
SV *sv;
STRLEN offset;
PUTBACK; sv = decode_json (aTHX_ jsonstr, self, &offset, typesv); SPAGAIN;
EXTEND (SP, 2);
PUSHs (sv);
PUSHs (sv_2mortal (newSVuv (ptr_to_index (aTHX_ 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 */
#if PERL_VERSION > 6
SV *incr_text (JSON *self)
ATTRS: lvalue
PPCODE:
{
PERL_UNUSED_VAR(RETVAL);
if (UNLIKELY(self->incr_pos))
{
/* We might want to return a copy of the rest.
}
#else
SV *incr_text (JSON *self)
PPCODE:
{
if (UNLIKELY(self->incr_pos))
croak ("incr_text can not be called when the incremental parser already started parsing");
ST(0) = self->incr_text ? self->incr_text : &PL_sv_undef;
void encode_json (SV *scalar, SV *typesv = &PL_sv_undef)
ALIAS:
_to_json = 0
encode_json = F_UTF8
PPCODE:
{
JSON json;
json_init (&json);
json.flags |= ix;
PUTBACK; scalar = encode_json (aTHX_ scalar, &json, typesv); SPAGAIN;
void decode_json (SV *jsonstr, SV *allow_nonref = NULL, SV *typesv = NULL)
ALIAS:
_from_json = 0
decode_json = F_UTF8
PPCODE:
{
JSON json;
json_init (&json);
json.flags |= ix;
if (items > 1) {
Crypt-ARIA
view release on metacpan or search on metacpan
const Byte * mk
int keybits
PREINIT:
int round;
Byte rkey[16*17];
PPCODE:
round = EncKeySetup(mk, rkey, keybits);
XPUSHs( sv_2mortal(newSVnv(round)) );
XPUSHs( sv_2mortal(newSVpvn((const char *)rkey, 16*17*sizeof(Byte))) );
void
const Byte * mk
int keybits
PREINIT:
int round;
Byte rkey[16*17];
PPCODE:
round = DecKeySetup(mk, rkey, keybits);
XPUSHs( sv_2mortal(newSVnv(round)) );
XPUSHs( sv_2mortal(newSVpvn((const char *)rkey, 16*17*sizeof(Byte))) );
Crypt-Bear
view release on metacpan or search on metacpan
lib/Crypt/Bear.xs view on Meta::CPAN
ec_default = br_ec_get_default();
ec_sign_default = br_ecdsa_sign_asn1_get_default();
ec_verify_default = br_ecdsa_vrfy_asn1_get_default();
void br_ec_supported_curves(class)
PPCODE:
for (UV i = 0; i < 31; i++) {
if (ec_default->supported_curves & (1 << i)) {
union value value = { .integer = i };
const entry* entry = map_reverse_find(curves, value);
mXPUSHp(entry->key, entry->length);
lib/Crypt/Bear.xs view on Meta::CPAN
OUTPUT:
RETVAL
SV* br_pem_pem_decode(const char* data, size_t length(data))
PPCODE:
pem_decoder decoder;
br_pem_decoder_init(&decoder.decoder);
#ifdef MULTIPLICITY
decoder.aTHX = aTHX;
#endif
lib/Crypt/Bear.xs view on Meta::CPAN
x509_key_copy(&anchor.pkey, &old->pkey);
trust_anchors_push(self, &anchor);
}
void br_x509_trust_anchors_names(Crypt::Bear::X509::TrustAnchors self)
PPCODE:
for (size_t i = 0; i < self->used; i++) {
const br_x509_trust_anchor* anchor = self->array + i;
mXPUSHp((const char*)anchor->dn.data, anchor->dn.len);
}
lib/Crypt/Bear.xs view on Meta::CPAN
}
OUTPUT:
RETVAL
void br_ssl_server_get_client_suites(Crypt::Bear::SSL::Server self)
PPCODE:
size_t len;
const br_suite_translated* suites = br_ssl_server_get_client_suites(&self->context, &len);
for (size_t i = 0; i < len; i++) {
AV* pair = newAV();
av_push(pair, newSVuv(suites[i][0]));
Crypt-Digest-Scrypt
view release on metacpan or search on metacpan
MODULE = Crypt::Digest::Scrypt PACKAGE = Crypt::Digest::Scrypt
PROTOTYPES: DISABLE
void scrypt_1024_1_1_256(SV *svdata)
PPCODE:
{
char hash[32];
STRLEN len;
const char *data = (const char *)SvPV(svdata, len);
scrypt_1024_1_1_256(data, len, hash);
Crypt-Ed25519
view release on metacpan or search on metacpan
void
generate_keypair (SV *secret = 0)
ALIAS:
eddsa_public_key = 1
PPCODE:
{
STRLEN secret_l; char *secret_p;
unsigned char seed[32];
unsigned char public_key[32];
( run in 1.244 second using v1.01-cache-2.11-cpan-71847e10f99 )