void
LUCY_Doc_Set_Fields_IMP(lucy_Doc *self, void *fields) {
dTHX;
lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
if (ivars->fields) { SvREFCNT_dec((SV*)ivars->fields); }
ivars->fields = SvREFCNT_inc((SV*)fields);
}
void decode_tuple(pTHX_ unsigned char *input, STRLEN len, struct cc_type *type, SV *output)
{
SV *the_rv;
AV *the_tuple;
struct cc_tuple *tuple;
int i;
STRLEN pos;
the_tuple = newAV();
the_rv = newRV_noinc((SV*)the_tuple);
sv_setsv(output, the_rv);
SvREFCNT_dec(the_rv);
tuple = type->tuple;
assert(tuple);
pos = 0;
for (i = 0; i < tuple->field_count; i++) {
struct cc_type *type = &tuple->fields[i];
SV *decoded = newSV(0);
av_push(the_tuple, decoded);
decode_cell(aTHX_ input, len, &pos, type, decoded);
}
}
lucy_Doc*
LUCY_Doc_Load_IMP(lucy_Doc *self, cfish_Obj *dump) {
dTHX;
cfish_Hash *source = (cfish_Hash*)CFISH_CERTIFY(dump, CFISH_HASH);
cfish_String *class_name = (cfish_String*)CFISH_CERTIFY(
CFISH_Hash_Fetch_Utf8(source, "_class", 6),
CFISH_STRING);
cfish_Class *klass = cfish_Class_singleton(class_name, NULL);
lucy_Doc *loaded = (lucy_Doc*)CFISH_Class_Make_Obj(klass);
cfish_Obj *doc_id = CFISH_CERTIFY(
CFISH_Hash_Fetch_Utf8(source, "doc_id", 7),
CFISH_OBJ);
cfish_Hash *fields = (cfish_Hash*)CFISH_CERTIFY(
CFISH_Hash_Fetch_Utf8(source, "fields", 6),
CFISH_HASH);
SV *fields_sv = XSBind_cfish_to_perl(aTHX_ (cfish_Obj*)fields);
CFISH_UNUSED_VAR(self);
lucy_DocIVARS *const loaded_ivars = lucy_Doc_IVARS(loaded);
loaded_ivars->doc_id = (int32_t)lucy_Json_obj_to_i64(doc_id);
loaded_ivars->fields = SvREFCNT_inc(SvRV(fields_sv));
SvREFCNT_dec(fields_sv);
return loaded;
}
lucy_RegexTokenizer*
lucy_RegexTokenizer_init(lucy_RegexTokenizer *self,
const lucy_CharBuf *pattern) {
SV *token_re_sv;
lucy_Analyzer_init((lucy_Analyzer*)self);
#define DEFAULT_PATTERN "\\w+(?:['\\x{2019}]\\w+)*"
if (pattern) {
if (Lucy_CB_Find_Str(pattern, "\\p", 2) != -1
|| Lucy_CB_Find_Str(pattern, "\\P", 2) != -1
) {
CFISH_DECREF(self);
THROW(LUCY_ERR, "\\p and \\P constructs forbidden");
}
self->pattern = Lucy_CB_Clone(pattern);
}
else {
self->pattern = lucy_CB_new_from_trusted_utf8(
DEFAULT_PATTERN, sizeof(DEFAULT_PATTERN) - 1);
}
// Acquire a compiled regex engine for matching one token.
token_re_sv = (SV*)lucy_Host_callback_host(
LUCY_REGEXTOKENIZER, "compile_token_re", 1,
CFISH_ARG_STR("pattern", self->pattern));
S_set_token_re_but_not_pattern(self, SvRV(token_re_sv));
SvREFCNT_dec(token_re_sv);
return self;
}
static long sv_to_dimension(pTHX_ SV *sv, const char *member)
{
SV *warning;
const char *value = NULL;
assert(sv != NULL);
SvGETMAGIC(sv);
if (SvOK(sv) && !SvROK(sv))
{
if (looks_like_number(sv))
{
return SvIV(sv);
}
value = SvPV_nolen(sv);
}
warning = newSVpvn("", 0);
if (value) sv_catpvf(warning, " ('%s')", value);
if (member) sv_catpvf(warning, " in '%s'", member);
WARN((aTHX_ "Cannot use %s%s as dimension", identify_sv(sv), SvPV_nolen(warning)));
SvREFCNT_dec(warning);
return 0;
}
void decode_list(pTHX_ unsigned char *input, STRLEN len, struct cc_type *type, SV *output)
{
struct cc_type *inner_type;
int i;
AV *the_list;
SV *the_rv;
STRLEN pos;
inner_type = type->inner_type;
assert(inner_type);
if (UNLIKELY(len < 4))
croak("decode_list: len < 4");
int32_t num_elements = (int32_t)ntohl(*(uint32_t*)(input));
if (UNLIKELY(num_elements < 0))
croak("decode_list: num_elements < 0");
the_list = newAV();
the_rv = newRV_noinc((SV*)the_list);
sv_setsv(output, the_rv);
SvREFCNT_dec(the_rv);
pos = 4;
for (i = 0; i < num_elements; i++) {
SV *decoded = newSV(0);
av_push(the_list, decoded);
decode_cell(aTHX_ input, len, &pos, inner_type, decoded);
}
}
static void
destroy_cmd_handler(PurplePerlCmdHandler *handler)
{
purple_cmd_unregister(handler->id);
cmd_handlers = g_slist_remove(cmd_handlers, handler);
if (handler->callback != NULL)
SvREFCNT_dec(handler->callback);
if (handler->data != NULL)
SvREFCNT_dec(handler->data);
g_free(handler->cmd);
g_free(handler->prpl_id);
g_free(handler);
}
static void coroae_int(void) {
uwsgi_log("Brutally killing worker %d (pid: %d)...\n", uwsgi.mywid, uwsgi.mypid);
uwsgi.workers[uwsgi.mywid].manage_next_request = 0;
SvREFCNT_dec(ucoroae.watchers);
coroae_condvar_call(ucoroae.condvar, "send");
}
/*----------------------------------------------------------------------------
perl_substitute__()
The pattern substitution function which includes loading perl interpreter
and doing the pattern substitution, then returning the replaced string.
arguments:
input: char* string, input text
char* pattern, match pattern
output:char* string, output text
----------------------------------------------------------------------------*/
int perl_substitute__( void )
{
SV *text; /* Perl representation for the string to be
modified by substitution */
char *subst_cmd = ptoc_string(2);
int i;
/* first load the perl interpreter, if unloaded */
if (perlObjectStatus == UNLOADED) load_perl__();
text = newSV(0);
sv_setpv(text, ptoc_string(1)); /* put the string to the SV */
if( !substitute(&text, subst_cmd) )
return(FAILURE);
global_pattern_mode = is_global_pattern(subst_cmd);
if (substituteString != NULL ) free(substituteString);
substituteString = malloc(strlen(SvPV(text,PL_na))+1);
strcpy(substituteString,SvPV(text,PL_na));
SvREFCNT_dec(text); /*release space*/
ctop_string(3, string_find(substituteString,1)); /*return changed text*/
return SUCCESS;
}
USER_OBJECT_
RS_discardPerlForeignReference(USER_OBJECT_ obj)
{
const char *key;
USER_OBJECT_ ans = NEW_LOGICAL(1);
#ifndef USE_NEW_PERL_REFERENCES
if(IS_CHARACTER(obj)) {
key = CHAR_DEREF(STRING_ELT(obj, 0));
} else {
key = CHAR_DEREF(STRING_ELT(VECTOR_ELT(obj, 0), 0));
}
LOGICAL_DATA(ans)[0] = discardPerlForeignReference(key, NULL);
#else
SV *el;
dTHX;
el = getForeignPerlReference(obj);
if(el) {
SvREFCNT_dec(obj);
LOGICAL_DATA(ans)[0] = 1;
}
#endif
return(ans);
}
static void
destroy_prefs_handler(PurplePerlPrefsHandler *handler)
{
pref_handlers = g_slist_remove(pref_handlers, handler);
if (handler->iotag > 0)
purple_prefs_disconnect_callback(handler->iotag);
if (handler->callback != NULL)
SvREFCNT_dec(handler->callback);
if (handler->data != NULL)
SvREFCNT_dec(handler->data);
g_free(handler);
}
void decode_udt(pTHX_ unsigned char *input, STRLEN len, struct cc_type *type, SV *output)
{
struct cc_udt *udt;
int i;
STRLEN pos;
HV *the_obj;
SV *the_rv;
the_obj = newHV();
the_rv = newRV_noinc((SV*)the_obj);
sv_setsv(output, the_rv);
SvREFCNT_dec(the_rv);
udt = type->udt;
assert(udt && udt->fields);
pos = 0;
for (i = 0; i < udt->field_count; i++) {
if (len == pos) {
break;
}
struct cc_udt_field *field;
SV *value;
field = &udt->fields[i];
value = newSV(0);
hv_store_ent(the_obj, field->name, value, field->name_hash);
decode_cell(aTHX_ input, len, &pos, &field->type, value);
}
}
SV*
newPerlPyObject_noinc(PyObject *pyo)
{
SV* rv;
SV* sv;
MAGIC *mg;
dCTXP;
ASSERT_LOCK_PERL;
if (!pyo)
croak("Missing pyo reference argument");
rv = newSV(0);
sv = newSVrv(rv, "Python::Object");
sv_setiv(sv, (IV)pyo);
sv_magic(sv, 0, '~', 0, 0);
mg = mg_find(sv, '~');
if (!mg) {
SvREFCNT_dec(rv);
croak("Can't assign magic to Python::Object");
}
mg->mg_virtual = &vtbl_free_pyo;
SvREADONLY(sv);
#ifdef REF_TRACE
printf("Bind pyo %p\n", pyo);
#endif
ASSERT_LOCK_PERL;
return rv;
}
KHARON_DECL void
kharon_perl_free(ssp_val *ret)
{
D(fprintf(stderr, "decrementing ref count on %p\n", *ret));
SvREFCNT_dec(*ret);
}
void fatal(const char *f, ...)
{
dTHX;
va_list l;
SV *sv = newSVpvn("", 0);
va_start(l, f);
sv_catpv(sv,
"============================================\n"
" FATAL ERROR in " XSCLASS "!\n"
"--------------------------------------------\n"
);
sv_vcatpvf(sv, f, &l);
sv_catpv(sv,
"\n"
"--------------------------------------------\n"
" please report this error to [email protected]\n"
"============================================\n"
);
va_end(l);
fprintf(stderr, "%s", SvPVX(sv));
SvREFCNT_dec(sv);
abort();
}
MP_INLINE SV *modperl_dir_config(pTHX_ request_rec *r, server_rec *s,
char *key, SV *sv_val)
{
SV *retval = &PL_sv_undef;
if (r && r->per_dir_config) {
MP_dDCFG;
retval = modperl_table_get_set(aTHX_ dcfg->configvars,
key, sv_val, FALSE);
}
if (!SvOK(retval)) {
if (s && s->module_config) {
MP_dSCFG(s);
SvREFCNT_dec(retval); /* in case above did newSV(0) */
retval = modperl_table_get_set(aTHX_ scfg->configvars,
key, sv_val, FALSE);
}
else {
retval = &PL_sv_undef;
}
}
return retval;
}
void
Perl_set_numeric_radix(pTHX)
{
#ifdef USE_LOCALE_NUMERIC
dVAR;
# ifdef HAS_LOCALECONV
const struct lconv* const lc = localeconv();
if (lc && lc->decimal_point) {
if (lc->decimal_point[0] == '.' && lc->decimal_point[1] == 0) {
SvREFCNT_dec(PL_numeric_radix_sv);
PL_numeric_radix_sv = NULL;
}
else {
if (PL_numeric_radix_sv)
sv_setpv(PL_numeric_radix_sv, lc->decimal_point);
else
PL_numeric_radix_sv = newSVpv(lc->decimal_point, 0);
}
}
else
PL_numeric_radix_sv = NULL;
# endif /* HAS_LOCALECONV */
#endif /* USE_LOCALE_NUMERIC */
}
MP_INLINE apr_size_t modperl_input_filter_read(pTHX_
modperl_filter_t *filter,
SV *buffer,
apr_size_t wanted)
{
apr_size_t len = 0;
if (!filter->bb_in) {
/* This should be read only once per handler invocation! */
filter->bb_in = apr_brigade_create(filter->pool,
filter->f->c->bucket_alloc);
MP_TRACE_f(MP_FUNC, MP_FILTER_NAME_FORMAT
"retrieving bb: 0x%lx",
MP_FILTER_NAME(filter->f),
(unsigned long)(filter->bb_in));
MP_RUN_CROAK(ap_get_brigade(filter->f->next, filter->bb_in,
filter->input_mode, filter->block,
filter->readbytes),
"Apache2::Filter::read");
}
len = modperl_filter_read(aTHX_ filter, buffer, wanted);
if (filter->flush && len == 0) {
/* if len > 0 then $filter->write will flush */
apr_status_t rc = modperl_input_filter_flush(filter);
if (rc != APR_SUCCESS) {
SvREFCNT_dec(buffer);
modperl_croak(aTHX_ rc, "Apache2::Filter::read");
}
}
return len;
}
void sar_cleanAll_c(sarNode_p node) {
if (node == (sarNode_p)NULL) {
return;
}
int charNumber = node->charNumber;
if (charNumber > 0) {
int i;
for(i=0; i<charNumber; ++i) {
sar_cleanAll_c(node->sarNodes[i]);
}
}
Safefree(node->sarPathChars);
Safefree(node->sarNodes);
int currCallIdx = 0;
while ( node->callFunc[currCallIdx] != (SV*)NULL ) {
SvREFCNT_dec(node->callFunc[currCallIdx]);
++currCallIdx;
}
Safefree(node->callFunc);
sar_cleanAll_c(node->plusNode);
sar_cleanAll_c(node->digitNode);
sar_cleanAll_c(node->alphaNumNode);
sar_cleanAll_c(node->alphaNode);
sar_cleanAll_c(node->dotNode);
sar_cleanAll_c(node->spaceNode);
sar_cleanAll_c(node->negativeNode);
Safefree(node);
}
lucy_Doc*
LUCY_Doc_Deserialize_IMP(lucy_Doc *self, lucy_InStream *instream) {
int32_t doc_id = (int32_t)LUCY_InStream_Read_C32(instream);
HV *fields = S_thaw_fields(instream);
lucy_Doc_init(self, fields, doc_id);
SvREFCNT_dec(fields);
return self;
}
static void
S_set_pattern_from_token_re(lucy_RegexTokenizer *self, void *token_re) {
SV *rv = newRV((SV*)token_re);
STRLEN len = 0;
char *ptr = SvPVutf8((SV*)rv, len);
Lucy_CB_Mimic_Str(self->pattern, ptr, len);
SvREFCNT_dec(rv);
}
void post_callback(const I32 ax, SV **sp, I32 items, SV * const args_rv, SV *err, SV *retval) {
/* refresh local stack pointer, could have been modified by Perl 5 code called from Perl 6 */
SPAGAIN;
SvREFCNT_dec(args_rv);
handle_p6_error(err);
sv_2mortal(retval);
sp -= items;
return return_retval(ax, sp, retval);
}
void
LUCY_Doc_Destroy_IMP(lucy_Doc *self) {
lucy_DocIVARS *const ivars = lucy_Doc_IVARS(self);
if (ivars->fields) {
dTHX;
SvREFCNT_dec((SV*)ivars->fields);
}
CFISH_SUPER_DESTROY(self, LUCY_DOC);
}
static void coroae_loop() {
if (uwsgi.async < 1) {
if (uwsgi.mywid == 1) {
uwsgi_log("the Coro::AnyEvent loop engine requires async mode (--async <n>)\n");
}
exit(1);
}
if (!uperl.loaded) {
uwsgi_log("no perl/PSGI code loaded (with --psgi), unable to initialize Coro::AnyEvent\n");
exit(1);
}
perl_eval_pv("use Coro;", 1);
perl_eval_pv("use AnyEvent;", 1);
perl_eval_pv("use Coro::AnyEvent;", 1);
uwsgi.current_wsgi_req = coroae_current_wsgi_req;
uwsgi.wait_write_hook = coroae_wait_fd_write;
uwsgi.wait_read_hook = coroae_wait_fd_read;
uwsgi.wait_milliseconds_hook = coroae_wait_milliseconds;
I_CORO_API("uwsgi::coroae");
// patch goodbye_cruel_world
uwsgi.gbcw_hook = coroae_gbcw;
ucoroae.watchers = newAV();
av_push(ucoroae.watchers, coroae_add_signal_watcher("HUP", newXS(NULL, XS_coroae_hup_sighandler, "uwsgi::coroae")));
av_push(ucoroae.watchers, coroae_add_signal_watcher("INT", newXS(NULL, XS_coroae_int_sighandler, "uwsgi::coroae")));
av_push(ucoroae.watchers, coroae_add_signal_watcher("TERM", newXS(NULL, XS_coroae_int_sighandler, "uwsgi::coroae")));
// create signal watchers
if (uwsgi.signal_socket > -1) {
av_push(ucoroae.watchers, coroae_add_watcher(uwsgi.signal_socket, coroae_closure_sighandler(uwsgi.signal_socket)));
av_push(ucoroae.watchers, coroae_add_watcher(uwsgi.my_signal_socket, coroae_closure_sighandler(uwsgi.my_signal_socket)));
}
struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
while(uwsgi_sock) {
// check return value here
av_push(ucoroae.watchers, coroae_add_watcher(uwsgi_sock->fd, coroae_closure_acceptor(uwsgi_sock)));
uwsgi_sock = uwsgi_sock->next;
};
ucoroae.condvar = coroae_condvar_new();
coroae_condvar_call(ucoroae.condvar, "recv");
SvREFCNT_dec(ucoroae.condvar);
if (uwsgi.workers[uwsgi.mywid].manage_next_request == 0) {
uwsgi_log("goodbye to the Coro::AnyEvent loop on worker %d (pid: %d)\n", uwsgi.mywid, uwsgi.mypid);
exit(UWSGI_RELOAD_CODE);
}
uwsgi_log("the Coro::AnyEvent loop is no more :(\n");
}
void PJS_finalize(JSContext *cx, JSObject *obj) {
void *ptr = JS_GetPrivate(cx, obj);
if(ptr != NULL) {
if (SvTYPE((SV *) ptr) == SVt_RV) {
SvREFCNT_dec(SvRV((SV *) ptr));
}
}
}
void
Rperl_ReleaseReference(SEXP el)
{
SV *sv = R_ExternalPtrAddr(el);
dTHX;
if(sv)
SvREFCNT_dec(sv);
}
SV* call_ftn(SV* arg) {
append_to_log_file(refcount_to_string("Refcount 3 (inside the callee):", SvREFCNT(arg)));
FILE* fp;
fp = fopen("print_scalar.txt", "w");
fprintf(fp, "%s", SvPV_nolen(arg));
fclose(fp);
SvREFCNT_dec(arg);
append_to_log_file(refcount_to_string("Refcount 4 (inside the callee, after dec):", SvREFCNT(arg)));
return arg;
}
IV
PerlIOScalar_popped(pTHX_ PerlIO * f)
{
PerlIOScalar *s = PerlIOSelf(f, PerlIOScalar);
if (s->var) {
SvREFCNT_dec(s->var);
s->var = Nullsv;
}
return 0;
}
static gboolean
destroy_timeout_handler(PurplePerlTimeoutHandler *handler)
{
gboolean ret = FALSE;
timeout_handlers = g_slist_remove(timeout_handlers, handler);
if (handler->iotag > 0)
ret = purple_timeout_remove(handler->iotag);
if (handler->callback != NULL)
SvREFCNT_dec(handler->callback);
if (handler->data != NULL)
SvREFCNT_dec(handler->data);
g_free(handler);
return ret;
}
void
srl_deinit_iterator(pTHX_ srl_iterator_t *iter)
{
assert(iter != NULL);
if (iter->dec)
srl_destroy_decoder(aTHX_ iter->dec);
if (iter->document)
SvREFCNT_dec(iter->document);
}
