Chandra
view release on metacpan or search on metacpan
}
OUTPUT:
RETVAL
# ---- _match_route($path) - returns ($handler, %params) or () ----
void
_match_route(self, path_sv)
SV *self
SV *path_sv
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **routes_svp = hv_fetchs(hv, "_routes", 0);
const char *path;
STRLEN path_len;
AV *path_parts;
I32 path_count;
path = SvPV(path_sv, path_len);
}
}
OUTPUT:
RETVAL
# ---- windows() - return all child windows ----
void
windows(self)
SV *self
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **arr_svp = hv_fetchs(hv, "_windows", 0);
if (arr_svp && SvROK(*arr_svp)) {
AV *arr = (AV *)SvRV(*arr_svp);
I32 len = av_len(arr) + 1;
I32 i;
for (i = 0; i < len; i++) {
SV **elem = av_fetch(arr, i, 0);
splash_done: ;
}
OUTPUT:
RETVAL
void
extend_bridge(self, name, source, ...)
SV *self
const char *name
const char *source
PPCODE:
{
char **deps = NULL;
int dep_count = 0;
int i;
PERL_UNUSED_VAR(self);
/* parse optional depends => [...] */
if (items > 3 && (items - 3) % 2 == 0) {
for (i = 3; i < items; i += 2) {
xs/assets.xs view on Meta::CPAN
}
PUTBACK; FREETMPS; LEAVE;
}
}
OUTPUT:
RETVAL
void
list(self, ...)
SV *self
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **root_svp = hv_fetchs(hv, "root", 0);
SV *pattern_sv = (items > 1 && SvOK(ST(1))) ? ST(1) : NULL;
AV *result_av = NULL;
if (!root_svp || !SvOK(*root_svp)) XSRETURN(0);
/* Call File::Raw::readdir($root) - capture result before returning to our stack */
{
STRLEN nlen;
const char *nstr = SvPV(name, nlen);
RETVAL = hv_exists(reg, nstr, (I32)nlen);
}
OUTPUT:
RETVAL
void
list(self)
SV *self
PPCODE:
{
PERL_UNUSED_VAR(self);
HV *reg = _bind_get_registry(aTHX);
I32 num = hv_iterinit(reg);
HE *entry;
EXTEND(SP, num);
while ((entry = hv_iternext(reg)) != NULL) {
PUSHs(sv_2mortal(newSVsv(hv_iterkeysv(entry))));
}
}
xs/bridge_extension.xs view on Meta::CPAN
MODULE = Chandra PACKAGE = Chandra::Bridge::Extension
PROTOTYPES: DISABLE
void
register(klass, name, source, ...)
SV *klass
const char *name
const char *source
PPCODE:
{
char **deps = NULL;
int dep_count = 0;
int i;
STRLEN len;
PERL_UNUSED_VAR(klass);
/* parse optional depends => [...] */
if (items > 3 && (items - 3) % 2 == 0) {
xs/bridge_extension.xs view on Meta::CPAN
}
XSRETURN(1);
}
void
register_file(klass, name, path, ...)
SV *klass
const char *name
const char *path
PPCODE:
{
SV *contents;
STRLEN len;
const char *src;
PerlIO *fh;
PERL_UNUSED_VAR(klass);
fh = PerlIO_open(path, "r");
if (!fh)
xs/bridge_extension.xs view on Meta::CPAN
}
SvREFCNT_dec(contents);
XSRETURN(1);
}
void
unregister(klass, name)
SV *klass
const char *name
PPCODE:
{
PERL_UNUSED_VAR(klass);
if (chandra_ext_unregister(name))
XSRETURN_YES;
else
XSRETURN_NO;
}
void
is_registered(klass, name)
SV *klass
const char *name
PPCODE:
{
PERL_UNUSED_VAR(klass);
if (chandra_ext_is_registered(name))
XSRETURN_YES;
else
XSRETURN_NO;
}
SV *
source(klass, name)
xs/bridge_extension.xs view on Meta::CPAN
RETVAL = newSVpv(src, 0);
else
RETVAL = &PL_sv_undef;
}
OUTPUT:
RETVAL
void
list(klass)
SV *klass
PPCODE:
{
int *order;
int count, i;
const char *err = NULL;
PERL_UNUSED_VAR(klass);
if (_ext_count == 0)
XSRETURN_EMPTY;
xs/bridge_extension.xs view on Meta::CPAN
EXTEND(SP, count);
for (i = 0; i < count; i++) {
PUSHs(sv_2mortal(newSVpv(_ext_list[order[i]].name, 0)));
}
Safefree(order);
}
void
clear(klass)
SV *klass
PPCODE:
{
PERL_UNUSED_VAR(klass);
chandra_ext_clear();
XSRETURN(1);
}
SV *
generate_js(klass)
SV *klass
CODE:
xs/canvas.xs view on Meta::CPAN
RETVAL
# ========================================================================
# Style Methods
# ========================================================================
void
fill_style(self, color)
SV *self
const char *color
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_1s(aTHX_ buf, CANVAS_OP_FILL_STYLE, color);
XPUSHs(self);
}
void
stroke_style(self, color)
SV *self
const char *color
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_1s(aTHX_ buf, CANVAS_OP_STROKE_STYLE, color);
XPUSHs(self);
}
void
line_width(self, width)
SV *self
NV width
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_1nv(aTHX_ buf, CANVAS_OP_LINE_WIDTH, width);
XPUSHs(self);
}
void
global_alpha(self, alpha)
SV *self
NV alpha
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_1nv(aTHX_ buf, CANVAS_OP_GLOBAL_ALPHA, alpha);
XPUSHs(self);
}
void
line_cap(self, cap)
SV *self
const char *cap
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_1s(aTHX_ buf, CANVAS_OP_LINE_CAP, cap);
XPUSHs(self);
}
void
line_join(self, join)
SV *self
const char *join
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_1s(aTHX_ buf, CANVAS_OP_LINE_JOIN, join);
XPUSHs(self);
}
# ========================================================================
# Drawing Methods
# ========================================================================
void
clear(self)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_0(aTHX_ buf, CANVAS_OP_CLEAR);
XPUSHs(self);
}
void
fill_rect(self, x, y, w, h)
SV *self
NV x
NV y
NV w
NV h
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_4nv(aTHX_ buf, CANVAS_OP_FILL_RECT, x, y, w, h);
XPUSHs(self);
}
void
stroke_rect(self, x, y, w, h)
SV *self
NV x
NV y
NV w
NV h
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_4nv(aTHX_ buf, CANVAS_OP_STROKE_RECT, x, y, w, h);
XPUSHs(self);
}
void
clear_rect(self, x, y, w, h)
SV *self
NV x
NV y
NV w
NV h
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_4nv(aTHX_ buf, CANVAS_OP_CLEAR_RECT, x, y, w, h);
XPUSHs(self);
}
void
fill_circle(self, x, y, r)
SV *self
NV x
NV y
NV r
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_3nv(aTHX_ buf, CANVAS_OP_FILL_CIRCLE, x, y, r);
XPUSHs(self);
}
void
stroke_circle(self, x, y, r)
SV *self
NV x
NV y
NV r
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_3nv(aTHX_ buf, CANVAS_OP_STROKE_CIRCLE, x, y, r);
XPUSHs(self);
}
# ========================================================================
# Path Methods
# ========================================================================
void
begin_path(self)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_0(aTHX_ buf, CANVAS_OP_BEGIN_PATH);
XPUSHs(self);
}
void
close_path(self)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_0(aTHX_ buf, CANVAS_OP_CLOSE_PATH);
XPUSHs(self);
}
void
move_to(self, x, y)
SV *self
NV x
NV y
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_2nv(aTHX_ buf, CANVAS_OP_MOVE_TO, x, y);
XPUSHs(self);
}
void
line_to(self, x, y)
SV *self
NV x
NV y
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_2nv(aTHX_ buf, CANVAS_OP_LINE_TO, x, y);
XPUSHs(self);
}
void
arc(self, x, y, r, start_angle, end_angle, ...)
SV *self
NV x
NV y
NV r
NV start_angle
NV end_angle
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
NV ccw = (items > 6 && SvTRUE(ST(6))) ? 1 : 0;
_canvas_push_op_6nv(aTHX_ buf, CANVAS_OP_ARC, x, y, r, start_angle, end_angle, ccw);
XPUSHs(self);
}
void
rect(self, x, y, w, h)
SV *self
NV x
NV y
NV w
NV h
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_4nv(aTHX_ buf, CANVAS_OP_RECT, x, y, w, h);
XPUSHs(self);
}
void
fill(self)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_0(aTHX_ buf, CANVAS_OP_FILL);
XPUSHs(self);
}
void
stroke(self)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_0(aTHX_ buf, CANVAS_OP_STROKE);
XPUSHs(self);
}
# ========================================================================
# State Methods
# ========================================================================
void
save(self)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_0(aTHX_ buf, CANVAS_OP_SAVE);
XPUSHs(self);
}
void
restore(self)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_0(aTHX_ buf, CANVAS_OP_RESTORE);
XPUSHs(self);
}
# ========================================================================
# Transform Methods
# ========================================================================
void
translate(self, x, y)
SV *self
NV x
NV y
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_2nv(aTHX_ buf, CANVAS_OP_TRANSLATE, x, y);
XPUSHs(self);
}
void
rotate(self, angle)
SV *self
NV angle
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_1nv(aTHX_ buf, CANVAS_OP_ROTATE, angle);
XPUSHs(self);
}
void
scale(self, x, y)
SV *self
NV x
NV y
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_2nv(aTHX_ buf, CANVAS_OP_SCALE, x, y);
XPUSHs(self);
}
# ========================================================================
# Phase 2: Advanced Path Methods
# ========================================================================
void
arc_to(self, x1, y1, x2, y2, radius)
SV *self
NV x1
NV y1
NV x2
NV y2
NV radius
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_5nv(aTHX_ buf, CANVAS_OP_ARC_TO, x1, y1, x2, y2, radius);
XPUSHs(self);
}
void
bezier_curve_to(self, cp1x, cp1y, cp2x, cp2y, x, y)
SV *self
NV cp1x
NV cp1y
NV cp2x
NV cp2y
NV x
NV y
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_6nv(aTHX_ buf, CANVAS_OP_BEZIER_CURVE_TO, cp1x, cp1y, cp2x, cp2y, x, y);
XPUSHs(self);
}
void
quadratic_curve_to(self, cpx, cpy, x, y)
SV *self
NV cpx
NV cpy
NV x
NV y
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_4nv(aTHX_ buf, CANVAS_OP_QUADRATIC_CURVE_TO, cpx, cpy, x, y);
XPUSHs(self);
}
void
clip(self, ...)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
AV *cmd = newAV();
av_push(cmd, newSViv(CANVAS_OP_CLIP));
/* Optional fill rule: 'nonzero' (default) or 'evenodd' */
if (items > 1 && SvOK(ST(1))) {
av_push(cmd, newSVsv(ST(1)));
}
av_push(buf, newRV_noinc((SV *)cmd));
xs/canvas.xs view on Meta::CPAN
void
transform(self, a, b, c, d, e, f)
SV *self
NV a
NV b
NV c
NV d
NV e
NV f
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_6nv(aTHX_ buf, CANVAS_OP_TRANSFORM, a, b, c, d, e, f);
XPUSHs(self);
}
void
set_transform(self, a, b, c, d, e, f)
SV *self
NV a
NV b
NV c
NV d
NV e
NV f
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_6nv(aTHX_ buf, CANVAS_OP_SET_TRANSFORM, a, b, c, d, e, f);
XPUSHs(self);
}
void
reset_transform(self)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_0(aTHX_ buf, CANVAS_OP_RESET_TRANSFORM);
XPUSHs(self);
}
void
miter_limit(self, limit)
SV *self
NV limit
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_1nv(aTHX_ buf, CANVAS_OP_MITER_LIMIT, limit);
XPUSHs(self);
}
void
global_composite_operation(self, op)
SV *self
const char *op
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_1s(aTHX_ buf, CANVAS_OP_GLOBAL_COMP_OP, op);
XPUSHs(self);
}
# ========================================================================
# Phase 2: Convenience Shape Methods
# ========================================================================
void
line(self, x1, y1, x2, y2)
SV *self
NV x1
NV y1
NV x2
NV y2
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_4nv(aTHX_ buf, CANVAS_OP_LINE, x1, y1, x2, y2);
XPUSHs(self);
}
void
rounded_rect(self, x, y, w, h, radius)
SV *self
NV x
NV y
NV w
NV h
NV radius
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_5nv(aTHX_ buf, CANVAS_OP_ROUNDED_RECT, x, y, w, h, radius);
XPUSHs(self);
}
void
fill_rounded_rect(self, x, y, w, h, radius)
SV *self
NV x
NV y
NV w
NV h
NV radius
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
_canvas_push_op_5nv(aTHX_ buf, CANVAS_OP_FILL_ROUNDED_RECT, x, y, w, h, radius);
XPUSHs(self);
}
void
polygon(self, points_av)
SV *self
SV *points_av
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
AV *points;
SSize_t len, i;
if (!SvROK(points_av) || SvTYPE(SvRV(points_av)) != SVt_PVAV)
croak("polygon requires arrayref of [x,y] pairs");
points = (AV *)SvRV(points_av);
xs/canvas.xs view on Meta::CPAN
_canvas_push_op_0(aTHX_ buf, CANVAS_OP_CLOSE_PATH);
_canvas_push_op_0(aTHX_ buf, CANVAS_OP_STROKE);
XPUSHs(self);
}
void
fill_polygon(self, points_av)
SV *self
SV *points_av
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
AV *buf = _canvas_get_buffer(aTHX_ self_hv);
AV *points;
SSize_t len, i;
if (!SvROK(points_av) || SvTYPE(SvRV(points_av)) != SVt_PVAV)
croak("fill_polygon requires arrayref of [x,y] pairs");
points = (AV *)SvRV(points_av);
xs/canvas.xs view on Meta::CPAN
{
HV *self_hv = (HV *)SvRV(self);
RETVAL = _canvas_serialize_buffer(aTHX_ self_hv);
}
OUTPUT:
RETVAL
void
_clear_buffer(self)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
_canvas_clear_buffer(aTHX_ self_hv);
XPUSHs(self);
}
SV *
render(self)
SV *self
CODE:
{
HV *self_hv = (HV *)SvRV(self);
RETVAL = _canvas_gen_html(aTHX_ self_hv);
}
OUTPUT:
RETVAL
void
flush(self)
SV *self
PPCODE:
{
HV *self_hv = (HV *)SvRV(self);
SV *js = _canvas_serialize_buffer(aTHX_ self_hv);
/* Call Chandra::eval_js if available */
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVpvs("Chandra")));
xs/contextmenu.xs view on Meta::CPAN
RETVAL = SvREFCNT_inc(*items_svp);
}
OUTPUT:
RETVAL
# ---- attachments() - return list of attached selectors ----
void
attachments(self)
SV *self
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **att_svp = hv_fetchs(hv, "_attachments", 0);
HV *att_hv = (HV *)SvRV(*att_svp);
HE *entry;
hv_iterinit(att_hv);
while ((entry = hv_iternext(att_hv)) != NULL) {
I32 klen;
const char *key = hv_iterkey(entry, &klen);
xs/dragdrop.xs view on Meta::CPAN
RETVAL = SvREFCNT_inc(self);
}
OUTPUT:
RETVAL
# ---- drop_zones() - list registered selectors ----
void
drop_zones(self)
SV *self
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **dz_svp = hv_fetchs(hv, "_drop_zones", 0);
HV *zones = (HV *)SvRV(*dz_svp);
HE *entry;
hv_iterinit(zones);
while ((entry = hv_iternext(zones)) != NULL) {
I32 klen;
const char *key = hv_iterkey(entry, &klen);
XPUSHs(sv_2mortal(newSVpvn(key, klen)));
xs/element.xs view on Meta::CPAN
av_push(children, SvREFCNT_inc(child));
RETVAL = SvREFCNT_inc(child);
}
}
OUTPUT:
RETVAL
void
children(self)
SV *self
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **ch_svp = hv_fetchs(hv, "children", 0);
if (ch_svp && *ch_svp && SvROK(*ch_svp) &&
SvTYPE(SvRV(*ch_svp)) == SVt_PVAV) {
AV *children = (AV *)SvRV(*ch_svp);
SSize_t i, len = av_len(children) + 1;
if (GIMME_V == G_SCALAR) {
XPUSHs(sv_2mortal(newSViv(len)));
} else {
xs/element.xs view on Meta::CPAN
SV *found = _elem_find_by_tag(aTHX_ self, target_tag);
RETVAL = found ? SvREFCNT_inc(found) : &PL_sv_undef;
}
OUTPUT:
RETVAL
void
get_elements_by_class(self, target_class)
SV *self
const char *target_class
PPCODE:
{
AV *results = newAV();
STRLEN tlen = strlen(target_class);
SSize_t i, len;
_elem_collect_by_class(aTHX_ self, target_class, tlen, results);
len = av_len(results) + 1;
EXTEND(SP, len);
for (i = 0; i < len; i++) {
xs/hotreload.xs view on Meta::CPAN
HV *hv = (HV *)SvRV(self);
(void)hv_stores(hv, "watches", newRV_noinc((SV *)newAV()));
RETVAL = SvREFCNT_inc(self);
}
OUTPUT:
RETVAL
void
watched_paths(self)
SV *self
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **watches_svp = hv_fetchs(hv, "watches", 0);
AV *watches_av = (AV *)SvRV(*watches_svp);
I32 i, len = av_len(watches_av) + 1;
if (GIMME_V == G_SCALAR) {
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSViv(len)));
} else {
xs/protocol.xs view on Meta::CPAN
}
RETVAL = SvREFCNT_inc(self);
}
OUTPUT:
RETVAL
void
schemes(self)
SV *self
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **protocols_svp;
protocols_svp = hv_fetchs(hv, "protocols", 0);
if (protocols_svp && SvROK(*protocols_svp)) {
HV *protocols_hv = (HV *)SvRV(*protocols_svp);
I32 num_keys = hv_iterinit(protocols_hv);
if (GIMME_V == G_SCALAR) {
xs/shortcut.xs view on Meta::CPAN
RETVAL = SvREFCNT_inc(self);
}
OUTPUT:
RETVAL
# ---- list() - return array of hashrefs ----
void
list(self)
SV *self
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **bindings_svp;
bindings_svp = hv_fetchs(hv, "bindings", 0);
if (bindings_svp && SvROK(*bindings_svp)) {
HV *bindings_hv = (HV *)SvRV(*bindings_svp);
HE *entry;
hv_iterinit(bindings_hv);
xs/socket_connection.xs view on Meta::CPAN
}
}
}
}
OUTPUT:
RETVAL
void
recv(self)
SV *self
PPCODE:
{
/* Delegate entirely to Perl helper _xs_do_recv which handles
sysread, buffering, frame decoding, and returns a list of msgs */
int count, i;
SV **results;
{
dSP;
ENTER;
SAVETMPS;
xs/socket_connection.xs view on Meta::CPAN
Newx(results, count, SV *);
for (i = count - 1; i >= 0; i--) {
results[i] = newSVsv(POPs);
}
}
PUTBACK;
FREETMPS;
LEAVE;
}
/* Now push saved results onto the PPCODE return stack */
for (i = 0; i < count; i++) {
XPUSHs(sv_2mortal(results[i]));
}
if (count > 0) Safefree(results);
}
void
close(self)
SV *self
CODE:
xs/socket_connection.xs view on Meta::CPAN
SvREFCNT_dec(json_sv);
}
OUTPUT:
RETVAL
void
decode_frames(class, data_sv)
SV *class
SV *data_sv
PPCODE:
{
AV *result = newAV();
I32 ri, result_count;
if (SvOK(data_sv)) {
const char *buf;
STRLEN buf_len;
STRLEN consumed = 0;
buf = SvPV(data_sv, buf_len);
xs/socket_connection.xs view on Meta::CPAN
}
SvREFCNT_dec(frame);
}
OUTPUT:
RETVAL
void
_xs_do_recv(self)
SV *self
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **connected_svp = hv_fetchs(hv, "_connected", 0);
SV **sock_svp = hv_fetchs(hv, "socket", 0);
SV **buf_svp;
AV *messages = newAV();
I32 mi, msg_count;
if (!connected_svp || !SvTRUE(*connected_svp) ||
!sock_svp || !SvOK(*sock_svp)) {
xs/socket_hub.xs view on Meta::CPAN
} else {
RETVAL = newSViv(0);
}
}
OUTPUT:
RETVAL
void
clients(self)
SV *self
PPCODE:
{
HV *hv = (HV *)SvRV(self);
SV **clients_svp = hv_fetchs(hv, "_clients", 0);
if (clients_svp && SvROK(*clients_svp)) {
HV *clients = (HV *)SvRV(*clients_svp);
I32 num_keys = hv_iterinit(clients);
if (GIMME_V == G_SCALAR) {
mXPUSHi(num_keys);
XSRETURN(1);
} else {
xs/window.xs view on Meta::CPAN
OUTPUT:
RETVAL
void
get_size(self)
SV *self
PREINIT:
HV *hv;
SV **svp;
int width = 0, height = 0;
PPCODE:
if (!SvROK(self) || SvTYPE(SvRV(self)) != SVt_PVHV)
croak("Not a Chandra::Window object");
hv = (HV*)SvRV(self);
svp = hv_fetch(hv, "width", 5, 0);
if (svp && SvIOK(*svp)) width = SvIV(*svp);
svp = hv_fetch(hv, "height", 6, 0);
if (svp && SvIOK(*svp)) height = SvIV(*svp);
EXTEND(SP, 2);
PUSHs(sv_2mortal(newSViv(width)));
PUSHs(sv_2mortal(newSViv(height)));
void
get_position(self)
SV *self
PREINIT:
HV *hv;
SV **svp;
int x = 0, y = 0;
PPCODE:
if (!SvROK(self) || SvTYPE(SvRV(self)) != SVt_PVHV)
croak("Not a Chandra::Window object");
hv = (HV*)SvRV(self);
svp = hv_fetch(hv, "x", 1, 0);
if (svp && SvIOK(*svp)) x = SvIV(*svp);
svp = hv_fetch(hv, "y", 1, 0);
if (svp && SvIOK(*svp)) y = SvIV(*svp);
EXTEND(SP, 2);
PUSHs(sv_2mortal(newSViv(x)));
PUSHs(sv_2mortal(newSViv(y)));
xs/window.xs view on Meta::CPAN
RETVAL = SvREFCNT_inc(self);
OUTPUT:
RETVAL
void
windows(class)
const char *class
PREINIT:
HE *entry;
PPCODE:
PERL_UNUSED_VAR(class);
ENSURE_REGISTRY();
hv_iterinit(_window_registry);
while ((entry = hv_iternext(_window_registry))) {
SV *val = hv_iterval(_window_registry, entry);
if (val && SvOK(val)) {
XPUSHs(sv_2mortal(SvREFCNT_inc(val)));
}
}
xs/window.xs view on Meta::CPAN
RETVAL
void
children(self)
SV *self
PREINIT:
HV *hv;
SV **svp;
AV *children_av;
int i, len;
PPCODE:
if (!SvROK(self) || SvTYPE(SvRV(self)) != SVt_PVHV)
croak("Not a Chandra::Window object");
hv = (HV*)SvRV(self);
svp = hv_fetch(hv, "_children", 9, 0);
if (svp && SvROK(*svp)) {
children_av = (AV*)SvRV(*svp);
len = av_len(children_av) + 1;
EXTEND(SP, len);
for (i = 0; i < len; i++) {
SV **child = av_fetch(children_av, i, 0);
( run in 2.051 seconds using v1.01-cache-2.11-cpan-71847e10f99 )