static int CsvGet(csv_t* csv, SV* src) {
if (!csv->useIO) {
return EOF;
}
{
int result;
dSP;
PUSHMARK(sp);
EXTEND(sp, 1);
PUSHs(src);
PUTBACK;
result = perl_call_method("getline", G_SCALAR);
SPAGAIN;
if (result) {
csv->tmp = POPs;
} else {
csv->tmp = NULL;
}
PUTBACK;
}
if (csv->tmp && SvOK(csv->tmp)) {
csv->bptr = SvPV(csv->tmp, csv->size);
csv->used = 0;
if (csv->size) {
return ((unsigned char) csv->bptr[csv->used++]);
}
}
return EOF;
}
static
int Print(csv_t* csv, SV* dst) {
int result;
if (csv->useIO) {
SV* tmp = newSVpv(csv->buffer, csv->used);
dSP;
PUSHMARK(sp);
EXTEND(sp, 2);
PUSHs((dst));
PUSHs(tmp);
PUTBACK;
result = perl_call_method("print", G_SCALAR);
SPAGAIN;
if (result) {
result = POPi;
}
PUTBACK;
SvREFCNT_dec(tmp);
} else {
sv_catpvn(SvRV(dst), csv->buffer, csv->used);
result = TRUE;
}
csv->used = 0;
return result;
}
void HRA_fetch_a(SV *self, SV *attr, char *t)
{
dXSARGS;
SP -= 3;
if(GIMME_V == G_VOID) {
XSRETURN(0);
}
SV *aobj = attr_get(self, attr, t, 0);
if(!aobj) {
HR_DEBUG("Can't find attribute!");
XSRETURN_EMPTY;
} else {
HR_DEBUG("Found aobj=%p", aobj);
}
hrattr_simple *aptr = attr_from_sv(SvRV(aobj));
HR_DEBUG("Attrhash=%p", aptr->attrhash);
int nkeys = hv_iterinit(aptr->attrhash);
HR_DEBUG("We have %d keys", nkeys);
if(GIMME_V == G_SCALAR) {
HR_DEBUG("Scalar return value requested");
XSRETURN_IV(nkeys);
}
HR_DEBUG("Will do some stack voodoo");
EXTEND(sp, nkeys);
HE *cur = hv_iternext(aptr->attrhash);
for(; cur != NULL; cur = hv_iternext(aptr->attrhash))
{
XPUSHs(sv_mortalcopy(hv_iterval(aptr->attrhash, cur)));
}
PUTBACK;
}
void operator()(SV **&sp, HashTable &result) {
EXTEND(sp, result.length() * 2);
for (HashTableIterator it = result.begin(); it != result.end(); ++it) {
PUSHs(String((*it).first).dispose());
PUSHs((*it).second);
}
}
static void plcb_call_sv_with_args_noret(SV *code, int mortalize, int nargs, ...)
{
va_list ap;
SV *cursv;
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, nargs);
va_start(ap, nargs);
while (nargs) {
cursv = va_arg(ap, SV*);
if (mortalize) {
cursv = sv_2mortal(cursv);
}
PUSHs(cursv);
nargs--;
}
va_end(ap);
PUTBACK;
call_sv(code, G_DISCARD);
FREETMPS;
LEAVE;
}
static HV*
S_thaw_fields(lucy_InStream *instream) {
// Read frozen data into an SV buffer.
size_t len = (size_t)LUCY_InStream_Read_C64(instream);
SV *buf_sv = newSV(len + 1);
SvPOK_on(buf_sv);
SvCUR_set(buf_sv, len);
char *buf = SvPVX(buf_sv);
LUCY_InStream_Read_Bytes(instream, buf, len);
// Call back to Storable to thaw the frozen hash.
dSP;
ENTER;
SAVETMPS;
EXTEND(SP, 1);
PUSHMARK(SP);
mPUSHs(buf_sv);
PUTBACK;
call_pv("Storable::thaw", G_SCALAR);
SPAGAIN;
SV *frozen = POPs;
if (frozen && !SvROK(frozen)) {
CFISH_THROW(CFISH_ERR, "thaw failed");
}
HV *fields = (HV*)SvRV(frozen);
(void)SvREFCNT_inc((SV*)fields);
PUTBACK;
FREETMPS;
LEAVE;
return fields;
}
/* this is public so that other extensions which use GtkMenuPosFunc (e.g.
* libgnomeui) don't need to reimplement it. */
void
gtk2perl_menu_position_func (GtkMenu * menu,
gint * x,
gint * y,
gboolean * push_in,
GPerlCallback * callback)
{
int n;
dGPERL_CALLBACK_MARSHAL_SP;
GPERL_CALLBACK_MARSHAL_INIT (callback);
ENTER;
SAVETMPS;
PUSHMARK (SP);
EXTEND (SP, 3);
PUSHs (sv_2mortal (newSVGtkMenu (menu)));
PUSHs (sv_2mortal (newSViv (*x)));
PUSHs (sv_2mortal (newSViv (*y)));
if (callback->data)
XPUSHs (sv_2mortal (newSVsv (callback->data)));
/* A die() from callback->func is suspected to be bad or very bad.
Circa Gtk 2.18 a jump out of $menu->popup seems to leave an X
grab with no way to get rid of it (no keyboard Esc, and no mouse
click handlers). The position func can also be called later for
things like resizing or move to a different GdkScreen, and such a
call might come straight from the main loop, where a die() would
jump out of Gtk2->main. */
PUTBACK;
n = call_sv (callback->func, G_ARRAY | G_EVAL);
SPAGAIN;
if (SvTRUE (ERRSV)) {
g_warning ("menu position callback ignoring error: %s",
SvPVutf8_nolen (ERRSV));
} else if (n < 2 || n > 3) {
g_warning ("menu position callback must return two integers "
"(x, and y) or two integers and a boolean "
"(x, y, and push_in)");
} else {
/* POPs and POPi take things off the *end* of the stack! */
if (n > 2) {
SV *sv = POPs;
*push_in = sv_2bool (sv);
}
if (n > 1) *y = POPi;
if (n > 0) *x = POPi;
}
PUTBACK;
FREETMPS;
LEAVE;
}
static
XS(epoc_getcwd) /* more or less stolen from win32.c */
{
dXSARGS;
/* Make the host for current directory */
char *buffer;
int buflen = 256;
char *ptr;
buffer = (char *) malloc( buflen);
if (buffer == NULL) {
XSRETURN_UNDEF;
}
while ((NULL == ( ptr = getcwd( buffer, buflen))) && (errno == ERANGE)) {
buflen *= 2;
if (NULL == realloc( buffer, buflen)) {
XSRETURN_UNDEF;
}
}
/*
* If ptr != Nullch
* then it worked, set PV valid,
* else return 'undef'
*/
if (ptr) {
SV *sv = sv_newmortal();
char *tptr;
for (tptr = ptr; *tptr != '\0'; tptr++) {
if (*tptr == '\\') {
*tptr = '/';
}
}
sv_setpv(sv, ptr);
free( buffer);
EXTEND(SP,1);
SvPOK_on(sv);
ST(0) = sv;
#ifndef INCOMPLETE_TAINTS
SvTAINTED_on(ST(0));
#endif
XSRETURN(1);
}
free( buffer);
XSRETURN_UNDEF;
}
/* getcode_list関数 */
int xs_getcode_list(SV* sv_str)
{
int matches;
CodeCheck check[cc_tmpl_max];
int i;
dSP; dMARK; dAX; /* XSARGS; - items */
if( sv_str==&PL_sv_undef )
{
return 0;
}
if( SvGMAGICAL(sv_str) )
{
mg_get(sv_str);
}
if( !SvOK(sv_str) )
{
return 0;
}
matches = getcode_list(sv_str, check);
if( matches<=0 )
{
return 0;
}
EXTEND(SP, matches);
for( i=0; i<matches; ++i )
{
switch(check[i].code)
{
case cc_unknown: ST(i) = sv_2mortal( new_CC_UNKNOWN() ); break;
case cc_ascii: ST(i) = sv_2mortal( new_CC_ASCII() ); break;
case cc_sjis: ST(i) = sv_2mortal( new_CC_SJIS() ); break;
case cc_eucjp: ST(i) = sv_2mortal( new_CC_EUCJP() ); break;
case cc_jis: ST(i) = sv_2mortal( new_CC_JIS() ); break;
case cc_jis_au: ST(i) = sv_2mortal( new_CC_JIS_AU() ); break;
case cc_jis_jsky: ST(i) = sv_2mortal( new_CC_JIS_JSKY() ); break;
case cc_utf8: ST(i) = sv_2mortal( new_CC_UTF8() ); break;
case cc_utf16: ST(i) = sv_2mortal( new_CC_UTF16() ); break;
case cc_utf32: ST(i) = sv_2mortal( new_CC_UTF32() ); break;
case cc_utf32_be: ST(i) = sv_2mortal( new_CC_UTF32_BE() ); break;
case cc_utf32_le: ST(i) = sv_2mortal( new_CC_UTF32_LE() ); break;
case cc_sjis_jsky: ST(i) = sv_2mortal( new_CC_SJIS_JSKY() ); break;
case cc_sjis_imode: ST(i) = sv_2mortal( new_CC_SJIS_IMODE() ); break;
case cc_sjis_doti: ST(i) = sv_2mortal( new_CC_SJIS_DOTI() ); break;
default: ST(i) = sv_2mortal( new_CC_UNKNOWN() ); break;
}
}
return matches;
}
void
Perl_av_extend(pTHX_ AV *av, I32 key)
{
dVAR;
MAGIC *mg;
PERL_ARGS_ASSERT_AV_EXTEND;
assert(SvTYPE(av) == SVt_PVAV);
mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied);
if (mg) {
dSP;
ENTER;
SAVETMPS;
PUSHSTACKi(PERLSI_MAGIC);
PUSHMARK(SP);
EXTEND(SP,2);
PUSHs(SvTIED_obj(MUTABLE_SV(av), mg));
mPUSHi(key + 1);
PUTBACK;
call_method("EXTEND", G_SCALAR|G_DISCARD);
POPSTACK;
FREETMPS;
LEAVE;
return;
}
if (key > AvMAX(av)) {
SV** ary;
I32 tmp;
I32 newmax;
if (AvALLOC(av) != AvARRAY(av)) {
ary = AvALLOC(av) + AvFILLp(av) + 1;
tmp = AvARRAY(av) - AvALLOC(av);
Move(AvARRAY(av), AvALLOC(av), AvFILLp(av)+1, SV*);
AvMAX(av) += tmp;
AvARRAY(av) = AvALLOC(av);
if (AvREAL(av)) {
while (tmp)
ary[--tmp] = &PL_sv_undef;
}
if (key > AvMAX(av) - 10) {
newmax = key + AvMAX(av);
goto resize;
}
}
static SV*
S_compile_token_re(pTHX_ cfish_String *pattern) {
dSP;
ENTER;
SAVETMPS;
EXTEND(SP, 1);
PUSHMARK(SP);
XPUSHs((SV*)CFISH_Str_To_Host(pattern));
PUTBACK;
call_pv("Lucy::Analysis::RegexTokenizer::_compile_token_re", G_SCALAR);
SPAGAIN;
SV *token_re_sv = POPs;
(void)SvREFCNT_inc(token_re_sv);
PUTBACK;
FREETMPS;
LEAVE;
return token_re_sv;
}
static SV*
S_nfreeze_fields(lucy_Doc *self) {
lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
dSP;
ENTER;
SAVETMPS;
EXTEND(SP, 1);
PUSHMARK(SP);
mPUSHs((SV*)newRV_inc((SV*)ivars->fields));
PUTBACK;
call_pv("Storable::nfreeze", G_SCALAR);
SPAGAIN;
SV *frozen = POPs;
(void)SvREFCNT_inc(frozen);
PUTBACK;
FREETMPS;
LEAVE;
return frozen;
}
void
Perl_av_extend(pTHX_ AV *av, I32 key)
{
MAGIC *mg;
if ((mg = SvTIED_mg((SV*)av, PERL_MAGIC_tied))) {
dSP;
ENTER;
SAVETMPS;
PUSHSTACKi(PERLSI_MAGIC);
PUSHMARK(SP);
EXTEND(SP,2);
PUSHs(SvTIED_obj((SV*)av, mg));
PUSHs(sv_2mortal(newSViv(key+1)));
PUTBACK;
call_method("EXTEND", G_SCALAR|G_DISCARD);
POPSTACK;
FREETMPS;
LEAVE;
return;
}
if (key > AvMAX(av)) {
SV** ary;
I32 tmp;
I32 newmax;
if (AvALLOC(av) != AvARRAY(av)) {
ary = AvALLOC(av) + AvFILLp(av) + 1;
tmp = AvARRAY(av) - AvALLOC(av);
Move(AvARRAY(av), AvALLOC(av), AvFILLp(av)+1, SV*);
AvMAX(av) += tmp;
SvPVX(av) = (char*)AvALLOC(av);
if (AvREAL(av)) {
while (tmp)
ary[--tmp] = &PL_sv_undef;
}
if (key > AvMAX(av) - 10) {
newmax = key + AvMAX(av);
goto resize;
}
}
void
c2p_totaldlcb(off_t total)
{
dSP;
if(!totaldlcb_ref){
return;
}
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSViv(total)));
PUTBACK;
call_sv(totaldlcb_ref, G_DISCARD);
FREETMPS;
LEAVE;
return;
}
lucy_Err*
lucy_Err_trap(Cfish_Err_Attempt_t routine, void *context) {
lucy_Err *error = NULL;
SV *routine_sv = newSViv(PTR2IV(routine));
SV *context_sv = newSViv(PTR2IV(context));
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 2);
PUSHs(sv_2mortal(routine_sv));
PUSHs(sv_2mortal(context_sv));
PUTBACK;
int count = call_sv(attempt_xsub, G_EVAL | G_DISCARD);
if (count != 0) {
lucy_CharBuf *mess
= lucy_CB_newf("'attempt' returned too many values: %i32",
(int32_t)count);
error = lucy_Err_new(mess);
}
else {
SV *dollar_at = get_sv("@", FALSE);
if (SvTRUE(dollar_at)) {
if (sv_isobject(dollar_at)
&& sv_derived_from(dollar_at,"Clownfish::Err")
) {
IV error_iv = SvIV(SvRV(dollar_at));
error = INT2PTR(lucy_Err*, error_iv);
CFISH_INCREF(error);
}
else {
STRLEN len;
char *ptr = SvPVutf8(dollar_at, len);
lucy_CharBuf *mess = lucy_CB_new_from_trusted_utf8(ptr, len);
error = lucy_Err_new(mess);
}
}
static void
XS_Fcntl_S_ISREG(pTHX_ CV* cv)
{
dVAR;
dXSARGS;
dXSI32;
/* Preserve the semantics of the perl code, which was:
sub S_ISREG { ( $_[0] & _S_IFMT() ) == S_IFREG() }
*/
SV *mode;
PERL_UNUSED_VAR(cv); /* -W */
SP -= items;
if (items > 0)
mode = ST(0);
else {
mode = &PL_sv_undef;
EXTEND(SP, 1);
}
PUSHs(((SvUV(mode) & S_IFMT) == (UV)ix) ? &PL_sv_yes : &PL_sv_no);
PUTBACK;
}
int
c2p_fetchcb(const char * url, const char * dest, int force)
{
SV * svret;
int ret;
dSP;
if(!fetchcb_ref){
return -1;
}
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 3);
PUSHs(sv_2mortal(newSVpv(url, 0)));
PUSHs(sv_2mortal(newSVpv(dest, 0)));
PUSHs(sv_2mortal(newSViv(force)));
PUTBACK;
ret = 0;
if(call_sv(fetchcb_ref, G_SCALAR | G_EVAL) == 1){
svret = POPs;
if(SvTRUE(ERRSV)){
/* the callback died, return an error to libalpm */
ret = -1;
}else{
ret = (SvTRUE(svret) ? 1 : 0);
}
}
FREETMPS;
LEAVE;
return ret;
}
/*
* pixman_composite_trapezoids()
*
* All the trapezoids are conceptually rendered to an infinitely big image.
* The (0, 0) coordinates of this image are then aligned with the (x, y)
* coordinates of the source image, and then both images are aligned with
* the (x, y) coordinates of the destination. Then, in principle, compositing
* of these three images takes place across the entire destination.
*
* FIXME: However, there is currently a bug, where we restrict this compositing
* to the bounding box of the trapezoids. This is incorrect for operators such
* as SRC and IN where blank source pixels do have an effect on the destination.
*/
PIXMAN_EXPORT void
pixman_composite_trapezoids (pixman_op_t op,
pixman_image_t * src,
pixman_image_t * dst,
pixman_format_code_t mask_format,
int x_src,
int y_src,
int x_dst,
int y_dst,
int n_traps,
const pixman_trapezoid_t * traps)
{
int i;
if (n_traps <= 0)
return;
_pixman_image_validate (src);
_pixman_image_validate (dst);
if (op == PIXMAN_OP_ADD &&
(src->common.flags & FAST_PATH_IS_OPAQUE) &&
(mask_format == dst->common.extended_format_code) &&
!(dst->common.have_clip_region))
{
for (i = 0; i < n_traps; ++i)
{
const pixman_trapezoid_t *trap = &(traps[i]);
if (!pixman_trapezoid_valid (trap))
continue;
pixman_rasterize_trapezoid (dst, trap, x_dst, y_dst);
}
}
else
{
pixman_image_t *tmp;
pixman_box32_t box;
box.x1 = INT32_MAX;
box.y1 = INT32_MAX;
box.x2 = INT32_MIN;
box.y2 = INT32_MIN;
for (i = 0; i < n_traps; ++i)
{
const pixman_trapezoid_t *trap = &(traps[i]);
int y1, y2;
if (!pixman_trapezoid_valid (trap))
continue;
y1 = pixman_fixed_to_int (trap->top);
if (y1 < box.y1)
box.y1 = y1;
y2 = pixman_fixed_to_int (pixman_fixed_ceil (trap->bottom));
if (y2 > box.y2)
box.y2 = y2;
#define EXTEND_MIN(x) \
if (pixman_fixed_to_int ((x)) < box.x1) \
box.x1 = pixman_fixed_to_int ((x));
#define EXTEND_MAX(x) \
if (pixman_fixed_to_int (pixman_fixed_ceil ((x))) > box.x2) \
box.x2 = pixman_fixed_to_int (pixman_fixed_ceil ((x)));
#define EXTEND(x) \
EXTEND_MIN(x); \
EXTEND_MAX(x);
EXTEND(trap->left.p1.x);
EXTEND(trap->left.p2.x);
EXTEND(trap->right.p1.x);
EXTEND(trap->right.p2.x);
}
if (box.x1 >= box.x2 || box.y1 >= box.y2)
return;
tmp = pixman_image_create_bits (
mask_format, box.x2 - box.x1, box.y2 - box.y1, NULL, -1);
for (i = 0; i < n_traps; ++i)
{
const pixman_trapezoid_t *trap = &(traps[i]);
if (!pixman_trapezoid_valid (trap))
continue;
pixman_rasterize_trapezoid (tmp, trap, - box.x1, - box.y1);
}
pixman_image_composite (op, src, tmp, dst,
x_src + box.x1, y_src + box.y1,
0, 0,
x_dst + box.x1, y_dst + box.y1,
box.x2 - box.x1, box.y2 - box.y1);
pixman_image_unref (tmp);
}
}
// Convert all arguments to Perl and place them on the Perl stack.
static CHY_INLINE void
SI_push_args(void *vobj, va_list args, uint32_t num_args)
{
kino_Obj *obj = (kino_Obj*)vobj;
SV *invoker;
uint32_t i;
dSP;
uint32_t stack_slots_needed = num_args < 2
? num_args + 1
: (num_args * 2) + 1;
EXTEND(SP, stack_slots_needed);
if (Kino_Obj_Is_A(obj, KINO_VTABLE)) {
kino_VTable *vtable = (kino_VTable*)obj;
// TODO: Creating a new class name SV every time is wasteful.
invoker = XSBind_cb_to_sv(Kino_VTable_Get_Name(vtable));
}
else {
invoker = (SV*)Kino_Obj_To_Host(obj);
}
ENTER;
SAVETMPS;
PUSHMARK(SP);
PUSHs( sv_2mortal(invoker) );
for (i = 0; i < num_args; i++) {
uint32_t arg_type = va_arg(args, uint32_t);
char *label = va_arg(args, char*);
if (num_args > 1) {
PUSHs( sv_2mortal( newSVpvn(label, strlen(label)) ) );
}
switch (arg_type & CFISH_HOST_ARGTYPE_MASK) {
case CFISH_HOST_ARGTYPE_I32: {
int32_t value = va_arg(args, int32_t);
PUSHs( sv_2mortal( newSViv(value) ) );
}
break;
case CFISH_HOST_ARGTYPE_I64: {
int64_t value = va_arg(args, int64_t);
if (sizeof(IV) == 8) {
PUSHs( sv_2mortal( newSViv((IV)value) ) );
}
else {
// lossy
PUSHs( sv_2mortal( newSVnv((double)value) ) );
}
}
break;
case CFISH_HOST_ARGTYPE_F32:
case CFISH_HOST_ARGTYPE_F64: {
// Floats are promoted to doubles by variadic calling.
double value = va_arg(args, double);
PUSHs( sv_2mortal( newSVnv(value) ) );
}
break;
case CFISH_HOST_ARGTYPE_STR: {
kino_CharBuf *string = va_arg(args, kino_CharBuf*);
PUSHs( sv_2mortal( XSBind_cb_to_sv(string) ) );
}
break;
case CFISH_HOST_ARGTYPE_OBJ: {
kino_Obj* anObj = va_arg(args, kino_Obj*);
SV *arg_sv = anObj == NULL
? newSV(0)
: XSBind_cfish_to_perl(anObj);
PUSHs( sv_2mortal(arg_sv) );
}
break;
default:
CFISH_THROW(KINO_ERR, "Unrecognized arg type: %u32", arg_type);
}
}
PUTBACK;
}
void operator()(SV **&sp, String &result) {
EXTEND(sp, 1);
PUSHs(sv_2mortal(result.dispose()));
}
int main(void)
{
int i, ret = 0;
uint8_t *temp;
PutBitContext pb;
BitstreamContext bc;
temp = av_malloc(SIZE);
if (!temp)
return 2;
init_put_bits(&pb, temp, SIZE);
for (i = 0; i < COUNT; i++)
set_ue_golomb(&pb, i);
flush_put_bits(&pb);
bitstream_init8(&bc, temp, SIZE);
for (i = 0; i < COUNT; i++) {
int j, s = bitstream_peek(&bc, 25);
j = get_ue_golomb(&bc);
if (j != i) {
fprintf(stderr, "get_ue_golomb: expected %d, got %d. bits: %7x\n",
i, j, s);
ret = 1;
}
}
#define EXTEND(i) (i << 3 | i & 7)
init_put_bits(&pb, temp, SIZE);
for (i = 0; i < COUNT; i++)
set_ue_golomb(&pb, EXTEND(i));
flush_put_bits(&pb);
bitstream_init8(&bc, temp, SIZE);
for (i = 0; i < COUNT; i++) {
int j, s = bitstream_peek(&bc, 32);
j = get_ue_golomb_long(&bc);
if (j != EXTEND(i)) {
fprintf(stderr, "get_ue_golomb_long: expected %d, got %d. "
"bits: %8x\n", EXTEND(i), j, s);
ret = 1;
}
}
init_put_bits(&pb, temp, SIZE);
for (i = 0; i < COUNT; i++)
set_se_golomb(&pb, i - COUNT / 2);
flush_put_bits(&pb);
bitstream_init8(&bc, temp, SIZE);
for (i = 0; i < COUNT; i++) {
int j, s = bitstream_peek(&bc, 25);
j = get_se_golomb(&bc);
if (j != i - COUNT / 2) {
fprintf(stderr, "get_se_golomb: expected %d, got %d. bits: %7x\n",
i - COUNT / 2, j, s);
ret = 1;
}
}
av_free(temp);
return ret;
}
PJS_EXTERN JSBool
PJS_Call_sv_with_jsvals_rsv(
pTHX_
JSContext *cx,
JSObject *obj,
SV *code,
SV *caller, /* Will be disposed inside */
uintN argc,
jsval *argv,
SV **rsv,
I32 flag
) {
dSP;
JSBool ok = JS_TRUE;
uintN arg;
I32 rcount = caller ? 1 : 0;
PJS_Context *pcx = PJS_GET_CONTEXT(cx);
if(SvROK(code) && SvTYPE(SvRV(code)) == SVt_PVCV) {
ENTER; SAVETMPS;
PUSHMARK(SP) ;
sv_setiv(save_scalar(PJS_Context_SV), PTR2IV(pcx));
EXTEND(SP, argc + rcount);
PUTBACK;
/* From here we are working with the global stack,
* a) at PUSH time we can fail, so we need to abort the call
* b) Want to avoid copying local <=> global SP at every single PUSH
*
* Before 'call_sv', rcount is the number of SVs pushed so far
*/
if(caller) *++PL_stack_sp = sv_2mortal(caller);
if(argv && !(flag & G_NOARGS)) {
/* HACK: We use G_NOARGS as a guard against use argv[-1] to get This.
* Needed for the use in PJS_invoke_perl_property_setter where given
* argc is faked
*/
SV *This;
ok = PJS_ReflectJS2Perl(aTHX_ cx, argv[-1], &This, 0);
if(ok) sv_setsv(save_scalar(PJS_This), sv_2mortal(This));
else goto forget;
}
else flag &= ~G_NOARGS;
for(arg = 0; arg < argc; arg++) {
SV *sv;
ok = PJS_ReflectJS2Perl(aTHX_ cx, argv[arg], &sv, 1);
if(!ok) {
rcount += arg;
goto forget;
}
*++PL_stack_sp = sv_2mortal(sv);
}
rcount = call_sv(code, flag | G_EVAL);
if(rsv) {
if(flag == G_SCALAR || rcount == 1)
*rsv = SvREFCNT_inc_simple_NN(*PL_stack_sp);
else
*rsv = newRV((SV *)av_make(rcount, PL_stack_sp-rcount+1));
SAVEMORTALIZESV(*rsv);
}
forget:
PL_stack_sp -= rcount;
FREETMPS; LEAVE;
if(ok && SvTRUE(ERRSV)) {
propagate2JS(aTHX_ pcx, obj);
ok = JS_FALSE;
}
}
else croak("Not a coderef");
return ok;
}
static pixman_bool_t
get_trap_extents (pixman_op_t op, pixman_image_t *dest,
const pixman_trapezoid_t *traps, int n_traps,
pixman_box32_t *box)
{
int i;
/* When the operator is such that a zero source has an
* effect on the underlying image, we have to
* composite across the entire destination
*/
if (!zero_src_has_no_effect [op])
{
box->x1 = 0;
box->y1 = 0;
box->x2 = dest->bits.width;
box->y2 = dest->bits.height;
return TRUE;
}
box->x1 = INT32_MAX;
box->y1 = INT32_MAX;
box->x2 = INT32_MIN;
box->y2 = INT32_MIN;
for (i = 0; i < n_traps; ++i)
{
const pixman_trapezoid_t *trap = &(traps[i]);
int y1, y2;
if (!pixman_trapezoid_valid (trap))
continue;
y1 = pixman_fixed_to_int (trap->top);
if (y1 < box->y1)
box->y1 = y1;
y2 = pixman_fixed_to_int (pixman_fixed_ceil (trap->bottom));
if (y2 > box->y2)
box->y2 = y2;
#define EXTEND_MIN(x) \
if (pixman_fixed_to_int ((x)) < box->x1) \
box->x1 = pixman_fixed_to_int ((x));
#define EXTEND_MAX(x) \
if (pixman_fixed_to_int (pixman_fixed_ceil ((x))) > box->x2) \
box->x2 = pixman_fixed_to_int (pixman_fixed_ceil ((x)));
#define EXTEND(x) \
EXTEND_MIN(x); \
EXTEND_MAX(x);
EXTEND(trap->left.p1.x);
EXTEND(trap->left.p2.x);
EXTEND(trap->right.p1.x);
EXTEND(trap->right.p2.x);
}
if (box->x1 >= box->x2 || box->y1 >= box->y2)
return FALSE;
return TRUE;
}
static ngx_int_t
ngx_http_perl_call_handler(pTHX_ ngx_http_request_t *r, HV *nginx, SV *sub,
SV **args, ngx_str_t *handler, ngx_str_t *rv)
{
SV *sv;
int n, status;
char *line;
STRLEN len, n_a;
ngx_str_t err;
ngx_uint_t i;
ngx_connection_t *c;
dSP;
status = 0;
ENTER;
SAVETMPS;
PUSHMARK(sp);
sv = sv_2mortal(sv_bless(newRV_noinc(newSViv(PTR2IV(r))), nginx));
XPUSHs(sv);
if (args) {
EXTEND(sp, (intptr_t) args[0]);
for (i = 1; i <= (ngx_uint_t) args[0]; i++) {
PUSHs(sv_2mortal(args[i]));
}
}
PUTBACK;
c = r->connection;
n = call_sv(sub, G_EVAL);
SPAGAIN;
if (c->destroyed) {
PUTBACK;
FREETMPS;
LEAVE;
return NGX_DONE;
}
if (n) {
if (rv == NULL) {
status = POPi;
ngx_log_debug1(NGX_LOG_DEBUG_HTTP, c->log, 0,
"call_sv: %d", status);
} else {
line = SvPVx(POPs, n_a);
rv->len = n_a;
rv->data = ngx_pnalloc(r->pool, n_a);
if (rv->data == NULL) {
return NGX_ERROR;
}
ngx_memcpy(rv->data, line, n_a);
}
}
PUTBACK;
FREETMPS;
LEAVE;
/* check $@ */
if (SvTRUE(ERRSV)) {
err.data = (u_char *) SvPV(ERRSV, len);
for (len--; err.data[len] == LF || err.data[len] == CR; len--) {
/* void */
}
err.len = len + 1;
ngx_log_error(NGX_LOG_ERR, c->log, 0,
"call_sv(\"%V\") failed: \"%V\"", handler, &err);
if (rv) {
return NGX_ERROR;
}
return NGX_HTTP_INTERNAL_SERVER_ERROR;
}
if (n != 1) {
ngx_log_error(NGX_LOG_ALERT, c->log, 0,
"call_sv(\"%V\") returned %d results", handler, n);
status = NGX_OK;
}
if (rv) {
return NGX_OK;
}
return (ngx_int_t) status;
}
static av_always_inline void FUNC(intra_pred)(HEVCContext *s, int x0, int y0,
int log2_size, int c_idx)
{
#define PU(x) \
((x) >> s->ps.sps->log2_min_pu_size)
#define MVF(x, y) \
(s->ref->tab_mvf[(x) + (y) * min_pu_width])
#define MVF_PU(x, y) \
MVF(PU(x0 + ((x) << hshift)), PU(y0 + ((y) << vshift)))
#define IS_INTRA(x, y) \
MVF_PU(x, y).is_intra
#define MIN_TB_ADDR_ZS(x, y) \
s->ps.pps->min_tb_addr_zs[(y) * s->ps.sps->min_tb_width + (x)]
#define EXTEND(ptr, val, len) \
do { \
pixel4 pix = PIXEL_SPLAT_X4(val); \
for (i = 0; i < (len); i += 4) \
AV_WN4P(ptr + i, pix); \
} while (0)
#define EXTEND_LEFT_CIP(ptr, start, length) \
for (i = (start); i > (start) - (length); i--) \
if (!IS_INTRA(i - 1, -1)) \
ptr[i - 1] = ptr[i]
#define EXTEND_RIGHT_CIP(ptr, start, length) \
for (i = (start); i < (start) + (length); i++) \
if (!IS_INTRA(i, -1)) \
ptr[i] = ptr[i - 1]
#define EXTEND_UP_CIP(ptr, start, length) \
for (i = (start); i > (start) - (length); i--) \
if (!IS_INTRA(-1, i - 1)) \
ptr[i - 1] = ptr[i]
#define EXTEND_UP_CIP_0(ptr, start, length) \
for (i = (start); i > (start) - (length); i--) \
ptr[i - 1] = ptr[i]
#define EXTEND_DOWN_CIP(ptr, start, length) \
for (i = (start); i < (start) + (length); i++) \
if (!IS_INTRA(-1, i)) \
ptr[i] = ptr[i - 1]
HEVCLocalContext *lc = &s->HEVClc;
int i;
int hshift = s->ps.sps->hshift[c_idx];
int vshift = s->ps.sps->vshift[c_idx];
int size = (1 << log2_size);
int size_in_luma = size << hshift;
int size_in_tbs = size_in_luma >> s->ps.sps->log2_min_tb_size;
int x = x0 >> hshift;
int y = y0 >> vshift;
int x_tb = x0 >> s->ps.sps->log2_min_tb_size;
int y_tb = y0 >> s->ps.sps->log2_min_tb_size;
int cur_tb_addr = MIN_TB_ADDR_ZS(x_tb, y_tb);
ptrdiff_t stride = s->frame->linesize[c_idx] / sizeof(pixel);
pixel *src = (pixel*)s->frame->data[c_idx] + x + y * stride;
int min_pu_width = s->ps.sps->min_pu_width;
enum IntraPredMode mode = c_idx ? lc->pu.intra_pred_mode_c :
lc->tu.cur_intra_pred_mode;
pixel left_array[2 * MAX_TB_SIZE + 1];
pixel filtered_left_array[2 * MAX_TB_SIZE + 1];
pixel top_array[2 * MAX_TB_SIZE + 1];
pixel filtered_top_array[2 * MAX_TB_SIZE + 1];
pixel *left = left_array + 1;
pixel *top = top_array + 1;
pixel *filtered_left = filtered_left_array + 1;
pixel *filtered_top = filtered_top_array + 1;
int cand_bottom_left = lc->na.cand_bottom_left && cur_tb_addr > MIN_TB_ADDR_ZS(x_tb - 1, y_tb + size_in_tbs);
int cand_left = lc->na.cand_left;
int cand_up_left = lc->na.cand_up_left;
int cand_up = lc->na.cand_up;
int cand_up_right = lc->na.cand_up_right && cur_tb_addr > MIN_TB_ADDR_ZS(x_tb + size_in_tbs, y_tb - 1);
int bottom_left_size = (FFMIN(y0 + 2 * size_in_luma, s->ps.sps->height) -
(y0 + size_in_luma)) >> vshift;
int top_right_size = (FFMIN(x0 + 2 * size_in_luma, s->ps.sps->width) -
(x0 + size_in_luma)) >> hshift;
if (s->ps.pps->constrained_intra_pred_flag == 1) {
int size_in_luma_pu = PU(size_in_luma);
int on_pu_edge_x = !(x0 & ((1 << s->ps.sps->log2_min_pu_size) - 1));
int on_pu_edge_y = !(y0 & ((1 << s->ps.sps->log2_min_pu_size) - 1));
if (!size_in_luma_pu)
size_in_luma_pu++;
if (cand_bottom_left == 1 && on_pu_edge_x) {
int x_left_pu = PU(x0 - 1);
int y_bottom_pu = PU(y0 + size_in_luma);
int max = FFMIN(size_in_luma_pu, s->ps.sps->min_pu_height - y_bottom_pu);
cand_bottom_left = 0;
for (i = 0; i < max; i++)
cand_bottom_left |= MVF(x_left_pu, y_bottom_pu + i).is_intra;
}
if (cand_left == 1 && on_pu_edge_x) {
int x_left_pu = PU(x0 - 1);
int y_left_pu = PU(y0);
int max = FFMIN(size_in_luma_pu, s->ps.sps->min_pu_height - y_left_pu);
cand_left = 0;
for (i = 0; i < max; i++)
cand_left |= MVF(x_left_pu, y_left_pu + i).is_intra;
}
if (cand_up_left == 1) {
int x_left_pu = PU(x0 - 1);
int y_top_pu = PU(y0 - 1);
cand_up_left = MVF(x_left_pu, y_top_pu).is_intra;
}
if (cand_up == 1 && on_pu_edge_y) {
int x_top_pu = PU(x0);
int y_top_pu = PU(y0 - 1);
int max = FFMIN(size_in_luma_pu, s->ps.sps->min_pu_width - x_top_pu);
cand_up = 0;
for (i = 0; i < max; i++)
cand_up |= MVF(x_top_pu + i, y_top_pu).is_intra;
}
if (cand_up_right == 1 && on_pu_edge_y) {
int y_top_pu = PU(y0 - 1);
int x_right_pu = PU(x0 + size_in_luma);
int max = FFMIN(size_in_luma_pu, s->ps.sps->min_pu_width - x_right_pu);
cand_up_right = 0;
for (i = 0; i < max; i++)
cand_up_right |= MVF(x_right_pu + i, y_top_pu).is_intra;
}
for (i = 0; i < 2 * MAX_TB_SIZE; i++) {
left[i] = 128;
top[i] = 128;
}
}
if (cand_bottom_left) {
for (i = size; i < size + bottom_left_size; i++)
left[i] = POS(-1, i);
EXTEND(left + size + bottom_left_size, POS(-1, size + bottom_left_size - 1),
size - bottom_left_size);
}
if (cand_left)
for (i = size - 1; i >= 0; i--)
left[i] = POS(-1, i);
if (cand_up_left) {
left[-1] = POS(-1, -1);
top[-1] = left[-1];
}
if (cand_up)
memcpy(top, src - stride, size * sizeof(pixel));
if (cand_up_right) {
memcpy(top + size, src - stride + size, size * sizeof(pixel));
EXTEND(top + size + top_right_size, POS(size + top_right_size - 1, -1),
size - top_right_size);
}
if (s->ps.pps->constrained_intra_pred_flag == 1) {
if (cand_bottom_left || cand_left || cand_up_left || cand_up || cand_up_right) {
int size_max_x = x0 + ((2 * size) << hshift) < s->ps.sps->width ?
2 * size : (s->ps.sps->width - x0) >> hshift;
int size_max_y = y0 + ((2 * size) << vshift) < s->ps.sps->height ?
2 * size : (s->ps.sps->height - y0) >> vshift;
int j = size + (cand_bottom_left? bottom_left_size: 0) -1;
if (!cand_up_right) {
size_max_x = x0 + ((size) << hshift) < s->ps.sps->width ?
size : (s->ps.sps->width - x0) >> hshift;
}
if (!cand_bottom_left) {
size_max_y = y0 + (( size) << vshift) < s->ps.sps->height ?
size : (s->ps.sps->height - y0) >> vshift;
}
void operator()(SV **&sp, Array &result) {
EXTEND(sp, result.length());
for (ArrayIterator it = result.begin(); it != result.end(); ++it) {
PUSHs(*it);
}
}
void operator()(SV **&sp, Reference &result) {
EXTEND(sp, 1);
PUSHs(sv_2mortal(result.dispose()));
}
int modperl_callback(pTHX_ modperl_handler_t *handler, apr_pool_t *p,
request_rec *r, server_rec *s, AV *args)
{
CV *cv = (CV *)NULL;
I32 flags = G_EVAL|G_SCALAR;
dSP;
int count, status = OK;
/* handler callbacks shouldn't affect each other's taintedness
* state, so start every callback with a clear tainted status
* before and after the callback one of the main problems we are
* trying to solve is that when modperl_croak called (which calls
* perl's croak((char *)NULL) to throw an error object) it leaves
* the interpreter in the tainted state which later affects other
* callbacks that call eval, etc., which triggers perl crash with:
* Insecure dependency in eval while running setgid. Callback
* called exit.
*/
TAINT_NOT;
if ((status = modperl_handler_resolve(aTHX_ &handler, p, s)) != OK) {
TAINT_NOT;
return status;
}
ENTER;SAVETMPS;
PUSHMARK(SP);
if (MpHandlerMETHOD(handler)) {
GV *gv;
if (!handler->mgv_obj) {
Perl_croak(aTHX_ "panic: %s method handler object is NULL!",
modperl_handler_name(handler));
}
gv = modperl_mgv_lookup(aTHX_ handler->mgv_obj);
XPUSHs(modperl_mgv_sv(gv));
}
if (args) {
I32 items = AvFILLp(args) + 1;
EXTEND(SP, items);
Copy(AvARRAY(args), SP + 1, items, SV*);
SP += items;
}
PUTBACK;
if (MpHandlerANON(handler)) {
#ifdef USE_ITHREADS
cv = modperl_handler_anon_get(aTHX_ handler->mgv_obj);
#else
cv = handler->cv;
#endif
}
else {
GV *gv = modperl_mgv_lookup_autoload(aTHX_ handler->mgv_cv, s, p);
if (gv) {
cv = modperl_mgv_cv(gv);
}
else {
const char *name;
modperl_mgv_t *symbol = handler->mgv_cv;
/* XXX: need to validate *symbol */
if (symbol && symbol->name) {
name = modperl_mgv_as_string(aTHX_ symbol, p, 0);
}
else {
name = handler->name;
}
MP_TRACE_h(MP_FUNC, "[%s %s] lookup of %s failed",
modperl_pid_tid(p),
modperl_server_desc(s, p), name);
ap_log_error(APLOG_MARK, APLOG_ERR, 0, s,
"lookup of '%s' failed", name);
status = HTTP_INTERNAL_SERVER_ERROR;
}
}
if (status == OK) {
count = call_sv((SV*)cv, flags);
SPAGAIN;
if (count != 1) {
/* XXX can this really happen with G_EVAL|G_SCALAR? */
status = OK;
}
else {
SV *status_sv = POPs;
if (status_sv == &PL_sv_undef) {
/* ModPerl::Util::exit() and Perl_croak internally
* arrange to return PL_sv_undef with G_EVAL|G_SCALAR */
status = OK;
}
else {
status = SvIVx(status_sv);
}
}
PUTBACK;
}
FREETMPS;LEAVE;
if (SvTRUE(ERRSV)) {
MP_TRACE_h(MP_FUNC, "$@ = %s", SvPV_nolen(ERRSV));
status = HTTP_INTERNAL_SERVER_ERROR;
}
if (status == HTTP_INTERNAL_SERVER_ERROR) {
if (r && r->notes) {
apr_table_merge(r->notes, "error-notes", SvPV_nolen(ERRSV));
}
}
TAINT_NOT;
return status;
}
