static int coroae_wait_fd_write(int fd, int timeout) {
int ret = 0;
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSViv(fd)));
XPUSHs(sv_2mortal(newSViv(timeout)));
PUTBACK;
call_pv("Coro::AnyEvent::writable", G_SCALAR);
SPAGAIN;
if(SvTRUE(ERRSV)) {
uwsgi_log("[uwsgi-perl error] %s", SvPV_nolen(ERRSV));
}
else {
if (SvTRUE(POPs)) {
ret = 1;
}
}
FREETMPS;
LEAVE;
return ret;
}
void p5_init_callbacks(
SV *(*call_p6_method)(IV, char * , I32, SV *, SV **),
SV *(*call_p6_callable)(IV, SV *, SV **),
void (*free_p6_object)(IV),
SV *(*hash_at_key)(IV, char *),
SV *(*hash_assign_key)(IV, char *, SV *)
) {
perl6_callbacks *cbs = malloc(sizeof(perl6_callbacks));
cbs->call_p6_method = call_p6_method;
cbs->call_p6_callable = call_p6_callable;
cbs->free_p6_object = free_p6_object;
cbs->hash_at_key = hash_at_key;
cbs->hash_assign_key = hash_assign_key;
hv_stores(PL_modglobal, "Inline::Perl5 callbacks", newSViv((IV)cbs));
}
static void
gtk2perl_cell_layout_reorder (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
gint position)
{
GET_METHOD_OR_DIE (cell_layout, "REORDER");
{
PREP (cell_layout);
XPUSHs (sv_2mortal (newSVGtkCellRenderer (cell)));
XPUSHs (sv_2mortal (newSViv (position)));
CALL;
FINISH;
}
}
static void *
create_event_common(lcb_io_opt_t cbcio, int type)
{
plcb_EVENT *cevent;
plcb_IOPROCS *async;
SV *initproc = NULL, *tmprv = NULL;
async = (plcb_IOPROCS*) cbcio->v.v0.cookie;
Newxz(cevent, 1, plcb_EVENT);
cevent->pl_event = newAV();
cevent->rv_event = newRV_noinc((SV*)cevent->pl_event);
cevent->evtype = type;
cevent->fd = -1;
sv_bless(cevent->rv_event, gv_stashpv(PLCB_EVENT_CLASS, GV_ADD));
av_store(cevent->pl_event, PLCB_EVIDX_OPAQUE, newSViv(PTR2IV(cevent)));
av_store(cevent->pl_event, PLCB_EVIDX_FD, newSViv(-1));
av_store(cevent->pl_event, PLCB_EVIDX_TYPE, newSViv(type));
av_store(cevent->pl_event, PLCB_EVIDX_WATCHFLAGS, newSViv(0));
tmprv = newRV_inc(*av_fetch(cevent->pl_event, PLCB_EVIDX_OPAQUE, 0));
sv_bless(tmprv, gv_stashpv("Couchbase::IO::_CEvent", GV_ADD));
SvREFCNT_dec(tmprv);
if (type == PLCB_EVTYPE_IO) {
initproc = async->cv_evinit;
} else {
initproc = async->cv_tminit;
}
if (initproc) {
cb_args_noret(initproc, 0, 2, async->userdata, cevent->rv_event);
}
return cevent;
}
static void __LogAnswer(
const char *msg,
unsigned append)
{
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(sv_2mortal(newSVpv(msg, 0)));
XPUSHs(sv_2mortal(newSViv(append)));
PUTBACK;
call_pv("LogAnswer", G_DISCARD);
FREETMPS;
LEAVE;
}
SV* isaHMM (char *input){
P7_HMMFILE *hfp = NULL; /* open input HMM file */
P7_HMM *hmm = NULL; /* HMM object */
ESL_ALPHABET *abc = NULL; /* alphabet (set from the HMM file)*/
int isaHMM = 1;
int status;
int cnt = 0;
HV* hash = newHV();
hv_store(hash, "type", strlen("type"), newSVpv("UNK", 3), 0);
/* read the hmm */
if ((status = p7_hmmfile_OpenBuffer(input, strlen(input), &hfp)) != 0 ) {
hv_store(hash, "error", strlen("error"), newSViv(status), 0);
}else{
hv_store(hash, "type", strlen("type"), newSVpv("HMM", 3), 0);
}
if(status == 0){
/* double check that we can read the whole HMM */
status = p7_hmmfile_Read(hfp, &abc, &hmm);
cnt++;
if (status != eslOK ){
hv_store(hash, "error", strlen("error"), newSVpv("Error in HMM format",19 ), 0);
}else{
hv_store(hash, "alpha", strlen("alpha"), newSViv(abc->type), 0);
hv_store(hash, "hmmpgmd", strlen("hmmpgmd"), newSVpv(input, strlen(input)), 0);
hv_store(hash, "count", strlen("count"), newSViv(cnt), 0);
}
}
if (abc != NULL) esl_alphabet_Destroy(abc);
if(hfp != NULL) p7_hmmfile_Close(hfp);
if(hmm != NULL) p7_hmm_Destroy(hmm);
return newRV_noinc((SV*) hash);
}
void RegisterMisc(HV * hv_object, void * gtk_object)
{
#ifdef USE_GHASH
if (!MiscCache)
MiscCache = g_hash_table_new(g_direct_hash, g_direct_equal);
g_hash_table_insert(MiscCache, gtk_object, hv_object);
#else
char buffer[40];
sprintf(buffer, "%lu", (unsigned long)gtk_object);
if (!MiscCache)
MiscCache = newHV();
hv_store(MiscCache, buffer, strlen(buffer), newSViv((long)hv_object), 0);
#endif
/*printf("Registering object %p, HV %p (%d)\n", gtk_object, hv_object, SvREFCNT(hv_object));*/
}
static SV *make_env(request_rec *r, psgi_dir_config *c)
{
dTHX;
HV *env;
AV *version;
char *url_scheme, *script_name, *vpath, *path_info;
SV *input, *errors;
env = newHV();
ap_add_cgi_vars(r);
ap_add_common_vars(r);
/* fix SCRIPT_NAME & PATH_INFO */
if (c->location == NULL || strcmp(c->location, "/") == 0) {
script_name = "";
} else {
script_name = c->location;
}
vpath = apr_pstrcat(r->pool,
apr_table_get(r->subprocess_env, "SCRIPT_NAME"),
apr_table_get(r->subprocess_env, "PATH_INFO"),
NULL);
path_info = &vpath[strlen(script_name)];
apr_table_set(r->subprocess_env, "PATH_INFO", path_info);
apr_table_set(r->subprocess_env, "SCRIPT_NAME", script_name);
apr_table_do(copy_env, env, r->subprocess_env, NULL);
version = newAV();
av_push(version, newSViv(1));
av_push(version, newSViv(0));
(void) hv_store(env, "psgi.version", 12, newRV_noinc((SV *) version), 0);
url_scheme = apr_table_get(r->subprocess_env, "HTTPS") == NULL ? "http" : "https";
(void) hv_store(env, "psgi.url_scheme", 15, newSVpv(url_scheme, 0), 0);
input = newRV_noinc(newSV(0));
sv_magic(SvRV(input), NULL, PERL_MAGIC_ext, NULL, 0);
mg_find(SvRV(input), PERL_MAGIC_ext)->mg_obj = (void *) r;
sv_bless(input, gv_stashpv("ModPSGI::Input", 1));
(void) hv_store(env, "psgi.input", 10, input, 0);
errors = newRV_noinc(newSV(0));
sv_magic(SvRV(errors), NULL, PERL_MAGIC_ext, NULL, 0);
mg_find(SvRV(errors), PERL_MAGIC_ext)->mg_obj = (void *) r;
sv_bless(errors, gv_stashpv("ModPSGI::Errors", 1));
(void) hv_store(env, "psgi.errors", 11, errors, 0);
(void) hv_store(env, "psgi.multithread", 16, newSViv(psgi_multithread), 0);
(void) hv_store(env, "psgi.multiprocess", 17, newSViv(psgi_multiprocess), 0);
(void) hv_store(env, "psgi.run_once", 13, newSViv(0), 0);
(void) hv_store(env, "psgi.nonblocking", 16, newSViv(0), 0);
return newRV_inc((SV *) env);
}
static int output_body_obj(request_rec *r, SV *obj, int type)
{
dTHX;
SV *buf_sv;
apr_off_t clen = 0;
STRLEN len;
dSP;
char *buf;
int count;
if (type == SVt_PVMG && !respond_to(obj, "getline")) {
server_error(r, "response body object must be able to getline");
return HTTP_INTERNAL_SERVER_ERROR;
}
ENTER;
SAVETMPS;
SAVESPTR(PL_rs);
PL_rs = newRV_inc(newSViv(AP_IOBUFSIZE));
while (1) {
PUSHMARK(SP);
XPUSHs(obj);
PUTBACK;
count = call_method("getline", G_SCALAR);
if (count != 1) croak("Big trouble\n");
SPAGAIN;
buf_sv = POPs;
if (SvOK(buf_sv)) {
buf = SvPV(buf_sv, len);
clen += len;
ap_rwrite(buf, len, r);
} else {
break;
}
}
if (clen > 0) {
ap_set_content_length(r, clen);
}
PUSHMARK(SP);
XPUSHs(obj);
PUTBACK;
call_method("close", G_DISCARD);
SPAGAIN;
PUTBACK;
FREETMPS;
LEAVE;
return OK;
}
int
perl_back_modrdn(
Operation *op,
SlapReply *rs )
{
PerlBackend *perl_back = (PerlBackend *) op->o_bd->be_private;
int count;
PERL_SET_CONTEXT( PERL_INTERPRETER );
ldap_pvt_thread_mutex_lock( &perl_interpreter_mutex );
{
dSP;
ENTER;
SAVETMPS;
PUSHMARK(sp) ;
XPUSHs( perl_back->pb_obj_ref );
XPUSHs(sv_2mortal(newSVpv( op->o_req_dn.bv_val , op->o_req_dn.bv_len )));
XPUSHs(sv_2mortal(newSVpv( op->orr_newrdn.bv_val , op->orr_newrdn.bv_len )));
XPUSHs(sv_2mortal(newSViv( op->orr_deleteoldrdn )));
if ( op->orr_newSup != NULL ) {
XPUSHs(sv_2mortal(newSVpv( op->orr_newSup->bv_val , op->orr_newSup->bv_len )));
}
PUTBACK ;
count = call_method("modrdn", G_SCALAR);
SPAGAIN ;
if (count != 1) {
croak("Big trouble in back_modrdn\n") ;
}
rs->sr_err = POPi;
PUTBACK;
FREETMPS;
LEAVE ;
}
ldap_pvt_thread_mutex_unlock( &perl_interpreter_mutex );
send_ldap_result( op, rs );
Debug( LDAP_DEBUG_ANY, "Perl MODRDN\n" );
return( 0 );
}
void VAstEnt::initAVEnt(AV* avp, VAstType type, AV* parentp) {
// $avp = [type, parent, {}]
av_push(avp, newSViv(type));
if (parentp) {
SV* parentsv = newRV((SV*)parentp);
#ifdef SvWEAKREF // Newer perls
// We're making a circular reference, so to garbage collect properly we need to break it
// On older Perl's we'll just leak.
sv_rvweaken(parentsv);
#endif
av_push(avp, parentsv );
} else { // netlist top
av_push(avp, &PL_sv_undef);
}
av_push(avp, newRV_noinc((SV*)newHV()) );
}
static void
gtk2perl_cell_layout_add_attribute (GtkCellLayout *cell_layout,
GtkCellRenderer *cell,
const gchar *attribute,
gint column)
{
GET_METHOD_OR_DIE (cell_layout, "ADD_ATTRIBUTE");
{
PREP (cell_layout);
XPUSHs (sv_2mortal (newSVGtkCellRenderer (cell)));
XPUSHs (sv_2mortal (newSVGChar (attribute)));
XPUSHs (sv_2mortal (newSViv (column)));
CALL;
FINISH;
}
}
SV *
AbstractMenu_key( Handle self, Bool set, char * varName, SV * key)
{
PMenuItemReg m;
if ( var-> stage > csFrozen) return nilSV;
m = find_menuitem( self, varName, true);
if ( m == nil) return nilSV;
if ( m-> flags. divider || m-> down) return nilSV;
if ( !set)
return newSViv( m-> key);
m-> key = key_normalize( SvPV_nolen( key));
if ( m-> id > 0)
if ( var-> stage <= csNormal && var-> system)
apc_menu_item_set_key( self, m);
return nilSV;
}
SV *radio_get_status() {
have_status = _dsp_chain_rstat_queue.try_pop_all(lrstat);
HV *hash;
hash = newHV();
hv_stores(hash,"have_status",newSViv(have_status));
if (have_status) {
___PERL_INSERT_HASH_COPYING_lrstat
std::string a_bit = "";
while (_dsp_chain_id_text_queue.try_pop(a_bit)) {
id_instr += a_bit;
}
hv_stores(hash,"id_instr",newSVpv(id_instr.c_str(),id_instr.size()));
id_instr.clear();
}
return newRV_noinc((SV *)hash);
};
static void
Encode_XSEncoding(pTHX_ encode_t *enc)
{
dSP;
HV *stash = gv_stashpv("Encode::XS", TRUE);
SV *sv = sv_bless(newRV_noinc(newSViv(PTR2IV(enc))),stash);
int i = 0;
PUSHMARK(sp);
XPUSHs(sv);
while (enc->name[i])
{
const char *name = enc->name[i++];
XPUSHs(sv_2mortal(newSVpvn(name,strlen(name))));
}
PUTBACK;
call_pv("Encode::define_encoding",G_DISCARD);
SvREFCNT_dec(sv);
}
SV *val2perlval(db_val_t* val) {
SV* retval;
SV *class;
SV *p_data;
SV *p_type;
class = newSVpv(PERL_CLASS_VALUE, 0);
p_data = valdata(val);
p_type = newSViv(val->type);
retval = perlvdb_perlmethod(class, PERL_CONSTRUCTOR_NAME,
p_type, p_data, NULL, NULL);
return retval;
}
static JSBool
perlarray_enumerate(
JSContext *cx,
JSObject *obj,
JSIterateOp enum_op,
jsval *statep,
jsid *idp
) {
dTHX;
SV *ref = (SV *)JS_GetPrivate(cx, obj);
AV *av = (AV *)SvRV(ref);
PJS_ARRAY_CHECK
if(enum_op == JSENUMERATE_INIT) {
SV *cc = newSViv(0);
*statep = PRIVATE_TO_JSVAL(cc);
if(idp) {
I32 alen = av_len(av);
*idp = INT_TO_JSVAL(alen + 1);
}
return JS_TRUE;
}
if(enum_op == JSENUMERATE_NEXT) {
SV *cc = (SV *)JSVAL_TO_PRIVATE(*statep);
I32 alen = av_len(av);
I32 curr;
if(!SvIOK(cc)) {
JS_ReportError(cx, "Wrong Array iterator");
return JS_FALSE;
}
curr = (I32)SvIVX(cc);
if(curr > alen) { // At end
*statep = JSVAL_NULL;
sv_free(cc);
} else {
jsval key = INT_TO_JSVAL(curr);
SvIV_set(cc, (IV)(curr+1));
return JS_ValueToId(cx, key, idp);
}
}
return JS_TRUE;
}
SV *p5_wrap_p6_hash(
PerlInterpreter *my_perl,
IV i
) {
PERL_SET_CONTEXT(my_perl);
{
int flags = G_SCALAR;
dSP;
SV * inst;
SV * inst_ptr;
inst_ptr = newSViv(0); // will be upgraded to an RV
inst = newSVrv(inst_ptr, "Perl6::Object");
_perl6_hash_magic priv;
/* set up magic */
priv.key = PERL6_HASH_MAGIC_KEY;
priv.index = i;
sv_magicext(inst, inst, PERL_MAGIC_ext, &p5_inline_hash_mg_vtbl, (char *) &priv, sizeof(priv));
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs(newSVpv("Perl6::Hash", 0));
XPUSHs(inst_ptr);
PUTBACK;
call_method("new", flags);
SPAGAIN;
SV *tied_handle = POPs;
SvREFCNT_inc(tied_handle);
PUTBACK;
FREETMPS;
LEAVE;
return tied_handle;
}
}
SV *
getFieldTypeAsSV ( BrokerTypeDef type_def, char * key )
{
short type;
gErr = awGetTypeDefFieldType ( type_def, key, &type );
if ( gErr != AW_NO_ERROR )
return ( Nullsv );
if ( type == FIELD_TYPE_SEQUENCE )
return ( getFieldTypeFromAV( type_def, key ) );
if ( type == FIELD_TYPE_STRUCT )
return ( getFieldTypeFromHV( type_def, key ) );
return ( newSViv ( (int)type ) );
}
static void call_perl(struct req_state *state){
hv_store(state->rethash, "received", 8, newSViv(1) , 0);
ev_timer_stop(EV_DEFAULT, &(state->timer) );
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
XPUSHs( state->req_obj );
PUTBACK;
call_sv(state->parent_listener->callback, G_VOID);
free_state( state );
FREETMPS;
LEAVE;
};
SV*
Widget_fetch_resource( char *className, char *name, char *classRes, char *res, Handle owner, int resType)
{
char *str = nil;
Color clr;
void *parm;
Font font;
SV * ret;
switch ( resType) {
case frColor:
parm = &clr;
break;
case frFont:
parm = &font;
bzero( &font, sizeof( font));
break;
default:
parm = &str;
resType = frString;
}
if ( !apc_fetch_resource(
prima_normalize_resource_string( className, true),
prima_normalize_resource_string( name, false),
prima_normalize_resource_string( classRes, true),
prima_normalize_resource_string( res, false),
owner, resType, parm))
return nilSV;
switch ( resType) {
case frColor:
ret = newSViv( clr);
break;
case frFont:
ret = sv_Font2HV( &font);
break;
default:
ret = str ? newSVpv( str, 0) : nilSV;
free( str);
}
return ret;
}
SV *
Drawable_get_font_ranges( Handle self)
{
int count = 0;
unsigned long * ret;
AV * av = newAV();
gpARGS;
gpENTER( newRV_noinc(( SV *) av));
ret = apc_gp_get_font_ranges( self, &count);
gpLEAVE;
if ( ret) {
int i;
for ( i = 0; i < count; i++)
av_push( av, newSViv( ret[i]));
free( ret);
}
return newRV_noinc(( SV *) av);
}
static void boot_core_cperl(pTHX) {
const char he_name1[] = "feature_signatures";
const char he_name2[] = "feature_lexsubs";
SV* on = newSViv(1);
/* use feature "signatures";
i.e. $^H{$feature{signatures}} = 1; */
/* This broke CM-364 by nasty side-effect. HINT_LOCALIZE_HH was added to fix
strtable global destruction issues with wrong refcounts.
So we get now only signatures and lexsubs for free.
PL_hints |= HINT_LOCALIZE_HH | (FEATURE_BUNDLE_515 << HINT_FEATURE_SHIFT);
*/
CopHINTHASH_set(&PL_compiling,
cophh_store_pvn(CopHINTHASH_get(&PL_compiling), he_name1, sizeof(he_name1)-1, 0,
on, 0));
CopHINTHASH_set(&PL_compiling,
cophh_store_pvn(CopHINTHASH_get(&PL_compiling), he_name2, sizeof(he_name2)-1, 0,
on, 0));
SvREFCNT(on) = 2;
}
static SV *
list_item_to_sv ( xchat_list *list, const char *const *fields )
{
HV *hash = newHV();
SV *field_value;
const char *field;
int field_index = 0;
const char *field_name;
int name_len;
while (fields[field_index] != NULL) {
field_name = fields[field_index] + 1;
name_len = strlen (field_name);
switch (fields[field_index][0]) {
case 's':
field = xchat_list_str (ph, list, field_name);
if (field != NULL) {
field_value = newSVpvn (field, strlen (field));
} else {
field_value = &PL_sv_undef;
}
break;
case 'p':
field_value = newSViv (PTR2IV (xchat_list_str (ph, list,
field_name)));
break;
case 'i':
field_value = newSVuv (xchat_list_int (ph, list, field_name));
break;
case 't':
field_value = newSVnv (xchat_list_time (ph, list, field_name));
break;
default:
field_value = &PL_sv_undef;
}
hv_store (hash, field_name, name_len, field_value, 0);
field_index++;
}
return sv_2mortal (newRV_noinc ((SV *) hash));
}
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;
}
}
SV *cond2perlcond(db_key_t key, db_op_t op, db_val_t* val) {
SV* retval;
SV *class;
SV *p_key;
SV *p_op;
SV *p_type;
SV *p_data;
class = newSVpv(PERL_CLASS_REQCOND, 0);
p_key = newSVpv(key->s, key->len);
p_op = newSVpv(op, strlen(op));
p_type = newSViv(val->type);
p_data = valdata(val);
retval = perlvdb_perlmethod(class, PERL_CONSTRUCTOR_NAME,
p_key, p_op, p_type, p_data);
return retval;
}
SV * newSVGdkTimeCoord(GdkTimeCoord * v)
{
HV * h;
SV * r;
if (!v)
return newSVsv(&PL_sv_undef);
h = newHV();
r = newRV((SV*)h);
SvREFCNT_dec(h);
hv_store(h, "time", 4, newSViv(v->time), 0);
hv_store(h, "x", 1, newSVnv(v->x), 0);
hv_store(h, "y", 1, newSVnv(v->y), 0);
hv_store(h, "pressure", 8, newSVnv(v->pressure), 0);
hv_store(h, "xtilt", 5, newSVnv(v->xtilt), 0);
hv_store(h, "ytilt", 5, newSVnv(v->ytilt), 0);
return r;
}
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;
}
SV *pair2perlpair(db_key_t key, db_val_t* val) {
SV* retval;
SV *class;
SV *p_key;
SV *p_type;
SV *p_data;
class = newSVpv(PERL_CLASS_PAIR, 0);
p_key = newSVpv(key->s, key->len);
p_type = newSViv(val->type);
p_data = valdata(val);
retval = perlvdb_perlmethod(class, PERL_CONSTRUCTOR_NAME,
p_key, p_type, p_data, NULL);
SvREFCNT_dec(class);
return retval;
}
static gboolean
perl_worker_vp_add_one(const gchar *name,
TypeHint type, const gchar *value,
gpointer user_data)
{
PerlInterpreter *my_perl = (PerlInterpreter *)((gpointer *)user_data)[0];
HV *kvmap = (HV *)((gpointer *)user_data)[1];
PerlDestDriver *self = (PerlDestDriver *)((gpointer *)user_data)[2];
gboolean need_drop = FALSE;
gboolean fallback = self->template_options.on_error & ON_ERROR_FALLBACK_TO_STRING;
switch (type)
{
case TYPE_HINT_INT32:
{
gint32 i;
if (type_cast_to_int32(value, &i, NULL))
hv_store(kvmap, name, strlen(name), newSViv(i), 0);
else
{
need_drop = type_cast_drop_helper(self->template_options.on_error,
value, "int");
if (fallback)
hv_store(kvmap, name, strlen(name), newSVpv(value, 0), 0);
}
break;
}
case TYPE_HINT_STRING:
hv_store(kvmap, name, strlen(name), newSVpv(value, 0), 0);
break;
default:
need_drop = type_cast_drop_helper(self->template_options.on_error,
value, "<unknown>");
break;
}
return need_drop;
}
