HashTable *properties = NULL;
zend_string *class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(Z_OBJ_P(expr));
zend_printf("%s Object (", ZSTR_VAL(class_name));
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
if (Z_IS_RECURSIVE_P(expr)) {
ZEND_PUTS(" *RECURSION*");
zend_string *class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(Z_OBJ_P(expr));
smart_str_appends(buf, ZSTR_VAL(class_name));
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
smart_str_appends(buf, " Object\n");
if (Z_IS_RECURSIVE_P(expr)) {
{
zend_string *str = zval_get_string_func(expr);
smart_str_append(buf, str);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
break;
}
{
zend_string *str = zend_print_zval_r_to_str(expr, indent);
zend_write(ZSTR_VAL(str), ZSTR_LEN(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
/* }}} */
if (class_name && class_name[0] != '*') {
zend_string *cname = zend_string_init(class_name, strlen(class_name), 0);
EG(fake_scope) = zend_lookup_class(cname);
- zend_string_release(cname);
+ zend_string_release_ex(cname, 0);
}
property_info = zend_get_property_info(object->ce, pname, 1);
- zend_string_release(pname);
+ zend_string_release_ex(pname, 0);
EG(fake_scope) = prev_scope;
} else {
property_info = ZEND_WRONG_PROPERTY_INFO;
lcname = zend_new_interned_string(lcname);
if ((module_ptr = zend_hash_add_mem(&module_registry, lcname, module, sizeof(zend_module_entry))) == NULL) {
zend_error(E_CORE_WARNING, "Module '%s' already loaded", module->name);
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 1);
return NULL;
}
module = module_ptr;
if (module->functions && zend_register_functions(NULL, module->functions, NULL, module->type)==FAILURE) {
zend_hash_del(&module_registry, lcname);
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 1);
EG(current_module) = NULL;
zend_error(E_CORE_WARNING,"%s: Unable to register functions, unable to load", module->name);
return NULL;
}
EG(current_module) = NULL;
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 1);
return module;
}
/* }}} */
if (zend_hash_add_ptr(target_function_table, lowercase_name, reg_function) == NULL) {
unload=1;
free(reg_function);
- zend_string_release(lowercase_name);
+ zend_string_release_ex(lowercase_name, 1);
break;
}
}
ptr++;
count++;
- zend_string_release(lowercase_name);
+ zend_string_release_ex(lowercase_name, 1);
}
if (unload) { /* before unloading, display all remaining bad function in the module */
if (scope) {
lowercase_name = zend_string_tolower_ex(orig_class_entry->name, 1);
lowercase_name = zend_new_interned_string(lowercase_name);
zend_hash_update_ptr(CG(class_table), lowercase_name, class_entry);
- zend_string_release(lowercase_name);
+ zend_string_release_ex(lowercase_name, 1);
return class_entry;
}
/* }}} */
lcname = zend_new_interned_string(lcname);
ce = zend_hash_add_ptr(CG(class_table), lcname, ce);
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
if (ce) {
ce->refcount++;
return SUCCESS;
key = zend_string_alloc(class_name_length, 0);
zend_str_tolower_copy(ZSTR_VAL(key), class_name, class_name_length);
disabled_class = zend_hash_find_ptr(CG(class_table), key);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
if (!disabled_class) {
return FAILURE;
}
cname = zend_string_init(Z_STRVAL_P(callable), clen, 0);
if (!zend_is_callable_check_class(cname, scope, fcc, &strict_class, error)) {
- zend_string_release(cname);
+ zend_string_release_ex(cname, 0);
return 0;
}
- zend_string_release(cname);
+ zend_string_release_ex(cname, 0);
ftable = &fcc->calling_scope->function_table;
if (ce_org && !instanceof_function(ce_org, fcc->calling_scope)) {
if (fcc->function_handler->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
if (fcc->function_handler->type != ZEND_OVERLOADED_FUNCTION &&
fcc->function_handler->common.function_name) {
- zend_string_release(fcc->function_handler->common.function_name);
+ zend_string_release_ex(fcc->function_handler->common.function_name, 0);
}
zend_free_trampoline(fcc->function_handler);
}
if (error) zend_spprintf(error, 0, "function '%s' does not exist", ZSTR_VAL(mname));
}
}
- zend_string_release(lmname);
- zend_string_release(mname);
+ zend_string_release_ex(lmname, 0);
+ zend_string_release_ex(mname, 0);
if (fcc->object) {
fcc->called_scope = fcc->object->ce;
fcc->function_handler->type == ZEND_OVERLOADED_FUNCTION)) {
if (fcc->function_handler->type != ZEND_OVERLOADED_FUNCTION &&
fcc->function_handler->common.function_name) {
- zend_string_release(fcc->function_handler->common.function_name);
+ zend_string_release_ex(fcc->function_handler->common.function_name, 0);
}
zend_free_trampoline(fcc->function_handler);
}
fcc.function_handler->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY ||
fcc.function_handler->type == ZEND_OVERLOADED_FUNCTION)) {
if (fcc.function_handler->type != ZEND_OVERLOADED_FUNCTION) {
- zend_string_release(fcc.function_handler->common.function_name);
+ zend_string_release_ex(fcc.function_handler->common.function_name, 0);
}
zend_free_trampoline(fcc.function_handler);
}
str = zend_string_init(name, name_length, 0);
value = zend_read_property_ex(scope, object, str, silent, rv);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
return value;
}
/* }}} */
goto tail_call;
}
} else if (EXPECTED(ast->kind == ZEND_AST_CONSTANT)) {
- zend_string_release(zend_ast_get_constant_name(ast));
+ zend_string_release_ex(zend_ast_get_constant_name(ast), 0);
} else if (EXPECTED(ast->kind >= ZEND_AST_FUNC_DECL)) {
zend_ast_decl *decl = (zend_ast_decl *) ast;
if (decl->name) {
- zend_string_release(decl->name);
+ zend_string_release_ex(decl->name, 0);
}
if (decl->doc_comment) {
- zend_string_release(decl->doc_comment);
+ zend_string_release_ex(decl->doc_comment, 0);
}
zend_ast_destroy(decl->child[0]);
zend_ast_destroy(decl->child[1]);
case IS_DOUBLE:
key = zend_strpprintf(0, "%.*G", (int) EG(precision), Z_DVAL_P(zv));
smart_str_appendl(str, ZSTR_VAL(key), ZSTR_LEN(key));
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
break;
case IS_STRING:
smart_str_appendc(str, '\'');
{
zend_string *key = zend_string_init("zend.enable_gc", sizeof("zend.enable_gc")-1, 0);
zend_alter_ini_entry_chars(key, "1", sizeof("1")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
/* }}} */
{
zend_string *key = zend_string_init("zend.enable_gc", sizeof("zend.enable_gc")-1, 0);
zend_alter_ini_entry_chars(key, "0", sizeof("0")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
/* }}} */
p->modified = 1;
}
} else if (p->orig_value != p->value) {
- zend_string_release(p->value);
+ zend_string_release_ex(p->value, 0);
}
p->value = new_val;
}
lcname = zend_string_tolower(name);
ret = memcmp(ZSTR_VAL(lcname), ZSTR_VAL(key), ZSTR_LEN(key)) == 0;
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
return ret;
}
/* }}} */
lcname = zend_string_tolower(method_name);
if (zend_hash_exists(&ce->function_table, lcname)) {
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
RETURN_TRUE;
} else {
union _zend_function *func = NULL;
RETVAL_BOOL(func->common.scope == zend_ce_closure
&& zend_string_equals_literal(method_name, ZEND_INVOKE_FUNC_NAME));
- zend_string_release(lcname);
- zend_string_release(func->common.function_name);
+ zend_string_release_ex(lcname, 0);
+ zend_string_release_ex(func->common.function_name, 0);
zend_free_trampoline(func);
return;
}
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
RETURN_TRUE;
}
}
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
RETURN_FALSE;
}
/* }}} */
}
ce = zend_hash_find_ptr(EG(class_table), lc_name);
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
} else {
ce = zend_lookup_class(class_name);
}
lc_name = zend_string_tolower(iface_name);
}
ce = zend_hash_find_ptr(EG(class_table), lc_name);
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
RETURN_BOOL(ce && ce->ce_flags & ZEND_ACC_INTERFACE);
}
}
ce = zend_hash_find_ptr(EG(class_table), lc_name);
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
} else {
ce = zend_lookup_class(trait_name);
}
}
func = zend_hash_find_ptr(EG(function_table), lcname);
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
/*
* A bit of a hack, but not a bad one: we see if the handler of the function
zend_string *error_handler_name = zend_get_callable_name(error_handler);
zend_error(E_WARNING, "%s() expects the argument (%s) to be a valid callback",
get_active_function_name(), error_handler_name?ZSTR_VAL(error_handler_name):"unknown");
- zend_string_release(error_handler_name);
+ zend_string_release_ex(error_handler_name, 0);
return;
}
}
zend_string *exception_handler_name = zend_get_callable_name(exception_handler);
zend_error(E_WARNING, "%s() expects the argument (%s) to be a valid callback",
get_active_function_name(), exception_handler_name?ZSTR_VAL(exception_handler_name):"unknown");
- zend_string_release(exception_handler_name);
+ zend_string_release_ex(exception_handler_name, 0);
return;
}
}
if (object
&& !func->common.scope
&& object->handlers->get_class_name != std_object_handlers.get_class_name) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
}
}
zend_printf("%s(", function_name);
} else {
RETVAL_FALSE;
}
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
}
/* }}} */
if (strncasecmp(ZSTR_VAL(extension_name), "zend", sizeof("zend"))) {
lcname = zend_string_tolower(extension_name);
module = zend_hash_find_ptr(&module_registry, lcname);
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
} else {
module = zend_hash_str_find_ptr(&module_registry, "core", sizeof("core") - 1);
}
}
/* destruct the function also, then - we have allocated it in get_method */
- zend_string_release(func->internal_function.function_name);
+ zend_string_release_ex(func->internal_function.function_name, 0);
efree(func);
#if ZEND_DEBUG
execute_data->func = NULL;
ce = closure->func.common.scope;
} else if ((ce = zend_lookup_class_ex(class_name, NULL, 1)) == NULL) {
zend_error(E_WARNING, "Class '%s' not found", ZSTR_VAL(class_name));
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
RETURN_NULL();
}
zend_tmp_string_release(tmp_class_name);
}
ZVAL_NEW_STR(&info, zend_strpprintf(0, "%s", i >= required ? "<optional>" : "<required>"));
zend_hash_update(Z_ARRVAL(val), name, &info);
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
arg_info++;
}
zend_hash_str_update(debug_info, "parameter", sizeof("parameter")-1, &val);
{
zend_property_info *property_info = Z_PTR_P(zv);
- zend_string_release(property_info->name);
+ zend_string_release_ex(property_info->name, 1);
free(property_info);
}
/* }}} */
FC(in_namespace) = 0;
zend_reset_import_tables();
if (FC(current_namespace)) {
- zend_string_release(FC(current_namespace));
+ zend_string_release_ex(FC(current_namespace), 0);
FC(current_namespace) = NULL;
}
}
/* }}} */
static void str_dtor(zval *zv) /* {{{ */ {
- zend_string_release(Z_STR_P(zv));
+ zend_string_release_ex(Z_STR_P(zv), 0);
}
/* }}} */
ZSTR_VAL(result)[left_len] = '\\';
memcpy(&ZSTR_VAL(result)[left_len + 1], ZSTR_VAL(right), ZSTR_LEN(right));
ZSTR_VAL(result)[len] = '\0';
- zend_string_release(right);
+ zend_string_release_ex(right, 0);
ZVAL_STR(left_zv, result);
return left_ast;
zend_ensure_valid_class_fetch_type(fetch_type);
}
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
} else {
opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node);
opline->op1.num = ZEND_FETCH_CLASS_DEFAULT | (throw_exception ? ZEND_FETCH_CLASS_EXCEPTION : 0);
result->u.op.num = fetch_type | fetch_flags;
}
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
} else {
zend_op *opline = zend_emit_op(result, ZEND_FETCH_CLASS, NULL, &name_node);
opline->op1.num = ZEND_FETCH_CLASS_DEFAULT | fetch_flags;
result->u.op.var = lookup_cv(CG(active_op_array), name);
if (UNEXPECTED(Z_TYPE_P(zv) != IS_STRING)) {
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
}
return SUCCESS;
zend_string *name1 = zval_get_string(zend_ast_get_zval(var_ast->child[0]));
zend_string *name2 = zval_get_string(zend_ast_get_zval(expr_ast->child[0]));
zend_bool result = zend_string_equals(name1, name2);
- zend_string_release(name1);
- zend_string_release(name2);
+ zend_string_release_ex(name1, 0);
+ zend_string_release_ex(name2, 0);
return result;
}
}
if (var_ast->kind == ZEND_AST_VAR && var_ast->child[0]->kind == ZEND_AST_ZVAL) {
zend_string *var_name = zval_get_string(zend_ast_get_zval(var_ast->child[0]));
zend_bool result = zend_string_equals(var_name, name);
- zend_string_release(var_name);
+ zend_string_release_ex(var_name, 0);
if (result) {
return 1;
}
if (expr_ast->kind == ZEND_AST_VAR && expr_ast->child[0]->kind == ZEND_AST_ZVAL) {
zend_string *name = zval_get_string(zend_ast_get_zval(expr_ast->child[0]));
zend_bool result = zend_list_has_assign_to(list_ast, name);
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
return result;
}
return 0;
name = zval_get_string(zend_ast_get_zval(args->child[0]));
if (zend_memrchr(ZSTR_VAL(name), '\\', ZSTR_LEN(name)) || zend_memrchr(ZSTR_VAL(name), ':', ZSTR_LEN(name))) {
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
return FAILURE;
}
if (zend_try_ct_eval_const(&result->u.constant, name, 0)) {
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
zval_ptr_dtor(&result->u.constant);
ZVAL_TRUE(&result->u.constant);
result->op_type = IS_CONST;
|| (fbc->type == ZEND_INTERNAL_FUNCTION && (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
|| (fbc->type == ZEND_USER_FUNCTION && (CG(compiler_options) & ZEND_COMPILE_IGNORE_USER_FUNCTIONS))
) {
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
return FAILURE;
}
opline = zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, &len_node);
opline->extended_value = Z_LVAL_P(zv);
zend_emit_op(result, ZEND_DO_FCALL, NULL, NULL);
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
return SUCCESS;
}
}
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
}
zend_compile_expr(&arg_node, args->child[1]);
zend_emit_op(NULL, ZEND_SEND_ARRAY, &arg_node, NULL);
SET_NODE(opline->result, result);
} else {
if (!fbc) {
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
}
result->op_type = IS_CONST;
ZVAL_TRUE(&result->u.constant);
zend_ast_get_str(name_ast), name_ast->attr, &is_fully_qualified);
if (!zend_try_ct_eval_const(&value, resolved_name, is_fully_qualified)) {
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
return FAILURE;
}
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
strict = zend_is_true(&value);
zval_ptr_dtor(&value);
} else {
first.op_type = IS_CONST;
ZVAL_LONG(&first.u.constant, Z_LVAL_P(zv));
zend_emit_op_tmp(result, ZEND_FUNC_GET_ARGS, &first, NULL);
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
return SUCCESS;
}
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
}
return FAILURE;
}
|| (fbc->type == ZEND_INTERNAL_FUNCTION && (CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS))
|| (fbc->type == ZEND_USER_FUNCTION && (CG(compiler_options) & ZEND_COMPILE_IGNORE_USER_FUNCTIONS))
) {
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
zend_compile_dynamic_call(result, &name_node, args_ast);
return;
}
if (zend_try_compile_special_func(result, lcname,
zend_ast_get_list(args_ast), fbc, type) == SUCCESS
) {
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
zval_ptr_dtor(&name_node.u.constant);
return;
}
}
}
- zend_string_release(encoding_name);
+ zend_string_release_ex(encoding_name, 0);
} else {
zend_error(E_COMPILE_WARNING, "declare(encoding=...) ignored because "
"Zend multibyte feature is turned off by settings");
}
}
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
}
/* }}} */
zend_add_literal_string(CG(active_op_array), &key);
}
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
}
/* }}} */
"is already in use", zend_get_use_type_str(type), ZSTR_VAL(old_name), ZSTR_VAL(new_name));
}
- zend_string_release(lookup_name);
- zend_string_release(new_name);
+ zend_string_release_ex(lookup_name, 0);
+ zend_string_release_ex(new_name, 0);
}
}
/* }}} */
zval *name_zval = zend_ast_get_zval(use->child[0]);
zend_string *name = Z_STR_P(name_zval);
zend_string *compound_ns = zend_concat_names(ZSTR_VAL(ns), ZSTR_LEN(ns), ZSTR_VAL(name), ZSTR_LEN(name));
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
ZVAL_STR(name_zval, compound_ns);
inline_use = zend_ast_create_list(1, ZEND_AST_USE, use);
inline_use->attr = ast->attr ? ast->attr : use->attr;
}
if (FC(current_namespace)) {
- zend_string_release(FC(current_namespace));
+ zend_string_release_ex(FC(current_namespace), 0);
}
if (name_ast) {
ZSTR_VAL(filename), ZSTR_LEN(filename), 0);
zend_register_long_constant(ZSTR_VAL(name), ZSTR_LEN(name), offset, CONST_CS, 0);
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
}
/* }}} */
if (last->kind == ZEND_AST_HALT_COMPILER) {
result->op_type = IS_CONST;
ZVAL_LONG(&result->u.constant, Z_LVAL_P(zend_ast_get_zval(last->child[0])));
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
return;
}
}
if (zend_try_ct_eval_const(&result->u.constant, resolved_name, is_fully_qualified)) {
result->op_type = IS_CONST;
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
return;
}
resolved_name = zend_resolve_class_name_ast(class_ast);
if (const_ast->kind == ZEND_AST_ZVAL && zend_try_ct_eval_class_const(&result->u.constant, resolved_name, zend_ast_get_str(const_ast))) {
result->op_type = IS_CONST;
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
return;
}
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
}
if (const_ast->kind == ZEND_AST_ZVAL && zend_string_equals_literal_ci(zend_ast_get_str(const_ast), "class")) {
zend_error_noreturn(E_COMPILE_ERROR,
ZSTR_VAL(class_name), ZSTR_LEN(class_name), "::", 2, ZSTR_VAL(const_name), ZSTR_LEN(const_name));
zend_ast_destroy(ast);
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
*ast_ptr = zend_ast_create_constant(name, fetch_type);
}
orig_name, name_ast->attr, &is_fully_qualified);
if (zend_try_ct_eval_const(&result, resolved_name, is_fully_qualified)) {
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
zend_ast_destroy(ast);
*ast_ptr = zend_ast_create_zval(&result);
return;
zend_ast_get_str(name_ast), name_ast->attr, &is_fully_qualified);
if (!zend_try_ct_eval_const(&result, resolved_name, is_fully_qualified)) {
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
return;
}
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
break;
}
case ZEND_AST_CLASS_CONST:
resolved_name = zend_resolve_class_name_ast(class_ast);
if (!zend_try_ct_eval_class_const(&result, resolved_name, zend_ast_get_str(name_ast))) {
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
return;
}
- zend_string_release(resolved_name);
+ zend_string_release_ex(resolved_name, 0);
break;
}
#define RESET_DOC_COMMENT() do { \
if (CG(doc_comment)) { \
- zend_string_release(CG(doc_comment)); \
+ zend_string_release_ex(CG(doc_comment), 0); \
CG(doc_comment) = NULL; \
} \
} while (0)
if (!(c->flags & CONST_PERSISTENT)) {
zval_ptr_dtor(&c->value);
+ if (c->name) {
+ zend_string_release_ex(c->name, 0);
+ }
+ efree(c);
} else {
zval_internal_dtor(&c->value);
+ if (c->name) {
+ zend_string_release_ex(c->name, 1);
+ }
+ free(c);
}
- if (c->name) {
- zend_string_release(c->name);
- }
- pefree(c, c->flags & CONST_PERSISTENT);
}
}
}
failure:
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
zend_string_efree(constant_name);
return ret_constant;
}
smart_str_appends(str, "Object(");
smart_str_appends(str, ZSTR_VAL(class_name));
smart_str_appends(str, "), ");
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
break;
}
}
if ((Z_OBJCE_P(exception) == zend_ce_type_error || Z_OBJCE_P(exception) == zend_ce_argument_count_error) && strstr(ZSTR_VAL(message), ", called in ")) {
zend_string *real_message = zend_strpprintf(0, "%s and defined", ZSTR_VAL(message));
- zend_string_release(message);
+ zend_string_release_ex(message, 0);
message = real_message;
}
ZSTR_LEN(prev_str) ? "\n\nNext " : "", ZSTR_VAL(prev_str));
}
- zend_string_release(prev_str);
- zend_string_release(message);
- zend_string_release(file);
+ zend_string_release_ex(prev_str, 0);
+ zend_string_release_ex(message, 0);
+ zend_string_release_ex(file, 0);
zval_ptr_dtor(&trace);
Z_PROTECT_RECURSION_P(exception);
break;
}
}
- zend_string_release(fname);
+ zend_string_release_ex(fname, 0);
exception = getThis();
/* Reset apply counts */
zend_error_helper(E_PARSE, ZSTR_VAL(file), line, "%s", ZSTR_VAL(message));
- zend_string_release(file);
- zend_string_release(message);
+ zend_string_release_ex(file, 0);
+ zend_string_release_ex(message, 0);
} else if (instanceof_function(ce_exception, zend_ce_throwable)) {
zval tmp, rv;
zend_string *str, *file = NULL;
ZSTR_VAL(Z_OBJCE(zv)->name), ZSTR_VAL(ce_exception->name));
if (file) {
- zend_string_release(file);
+ zend_string_release_ex(file, 0);
}
}
zend_error_va(severity, (file && ZSTR_LEN(file) > 0) ? ZSTR_VAL(file) : NULL, line,
"Uncaught %s\n thrown", ZSTR_VAL(str));
- zend_string_release(str);
- zend_string_release(file);
+ zend_string_release_ex(str, 0);
+ zend_string_release_ex(file, 0);
} else {
zend_error(severity, "Uncaught exception '%s'", ZSTR_VAL(ce_exception->name));
}
string_len = ZSTR_LEN(tmp);
c = (zend_uchar)ZSTR_VAL(tmp)[0];
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
} else {
string_len = Z_STRLEN_P(value);
c = (zend_uchar)Z_STRVAL_P(value)[0];
if (call->func->common.fn_flags & ZEND_ACC_CLOSURE) {
zend_object_release(ZEND_CLOSURE_OBJECT(call->func));
} else if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
- zend_string_release(call->func->common.function_name);
+ zend_string_release_ex(call->func->common.function_name, 0);
zend_free_trampoline(call->func);
}
last--;
}
if (last->opcode == ZEND_ROPE_INIT) {
- zend_string_release(*rope);
+ zend_string_release_ex(*rope, 0);
} else {
int j = last->extended_value;
do {
- zend_string_release(rope[j]);
+ zend_string_release_ex(rope[j], 0);
} while (j--);
}
} else if (kind == ZEND_LIVE_SILENCE) {
called_scope = zend_fetch_class_by_name(lcname, NULL, ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION);
if (UNEXPECTED(called_scope == NULL)) {
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
return NULL;
}
if (EXPECTED(!EG(exception))) {
zend_undefined_method(called_scope, mname);
}
- zend_string_release(lcname);
- zend_string_release(mname);
+ zend_string_release_ex(lcname, 0);
+ zend_string_release_ex(mname, 0);
return NULL;
}
- zend_string_release(lcname);
- zend_string_release(mname);
+ zend_string_release_ex(lcname, 0);
+ zend_string_release_ex(mname, 0);
if (UNEXPECTED(!(fbc->common.fn_flags & ZEND_ACC_STATIC))) {
zend_non_static_method_call(fbc);
}
if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
zend_throw_error(NULL, "Call to undefined function %s()", ZSTR_VAL(function));
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
return NULL;
}
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
fbc = Z_FUNC_P(func);
called_scope = NULL;
if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path)) {
zend_op_array *op_array = zend_compile_file(&file_handle, (type==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE));
zend_destroy_file_handle(&file_handle);
- zend_string_release(resolved_path);
+ zend_string_release_ex(resolved_path, 0);
if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) {
- zend_string_release(Z_STR(tmp_inc_filename));
+ zend_string_release_ex(Z_STR(tmp_inc_filename), 0);
}
return op_array;
} else {
zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, Z_STRVAL_P(inc_filename));
}
}
- zend_string_release(resolved_path);
+ zend_string_release_ex(resolved_path, 0);
}
break;
case ZEND_INCLUDE:
}
}
if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) {
- zend_string_release(Z_STR(tmp_inc_filename));
+ zend_string_release_ex(Z_STR(tmp_inc_filename), 0);
}
return new_op_array;
}
if (UNEXPECTED(Z_TYPE(call->This) != IS_OBJECT)) {
zend_vm_stack_free_args(call);
if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
- zend_string_release(fbc->common.function_name);
+ zend_string_release_ex(fbc->common.function_name, 0);
}
efree(fbc);
zend_vm_stack_free_call_frame(call);
zend_vm_stack_free_args(call);
if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
- zend_string_release(fbc->common.function_name);
+ zend_string_release_ex(fbc->common.function_name, 0);
}
efree(fbc);
}
zval_ptr_dtor_nogc(&c->value);
if (c->name) {
- zend_string_release(c->name);
+ zend_string_release_ex(c->name, 0);
}
efree(c);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
} ZEND_HASH_FOREACH_END_DEL();
ZEND_HASH_REVERSE_FOREACH_STR_KEY_VAL(EG(function_table), key, zv) {
zend_function *func = Z_PTR_P(zv);
break;
}
destroy_op_array(&func->op_array);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
} ZEND_HASH_FOREACH_END_DEL();
ZEND_HASH_REVERSE_FOREACH_STR_KEY_VAL(EG(class_table), key, zv) {
zend_class_entry *ce = Z_PTR_P(zv);
break;
}
destroy_zend_class(zv);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
} ZEND_HASH_FOREACH_END_DEL();
}
= zend_get_callable_name_ex(&fci->function_name, fci->object);
zend_error(E_WARNING, "Invalid callback %s, %s", ZSTR_VAL(callable_name), error);
efree(error);
- zend_string_release(callable_name);
+ zend_string_release_ex(callable_name, 0);
}
if (EG(current_execute_data) == &dummy_execute_data) {
EG(current_execute_data) = dummy_execute_data.prev_execute_data;
zend_vm_stack_free_args(call);
if (func->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
- zend_string_release(func->common.function_name);
+ zend_string_release_ex(func->common.function_name, 0);
}
efree(func);
zv = zend_hash_find(EG(class_table), lc_name);
if (zv) {
if (!key) {
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
}
return (zend_class_entry*)Z_PTR_P(zv);
}
*/
if (!use_autoload || zend_is_compiling()) {
if (!key) {
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
}
return NULL;
}
EG(autoload_func) = (zend_function*)Z_PTR_P(zv);
} else {
if (!key) {
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
}
return NULL;
}
/* Verify class name before passing it to __autoload() */
if (!key && strspn(ZSTR_VAL(name), "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\") != ZSTR_LEN(name)) {
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
return NULL;
}
if (zend_hash_add_empty_element(EG(in_autoload), lc_name) == NULL) {
if (!key) {
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
}
return NULL;
}
zval_ptr_dtor(&local_retval);
if (!key) {
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
}
return ce;
}
do {
i_zval_ptr_dtor(&p->val ZEND_FILE_LINE_CC);
if (EXPECTED(p->key)) {
- zend_string_release(p->key);
+ zend_string_release_ex(p->key, 0);
}
} while (++p != end);
} else {
if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF)) {
i_zval_ptr_dtor(&p->val ZEND_FILE_LINE_CC);
if (EXPECTED(p->key)) {
- zend_string_release(p->key);
+ zend_string_release_ex(p->key, 0);
}
}
} while (++p != end);
case T_DOC_COMMENT:
break;
default:
- zend_string_release(Z_STR(token));
+ zend_string_release_ex(Z_STR(token), 0);
break;
}
}
break;
default:
- zend_string_release(Z_STR(token));
+ zend_string_release_ex(Z_STR(token), 0);
break;
}
}
ce->constructor = fe;
fe->common.fn_flags |= ZEND_ACC_CTOR;
}
- zend_string_release(lowercase_name);
+ zend_string_release_ex(lowercase_name, 0);
}
}
/* }}} */
lcname = zend_string_tolower(alias->alias);
zend_add_trait_method(ce, ZSTR_VAL(alias->alias), lcname, &fn_copy, overriden);
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
/* Record the trait from which this alias was resolved. */
if (!alias->trait_method->ce) {
lcname = zend_string_tolower(cur_method_ref->method_name);
method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
lcname);
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
if (!method_exists) {
zend_error_noreturn(E_COMPILE_ERROR,
"A precedence rule was defined for %s::%s but this method does not exist",
ZSTR_VAL(cur_precedence->trait_method->ce->name));
}
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
j++;
}
}
lcname = zend_string_tolower(cur_method_ref->method_name);
method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
lcname);
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
if (!method_exists) {
zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", ZSTR_VAL(cur_method_ref->ce->name), ZSTR_VAL(cur_method_ref->method_name));
zend_string *lcname =
zend_string_tolower(precedences[i]->trait_method->method_name);
if (zend_hash_add_empty_element(exclude_table, lcname) == NULL) {
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", ZSTR_VAL(precedences[i]->trait_method->method_name), ZSTR_VAL(trait->name));
}
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
}
++j;
}
/* next: check for conflicts with current class */
if ((coliding_prop = zend_hash_find_ptr(&ce->properties_info, prop_name)) != NULL) {
if (coliding_prop->flags & ZEND_ACC_SHADOW) {
- zend_string_release(coliding_prop->name);
+ zend_string_release_ex(coliding_prop->name, 0);
if (coliding_prop->doc_comment) {
- zend_string_release(coliding_prop->doc_comment);
+ zend_string_release_ex(coliding_prop->doc_comment, 0);
}
zend_hash_del(&ce->properties_info, prop_name);
flags |= ZEND_ACC_CHANGED;
ZSTR_VAL(ce->name));
}
- zend_string_release(prop_name);
+ zend_string_release_ex(prop_name, 0);
continue;
}
}
zend_declare_property_ex(ce, prop_name,
prop_value, flags,
doc_comment);
- zend_string_release(prop_name);
+ zend_string_release_ex(prop_name, 0);
} ZEND_HASH_FOREACH_END();
}
}
cur_alias->trait_method->method_name);
if (zend_hash_exists(&ce->function_table,
lc_method_name)) {
- zend_string_release(lc_method_name);
+ zend_string_release_ex(lc_method_name, 0);
zend_error_noreturn(E_COMPILE_ERROR,
"The modifiers for the trait alias %s() need to be changed in the same statement in which the alias is defined. Error",
ZSTR_VAL(cur_alias->trait_method->method_name));
} else {
- zend_string_release(lc_method_name);
+ zend_string_release_ex(lc_method_name, 0);
zend_error_noreturn(E_COMPILE_ERROR,
"The modifiers of the trait method %s() are changed, but this method does not exist. Error",
ZSTR_VAL(cur_alias->trait_method->method_name));
{
zend_ini_entry *entry = (zend_ini_entry*)Z_PTR_P(zv);
- zend_string_release(entry->name);
+ zend_string_release_ex(entry->name, 1);
if (entry->value) {
zend_string_release(entry->value);
}
if (entry->orig_value) {
- zend_string_release(entry->orig_value);
+ zend_string_release_ex(entry->orig_value, 1);
}
free(entry);
}
if (zend_hash_add_ptr(directives, p->name, (void*)p) == NULL) {
if (p->name) {
- zend_string_release(p->name);
+ zend_string_release_ex(p->name, 1);
}
zend_unregister_ini_entries(module_number);
return FAILURE;
}
/* }}} */
+/* {{{ zval_ini_dtor()
+*/
+static int zval_ini_dtor(zval *zv)
+{
+ if (Z_TYPE_P(zv) == IS_STRING) {
+ zend_string_release(Z_STR_P(zv));
+ }
+}
+/* }}} */
+
%}
%expect 0
%left '|' '&' '^'
%right '~' '!'
-%destructor { zval_ptr_dtor(&$$); } TC_RAW TC_CONSTANT TC_NUMBER TC_STRING TC_WHITESPACE TC_LABEL TC_OFFSET TC_VARNAME BOOL_TRUE BOOL_FALSE NULL_NULL
+%destructor { zval_ini_dtor(&$$); } TC_RAW TC_CONSTANT TC_NUMBER TC_STRING TC_WHITESPACE TC_LABEL TC_OFFSET TC_VARNAME BOOL_TRUE BOOL_FALSE NULL_NULL
%%
#endif
ZEND_INI_PARSER_CB(&$1, &$3, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG);
zend_string_release(Z_STR($1));
- zval_ptr_dtor(&$3);
+ zval_ini_dtor(&$3);
}
| TC_OFFSET option_offset ']' '=' string_or_value {
#if DEBUG_CFG_PARSER
#endif
ZEND_INI_PARSER_CB(&$1, &$5, &$2, ZEND_INI_PARSER_POP_ENTRY, ZEND_INI_PARSER_ARG);
zend_string_release(Z_STR($1));
- if (Z_TYPE($2) == IS_STRING) {
- zend_string_release(Z_STR($2));
- } else {
- zval_dtor(&$2);
- }
- zval_ptr_dtor(&$5);
+ zval_ini_dtor(&$2);
+ zval_ini_dtor(&$5);
}
| TC_LABEL { ZEND_INI_PARSER_CB(&$1, NULL, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG); zend_string_release(Z_STR($1)); }
| END_OF_LINE
}
%destructor { zend_ast_destroy($$); } <ast>
-%destructor { if ($$) zend_string_release($$); } <str>
+%destructor { if ($$) zend_string_release_ex($$, 0); } <str>
%left T_INCLUDE T_INCLUDE_ONCE T_EVAL T_REQUIRE T_REQUIRE_ONCE
%left ','
}
zend_set_compiled_filename(compiled_filename);
- zend_string_release(compiled_filename);
+ zend_string_release_ex(compiled_filename, 0);
if (CG(start_lineno)) {
CG(zend_lineno) = CG(start_lineno);
zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path);
if (opened_path) {
- zend_string_release(opened_path);
+ zend_string_release_ex(opened_path, 0);
}
}
zend_destroy_file_handle(&file_handle);
new_compiled_filename = zend_string_init(filename, strlen(filename), 0);
zend_set_compiled_filename(new_compiled_filename);
- zend_string_release(new_compiled_filename);
+ zend_string_release_ex(new_compiled_filename, 0);
CG(zend_lineno) = 1;
CG(increment_lineno) = 0;
RESET_DOC_COMMENT();
}
zend_set_compiled_filename(compiled_filename);
- zend_string_release(compiled_filename);
+ zend_string_release_ex(compiled_filename, 0);
if (CG(start_lineno)) {
CG(zend_lineno) = CG(start_lineno);
zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path);
if (opened_path) {
- zend_string_release(opened_path);
+ zend_string_release_ex(opened_path, 0);
}
}
zend_destroy_file_handle(&file_handle);
new_compiled_filename = zend_string_init(filename, strlen(filename), 0);
zend_set_compiled_filename(new_compiled_filename);
- zend_string_release(new_compiled_filename);
+ zend_string_release_ex(new_compiled_filename, 0);
CG(zend_lineno) = 1;
CG(increment_lineno) = 0;
RESET_DOC_COMMENT();
zend_string *str = zend_string_init(key, key_len, 1);
zend_resource *ret = zend_register_persistent_resource_ex(str, rsrc_pointer, rsrc_type);
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
return ret;
}
member = zend_string_copy(prop_info_name);
}
property_info = zend_get_property_info(zobj->ce, member, 1);
- zend_string_release(member);
+ zend_string_release_ex(member, 0);
if (property_info == NULL) {
/* undefined public property */
if (class_name && class_name[0] != '*') {
EXPECTED(zend_string_equal_content(str, member)))) {
return &Z_PROPERTY_GUARD_P(zv);
} else if (EXPECTED(Z_PROPERTY_GUARD_P(zv) == 0)) {
- zend_string_release(Z_STR_P(zv));
+ zend_string_release_ex(Z_STR_P(zv), 0);
ZVAL_STR_COPY(zv, member);
return &Z_PROPERTY_GUARD_P(zv);
} else {
/* mark pointer as "special" using low bit */
zend_hash_add_new_ptr(guards, str,
(void*)(((zend_uintptr_t)&Z_PROPERTY_GUARD_P(zv)) | 1));
- zend_string_release(Z_STR_P(zv));
+ zend_string_release_ex(Z_STR_P(zv), 0);
ZVAL_ARR(zv, guards);
}
} else if (EXPECTED(Z_TYPE_P(zv) == IS_ARRAY)) {
fbc = ce->constructor;
} else {
if (UNEXPECTED(!key)) {
- zend_string_release(lc_function_name);
+ zend_string_release_ex(lc_function_name, 0);
}
if (ce->__call &&
(object = zend_get_this_object(EG(current_execute_data))) != NULL &&
}
if (UNEXPECTED(!key)) {
- zend_string_release(lc_function_name);
+ zend_string_release_ex(lc_function_name, 0);
}
return fbc;
}
if (UNEXPECTED(object->ce->ce_flags & ZEND_ACC_USE_GUARDS)) {
if (EXPECTED(Z_TYPE_P(p) == IS_STRING)) {
- zend_string_release(Z_STR_P(p));
+ zend_string_release_ex(Z_STR_P(p), 0);
} else if (Z_TYPE_P(p) == IS_ARRAY) {
HashTable *guards;
} else {
ZEND_ASSERT(function->type == ZEND_INTERNAL_FUNCTION);
ZEND_ASSERT(function->common.function_name);
- zend_string_release(function->common.function_name);
+ zend_string_release_ex(function->common.function_name, 1);
if (function->common.arg_info &&
(function->common.fn_flags & (ZEND_ACC_HAS_RETURN_TYPE|ZEND_ACC_HAS_TYPE_HINTS))) {
}
for (i = 0 ; i < num_args; i++) {
if (ZEND_TYPE_IS_CLASS(arg_info[i].type)) {
- zend_string_release(ZEND_TYPE_NAME(arg_info[i].type));
+ zend_string_release_ex(ZEND_TYPE_NAME(arg_info[i].type), 1);
}
}
free(arg_info);
} else {
ZEND_ASSERT(function->type == ZEND_INTERNAL_FUNCTION);
ZEND_ASSERT(function->common.function_name);
- zend_string_release(function->common.function_name);
+ zend_string_release_ex(function->common.function_name, 1);
if ((function->common.fn_flags & (ZEND_ACC_HAS_RETURN_TYPE|ZEND_ACC_HAS_TYPE_HINTS)) &&
!function->common.scope && function->common.arg_info) {
}
for (i = 0 ; i < num_args; i++) {
if (ZEND_TYPE_IS_CLASS(arg_info[i].type)) {
- zend_string_release(ZEND_TYPE_NAME(arg_info[i].type));
+ zend_string_release_ex(ZEND_TYPE_NAME(arg_info[i].type), 1);
}
}
free(arg_info);
while (ce->trait_aliases[i]) {
if (ce->trait_aliases[i]->trait_method) {
if (ce->trait_aliases[i]->trait_method->method_name) {
- zend_string_release(ce->trait_aliases[i]->trait_method->method_name);
+ zend_string_release_ex(ce->trait_aliases[i]->trait_method->method_name, 0);
}
if (ce->trait_aliases[i]->trait_method->class_name) {
- zend_string_release(ce->trait_aliases[i]->trait_method->class_name);
+ zend_string_release_ex(ce->trait_aliases[i]->trait_method->class_name, 0);
}
efree(ce->trait_aliases[i]->trait_method);
}
if (ce->trait_aliases[i]->alias) {
- zend_string_release(ce->trait_aliases[i]->alias);
+ zend_string_release_ex(ce->trait_aliases[i]->alias, 0);
}
efree(ce->trait_aliases[i]);
size_t i = 0;
while (ce->trait_precedences[i]) {
- zend_string_release(ce->trait_precedences[i]->trait_method->method_name);
- zend_string_release(ce->trait_precedences[i]->trait_method->class_name);
+ zend_string_release_ex(ce->trait_precedences[i]->trait_method->method_name, 0);
+ zend_string_release_ex(ce->trait_precedences[i]->trait_method->class_name, 0);
efree(ce->trait_precedences[i]->trait_method);
if (ce->trait_precedences[i]->exclude_from_classes) {
size_t j = 0;
zend_trait_precedence *cur_precedence = ce->trait_precedences[i];
while (cur_precedence->exclude_from_classes[j].class_name) {
- zend_string_release(cur_precedence->exclude_from_classes[j].class_name);
+ zend_string_release_ex(cur_precedence->exclude_from_classes[j].class_name, 0);
j++;
}
efree(ce->trait_precedences[i]->exclude_from_classes);
}
ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop_info) {
if (prop_info->ce == ce || (prop_info->flags & ZEND_ACC_SHADOW)) {
- zend_string_release(prop_info->name);
+ zend_string_release_ex(prop_info->name, 0);
if (prop_info->doc_comment) {
- zend_string_release(prop_info->doc_comment);
+ zend_string_release_ex(prop_info->doc_comment, 0);
}
}
} ZEND_HASH_FOREACH_END();
zend_hash_destroy(&ce->properties_info);
- zend_string_release(ce->name);
+ zend_string_release_ex(ce->name, 0);
zend_hash_destroy(&ce->function_table);
if (zend_hash_num_elements(&ce->constants_table)) {
zend_class_constant *c;
if (c->ce == ce) {
zval_ptr_dtor_nogc(&c->value);
if (c->doc_comment) {
- zend_string_release(c->doc_comment);
+ zend_string_release_ex(c->doc_comment, 0);
}
}
} ZEND_HASH_FOREACH_END();
efree(ce->interfaces);
}
if (ce->info.user.doc_comment) {
- zend_string_release(ce->info.user.doc_comment);
+ zend_string_release_ex(ce->info.user.doc_comment, 0);
}
_destroy_zend_class_traits_info(ce);
free(ce->default_static_members_table);
}
zend_hash_destroy(&ce->properties_info);
- zend_string_release(ce->name);
+ zend_string_release_ex(ce->name, 1);
/* TODO: eliminate this loop for classes without functions with arg_info */
ZEND_HASH_FOREACH_PTR(&ce->function_table, fn) {
if (c->ce == ce) {
zval_internal_ptr_dtor(&c->value);
if (c->doc_comment) {
- zend_string_release(c->doc_comment);
+ zend_string_release_ex(c->doc_comment, 1);
}
}
free(c);
i = op_array->last_var;
while (i > 0) {
i--;
- zend_string_release(op_array->vars[i]);
+ zend_string_release_ex(op_array->vars[i], 0);
}
efree(op_array->vars);
}
efree(op_array->opcodes);
if (op_array->function_name) {
- zend_string_release(op_array->function_name);
+ zend_string_release_ex(op_array->function_name, 0);
}
if (op_array->doc_comment) {
- zend_string_release(op_array->doc_comment);
+ zend_string_release_ex(op_array->doc_comment, 0);
}
if (op_array->live_range) {
efree(op_array->live_range);
}
for (i = 0 ; i < num_args; i++) {
if (arg_info[i].name) {
- zend_string_release(arg_info[i].name);
+ zend_string_release_ex(arg_info[i].name, 0);
}
if (ZEND_TYPE_IS_CLASS(arg_info[i].type)) {
- zend_string_release(ZEND_TYPE_NAME(arg_info[i].type));
+ zend_string_release_ex(ZEND_TYPE_NAME(arg_info[i].type), 0);
}
}
efree(arg_info);
zend_error(E_WARNING, "A non-numeric value encountered");
}
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
break;
}
case IS_NULL:
} else {
ZVAL_LONG(op, ZEND_STRTOL(ZSTR_VAL(str), NULL, base));
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
break;
case IS_ARRAY:
zend_string *str = Z_STR_P(op);
ZVAL_DOUBLE(op, zend_strtod(ZSTR_VAL(str), NULL));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
break;
case IS_ARRAY:
} else {
ZVAL_TRUE(op);
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
break;
case IS_ARRAY:
if (EXPECTED(Z_STRLEN_P(op1) == Z_STRLEN_P(op2)) && Z_STRLEN_P(op1) == 1) {
zend_uchar or = (zend_uchar) (*Z_STRVAL_P(op1) | *Z_STRVAL_P(op2));
if (result==op1) {
- zend_string_release(Z_STR_P(result));
+ zend_string_release_ex(Z_STR_P(result), 0);
}
ZVAL_INTERNED_STR(result, ZSTR_CHAR(or));
return SUCCESS;
}
memcpy(ZSTR_VAL(str) + i, Z_STRVAL_P(longer) + i, Z_STRLEN_P(longer) - i + 1);
if (result==op1) {
- zend_string_release(Z_STR_P(result));
+ zend_string_release_ex(Z_STR_P(result), 0);
}
ZVAL_NEW_STR(result, str);
return SUCCESS;
if (EXPECTED(Z_STRLEN_P(op1) == Z_STRLEN_P(op2)) && Z_STRLEN_P(op1) == 1) {
zend_uchar and = (zend_uchar) (*Z_STRVAL_P(op1) & *Z_STRVAL_P(op2));
if (result==op1) {
- zend_string_release(Z_STR_P(result));
+ zend_string_release_ex(Z_STR_P(result), 0);
}
ZVAL_INTERNED_STR(result, ZSTR_CHAR(and));
return SUCCESS;
}
ZSTR_VAL(str)[i] = 0;
if (result==op1) {
- zend_string_release(Z_STR_P(result));
+ zend_string_release_ex(Z_STR_P(result), 0);
}
ZVAL_NEW_STR(result, str);
return SUCCESS;
if (EXPECTED(Z_STRLEN_P(op1) == Z_STRLEN_P(op2)) && Z_STRLEN_P(op1) == 1) {
zend_uchar xor = (zend_uchar) (*Z_STRVAL_P(op1) ^ *Z_STRVAL_P(op2));
if (result==op1) {
- zend_string_release(Z_STR_P(result));
+ zend_string_release_ex(Z_STR_P(result), 0);
}
ZVAL_INTERNED_STR(result, ZSTR_CHAR(xor));
return SUCCESS;
}
ZSTR_VAL(str)[i] = 0;
if (result==op1) {
- zend_string_release(Z_STR_P(result));
+ zend_string_release_ex(Z_STR_P(result), 0);
}
ZVAL_NEW_STR(result, str);
return SUCCESS;
int ch;
if (Z_STRLEN_P(str) == 0) {
- zend_string_release(Z_STR_P(str));
+ zend_string_release_ex(Z_STR_P(str), 0);
ZVAL_INTERNED_STR(str, ZSTR_CHAR('1'));
return;
}
switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) {
case IS_LONG:
- zend_string_release(Z_STR_P(op1));
+ zend_string_release_ex(Z_STR_P(op1), 0);
if (lval == ZEND_LONG_MAX) {
/* switch to double */
double d = (double)lval;
}
break;
case IS_DOUBLE:
- zend_string_release(Z_STR_P(op1));
+ zend_string_release_ex(Z_STR_P(op1), 0);
ZVAL_DOUBLE(op1, dval+1);
break;
default:
break;
case IS_STRING: /* Like perl we only support string increment */
if (Z_STRLEN_P(op1) == 0) { /* consider as 0 */
- zend_string_release(Z_STR_P(op1));
+ zend_string_release_ex(Z_STR_P(op1), 0);
ZVAL_LONG(op1, -1);
break;
}
switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) {
case IS_LONG:
- zend_string_release(Z_STR_P(op1));
+ zend_string_release_ex(Z_STR_P(op1), 0);
if (lval == ZEND_LONG_MIN) {
double d = (double)lval;
ZVAL_DOUBLE(op1, d-1);
}
break;
case IS_DOUBLE:
- zend_string_release(Z_STR_P(op1));
+ zend_string_release_ex(Z_STR_P(op1), 0);
ZVAL_DOUBLE(op1, dval - 1);
break;
}
}
static zend_always_inline void zend_tmp_string_release(zend_string *tmp) {
if (UNEXPECTED(tmp)) {
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
}
}
smart_str_append_long_ex((dest), (val), 0)
#define smart_str_append_unsigned(dest, val) \
smart_str_append_unsigned_ex((dest), (val), 0)
+#define smart_str_free(dest) \
+ smart_str_free_ex((dest), 0)
BEGIN_EXTERN_C()
return len;
}
-static zend_always_inline void smart_str_free(smart_str *str) {
+static zend_always_inline void smart_str_free_ex(smart_str *str, zend_bool persistent) {
if (str->s) {
- zend_string_release(str->s);
+ zend_string_release_ex(str->s, persistent);
str->s = NULL;
}
str->a = 0;
break;
}
if (fh->opened_path) {
- zend_string_release(fh->opened_path);
+ zend_string_release_ex(fh->opened_path, 0);
fh->opened_path = NULL;
}
if (fh->free_filename && fh->filename) {
}
}
+static zend_always_inline void zend_string_release_ex(zend_string *s, int persistent)
+{
+ if (!ZSTR_IS_INTERNED(s)) {
+ if (GC_DELREF(s) == 0) {
+ if (persistent) {
+ ZEND_ASSERT(GC_FLAGS(s) & IS_STR_PERSISTENT);
+ free(s);
+ } else {
+ ZEND_ASSERT(!(GC_FLAGS(s) & IS_STR_PERSISTENT));
+ efree(s);
+ }
+ }
+ }
+}
+
#if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
ZEND_API zend_bool ZEND_FASTCALL zend_string_equal_val(zend_string *s1, zend_string *s2);
#else
CHECK_ZVAL_STRING_REL(str);
ZEND_ASSERT(!ZSTR_IS_INTERNED(str));
ZEND_ASSERT(GC_REFCOUNT(str) == 0);
- pefree(str, UNEXPECTED(GC_FLAGS(str) & IS_STR_PERSISTENT));
+ ZEND_ASSERT(!(GC_FLAGS(str) & IS_STR_PERSISTENT));
+ efree(str);
}
static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref ZEND_FILE_LINE_DC)
switch (Z_TYPE_P(zvalue)) {
case IS_STRING:
CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
- zend_string_release(Z_STR_P(zvalue));
+ zend_string_release_ex(Z_STR_P(zvalue), 1);
break;
case IS_ARRAY:
case IS_CONSTANT_AST:
} else if (OP1_TYPE == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
GET_OP1_UNDEF_CV(z, BP_VAR_R);
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
FREE_OP1();
}
}
ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
break;
}
}
}
}
ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
break;
}
}
memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
if (OP1_TYPE != IS_CONST) {
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
}
if (OP2_TYPE != IS_CONST) {
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
}
} while (0);
FREE_OP1();
FREE_OP2();
if (UNEXPECTED(EG(exception))) {
for (i = 0; i <= opline->extended_value; i++) {
- zend_string_release(rope[i]);
+ zend_string_release_ex(rope[i], 0);
}
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
for (i = 0; i <= opline->extended_value; i++) {
memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
target += ZSTR_LEN(rope[i]);
- zend_string_release(rope[i]);
+ zend_string_release_ex(rope[i], 0);
}
*target = '\0';
if (UNEXPECTED(EG(exception))) {
if (call) {
if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
- zend_string_release(call->func->common.function_name);
+ zend_string_release_ex(call->func->common.function_name, 0);
zend_free_trampoline(call->func);
}
zend_vm_stack_free_call_frame(call);
if (Z_TYPE(key) == IS_STRING) {
zend_throw_error(NULL,
"Cannot unpack Traversable with string keys");
- zend_string_release(Z_STR(key));
+ zend_string_release_ex(Z_STR(key), 0);
break;
}
if (Z_TYPE(key) == IS_STRING) {
zend_throw_error(NULL,
"Cannot unpack Traversable with string keys");
- zend_string_release(Z_STR(key));
+ zend_string_release_ex(Z_STR(key), 0);
break;
}
if (UNEXPECTED(EG(exception))) {
if (call) {
if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
- zend_string_release(call->func->common.function_name);
+ zend_string_release_ex(call->func->common.function_name, 0);
zend_free_trampoline(call->func);
}
zend_vm_stack_free_call_frame(call);
if (UNEXPECTED(EG(exception))) {
if (call) {
if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
- zend_string_release(call->func->common.function_name);
+ zend_string_release_ex(call->func->common.function_name, 0);
zend_free_trampoline(call->func);
}
zend_vm_stack_free_call_frame(call);
if (UNEXPECTED(EG(exception))) {
if (call) {
if (call->func->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
- zend_string_release(call->func->common.function_name);
+ zend_string_release_ex(call->func->common.function_name, 0);
zend_free_trampoline(call->func);
}
zend_vm_stack_free_call_frame(call);
} else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
GET_OP1_UNDEF_CV(z, BP_VAR_R);
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
break;
}
}
}
}
ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
break;
}
}
memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
if (IS_CONST != IS_CONST) {
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
}
if (IS_CONST != IS_CONST) {
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
}
} while (0);
}
}
ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
break;
}
}
}
}
ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
break;
}
}
memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
if (IS_CONST != IS_CONST) {
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
}
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
}
} while (0);
}
}
ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
break;
}
}
}
}
ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
break;
}
}
memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
if (IS_CONST != IS_CONST) {
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
}
if (IS_CV != IS_CONST) {
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
}
} while (0);
} else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
GET_OP1_UNDEF_CV(z, BP_VAR_R);
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
zval_ptr_dtor_nogc(free_op1);
}
}
ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
break;
}
}
}
}
ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
break;
}
}
memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
}
if (IS_CONST != IS_CONST) {
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
}
} while (0);
zval_ptr_dtor_nogc(free_op1);
}
}
ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
break;
}
}
}
}
ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
break;
}
}
memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
}
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
}
} while (0);
zval_ptr_dtor_nogc(free_op1);
}
}
ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
break;
}
}
}
}
ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
break;
}
}
memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
}
if (IS_CV != IS_CONST) {
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
}
} while (0);
zval_ptr_dtor_nogc(free_op1);
if (UNEXPECTED(EG(exception))) {
for (i = 0; i <= opline->extended_value; i++) {
- zend_string_release(rope[i]);
+ zend_string_release_ex(rope[i], 0);
}
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
for (i = 0; i <= opline->extended_value; i++) {
memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
target += ZSTR_LEN(rope[i]);
- zend_string_release(rope[i]);
+ zend_string_release_ex(rope[i], 0);
}
*target = '\0';
zval_ptr_dtor_nogc(free_op2);
if (UNEXPECTED(EG(exception))) {
for (i = 0; i <= opline->extended_value; i++) {
- zend_string_release(rope[i]);
+ zend_string_release_ex(rope[i], 0);
}
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
for (i = 0; i <= opline->extended_value; i++) {
memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
target += ZSTR_LEN(rope[i]);
- zend_string_release(rope[i]);
+ zend_string_release_ex(rope[i], 0);
}
*target = '\0';
if (UNEXPECTED(EG(exception))) {
for (i = 0; i <= opline->extended_value; i++) {
- zend_string_release(rope[i]);
+ zend_string_release_ex(rope[i], 0);
}
ZVAL_UNDEF(EX_VAR(opline->result.var));
HANDLE_EXCEPTION();
for (i = 0; i <= opline->extended_value; i++) {
memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i]));
target += ZSTR_LEN(rope[i]);
- zend_string_release(rope[i]);
+ zend_string_release_ex(rope[i], 0);
}
*target = '\0';
} else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) {
GET_OP1_UNDEF_CV(z, BP_VAR_R);
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION();
}
}
ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
break;
}
}
}
}
ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
break;
}
}
memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
if (IS_CV != IS_CONST) {
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
}
if (IS_CONST != IS_CONST) {
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
}
} while (0);
}
}
ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
break;
}
}
}
}
ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
break;
}
}
memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
if (IS_CV != IS_CONST) {
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
}
if ((IS_TMP_VAR|IS_VAR) != IS_CONST) {
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
}
} while (0);
}
}
ZVAL_STR(EX_VAR(opline->result.var), op2_str);
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
break;
}
}
}
}
ZVAL_STR(EX_VAR(opline->result.var), op1_str);
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
break;
}
}
memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1);
ZVAL_NEW_STR(EX_VAR(opline->result.var), str);
if (IS_CV != IS_CONST) {
- zend_string_release(op1_str);
+ zend_string_release_ex(op1_str, 0);
}
if (IS_CV != IS_CONST) {
- zend_string_release(op2_str);
+ zend_string_release_ex(op2_str, 0);
}
} while (0);
{
zend_internal_function *f = (zend_internal_function*)Z_PTR_P(zv);
- zend_string_release(f->function_name);
+ zend_string_release_ex(f->function_name, 0);
if (f->arg_info) {
efree(f->arg_info);
}
if (COMG(autoreg_verbose) && !compare_function(&results, &c.value, exists)) {
php_error_docref(NULL, E_WARNING, "Type library constant %s is already defined", c.name);
}
- zend_string_release(c.name);
+ zend_string_release_ex(c.name, 1);
ITypeInfo_ReleaseVarDesc(TypeInfo, pVarDesc);
continue;
}
/* Find the existing id */
if ((tmp = zend_hash_find(disp->name_to_dispid, name)) != NULL) {
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
continue;
}
ZVAL_LONG(&tmp2, pid);
zend_hash_update(disp->name_to_dispid, name, &tmp2);
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
}
}
/* Find the existing id */
if ((tmp = zend_hash_find(disp->name_to_dispid, name)) != NULL) {
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
continue;
}
ZVAL_LONG(&tmp2, pid);
zend_hash_update(disp->name_to_dispid, name, &tmp2);
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
}
}
}
if (type == CURLINFO_HEADER_OUT) {
if (ch->header.str) {
- zend_string_release(ch->header.str);
+ zend_string_release_ex(ch->header.str, 0);
}
if (buf_len > 0) {
ch->header.str = zend_string_init(buf, buf_len, 0);
}
}
- zend_string_release(string_key);
+ zend_string_release_ex(string_key, 0);
continue;
}
error = (CURLcode)form_error;
}
zend_tmp_string_release(tmp_postval);
- zend_string_release(string_key);
+ zend_string_release_ex(string_key, 0);
} ZEND_HASH_FOREACH_END();
SAVE_CURL_ERROR(ch, error);
{
smart_str_free(&ch->handlers->write->buf);
if (ch->header.str) {
- zend_string_release(ch->header.str);
+ zend_string_release_ex(ch->header.str, 0);
ch->header.str = NULL;
}
zval_ptr_dtor(&ch->handlers->write_header->func_name);
zval_ptr_dtor(&ch->handlers->std_err);
if (ch->header.str) {
- zend_string_release(ch->header.str);
+ zend_string_release_ex(ch->header.str, 0);
}
zval_ptr_dtor(&ch->handlers->write_header->stream);
} else {
if (opened_path) {
info->lock.name = pestrndup(ZSTR_VAL(opened_path), ZSTR_LEN(opened_path), persistent);
- zend_string_release(opened_path);
+ zend_string_release_ex(opened_path, 0);
}
}
}
}
/* now store the name of the lock */
info->lock.name = pestrndup(ZSTR_VAL(opened_path), ZSTR_LEN(opened_path), persistent);
- zend_string_release(opened_path);
+ zend_string_release_ex(opened_path, 0);
}
}
if (!lock_dbf) {
xmlNodeSetContentLen((xmlNodePtr) attrp, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
return SUCCESS;
}
xmlNodeSetContentLen(nodep, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
return SUCCESS;
}
php_error_docref(NULL, E_WARNING, "Invalid Document Encoding");
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
return SUCCESS;
}
docp->version = xmlStrdup((const xmlChar *) ZSTR_VAL(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
return SUCCESS;
}
docp->URL = xmlStrdup((const xmlChar *) ZSTR_VAL(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
return SUCCESS;
}
{
zend_string *str = zval_get_string(newval);
xmlNodeSetContentLen(nodep, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
break;
}
default:
}
if (ns == NULL) {
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
php_dom_throw_error(NAMESPACE_ERR, dom_get_strict_error(obj->document));
return FAILURE;
}
xmlSetNs(nodep, ns);
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
break;
default:
break;
/* we have to use xmlNodeAddContent() to get the same behavior as with xmlNewText() */
xmlNodeSetContent(nodep, (xmlChar *) "");
xmlNodeAddContent(nodep, (xmlChar *) ZSTR_VAL(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
return SUCCESS;
}
hnd.write_func = write_func ? write_func : dom_write_na;
str = zend_string_init_interned(name, name_len, 1);
zend_hash_add_mem(prop_handler, str, &hnd, sizeof(dom_prop_handler));
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
}
/* }}} */
retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot);
}
- zend_string_release(member_str);
+ zend_string_release_ex(member_str, 0);
return retval;
}
/* }}} */
retval = std_hnd->read_property(object, member, type, cache_slot, rv);
}
- zend_string_release(member_str);
+ zend_string_release_ex(member_str, 0);
return retval;
}
/* }}} */
std_hnd->write_property(object, member, value, cache_slot);
}
- zend_string_release(member_str);
+ zend_string_release_ex(member_str, 0);
}
/* }}} */
retval = std_hnd->has_property(object, member, check_empty, cache_slot);
}
- zend_string_release(member_str);
+ zend_string_release_ex(member_str, 0);
return retval;
}
/* }}} */
zend_hash_add(debug_info, string_key, &value);
} ZEND_HASH_FOREACH_END();
- zend_string_release(object_str);
+ zend_string_release_ex(object_str, 0);
return debug_info;
}
xmlNodeSetContentLen(nodep, (xmlChar *) ZSTR_VAL(str), ZSTR_LEN(str) + 1);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
return SUCCESS;
}
} else {
zend_string *str = zval_get_string(&retval);
valuePush(ctxt, xmlXPathNewString((xmlChar *) ZSTR_VAL(str)));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
zval_ptr_dtor(&retval);
}
}
- zend_string_release(callable);
+ zend_string_release_ex(callable, 0);
zval_dtor(&fci.function_name);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
zend_string *str = zval_get_string(entry);
ZVAL_LONG(&new_string,1);
zend_hash_update(intern->registered_phpfunctions, str, &new_string);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
} ZEND_HASH_FOREACH_END();
intern->registerPhpFunctions = 2;
RETURN_TRUE;
base = php_basename(stream->orig_path, strlen(stream->orig_path), NULL, 0);
ImageInfo->FileName = estrndup(ZSTR_VAL(base), ZSTR_LEN(base));
- zend_string_release(base);
+ zend_string_release_ex(base, 0);
/* Store file date/time. */
ImageInfo->FileDateTime = st.st_mtime;
repl = zend_string_init(rep, strlen(rep), 0);
res = php_pcre_replace_impl(pce, NULL, ms->o.buf, strlen(ms->o.buf), repl, -1, &rep_cnt);
- zend_string_release(repl);
+ zend_string_release_ex(repl, 0);
if (NULL == res) {
rep_cnt = -1;
goto out;
strncpy(ms->o.buf, ZSTR_VAL(res), ZSTR_LEN(res));
ms->o.buf[ZSTR_LEN(res)] = '\0';
- zend_string_release(res);
+ zend_string_release_ex(res, 0);
out:
(void)setlocale(LC_CTYPE, "");
php_pcre_free_match_data(match_data);
}
}
- zend_string_release(pattern);
+ zend_string_release_ex(pattern, 0);
(void)setlocale(LC_CTYPE, "");
return rv;
}
sregexp = zend_string_init(regexp, regexp_len, 0);
re = pcre_get_compiled_regex(sregexp, &capture_count, &preg_options);
+ zend_string_release_ex(sregexp, 0);
if (!re) {
- zend_string_release(sregexp);
RETURN_VALIDATION_FAILED
}
- zend_string_release(sregexp);
match_data = php_pcre_create_match_data(capture_count, re);
if (!match_data) {
RETURN_VALIDATION_FAILED
io_ctx = gdNewDynamicCtxEx(ZSTR_LEN(buff), pstr, 0);
if (!io_ctx) {
pefree(pstr, 1);
- zend_string_release(buff);
+ zend_string_release_ex(buff, 0);
php_error_docref(NULL, E_WARNING,"Cannot allocate GD IO context");
goto out_err;
}
}
io_ctx->gd_free(io_ctx);
pefree(pstr, 1);
- zend_string_release(buff);
+ zend_string_release_ex(buff, 0);
}
else if (php_stream_can_cast(stream, PHP_STREAM_AS_STDIO)) {
/* try and force the stream to be FILE* */
fclose(tmp);
VCWD_UNLINK((const char *)ZSTR_VAL(path)); /* make sure that the temporary file is removed */
- zend_string_release(path);
+ zend_string_release_ex(path, 0);
}
RETURN_TRUE;
}
PHP_VAR_SERIALIZE_DESTROY(serialize_data);
*buffer = (unsigned char *) estrndup(ZSTR_VAL(buf.s), ZSTR_LEN(buf.s));
*buf_len = ZSTR_LEN(buf.s);
- zend_string_release(buf.s);
+ zend_string_release_ex(buf.s, 0);
return SUCCESS;
}
php_hash_bin2hex(ZSTR_VAL(hex_digest), (unsigned char *) ZSTR_VAL(digest), ops->digest_size);
ZSTR_VAL(hex_digest)[2 * ops->digest_size] = 0;
- zend_string_release(digest);
+ zend_string_release_ex(digest, 0);
RETURN_NEW_STR(hex_digest);
}
}
php_hash_bin2hex(ZSTR_VAL(hex_digest), (unsigned char *) ZSTR_VAL(digest), ops->digest_size);
ZSTR_VAL(hex_digest)[2 * ops->digest_size] = 0;
- zend_string_release(digest);
+ zend_string_release_ex(digest, 0);
RETURN_NEW_STR(hex_digest);
}
}
php_hash_bin2hex(ZSTR_VAL(hex_digest), (unsigned char *) ZSTR_VAL(digest), digest_len);
ZSTR_VAL(hex_digest)[2 * digest_len] = 0;
- zend_string_release(digest);
+ zend_string_release_ex(digest, 0);
RETURN_NEW_STR(hex_digest);
}
}
smart_str_appendl(pretval, "?=", sizeof("?=") - 1);
char_cnt -= 2;
- zend_string_release(encoded);
+ zend_string_release_ex(encoded, 0);
encoded = NULL;
} break; /* case PHP_ICONV_ENC_SCHEME_BASE64: */
iconv_close(cd_pl);
}
if (encoded != NULL) {
- zend_string_release(encoded);
+ zend_string_release_ex(encoded, 0);
}
if (buf != NULL) {
efree(buf);
}
err = _php_iconv_appendl(pretval, ZSTR_VAL(decoded_text), ZSTR_LEN(decoded_text), cd);
- zend_string_release(decoded_text);
+ zend_string_release_ex(decoded_text, 0);
if (err != PHP_ICONV_ERR_SUCCESS) {
if ((mode & PHP_ICONV_MIME_DECODE_CONTINUE_ON_ERROR)) {
}
if (tmp_str) {
- zend_string_release(tmp_str);
+ zend_string_release_ex(tmp_str, 0);
}
}
/* }}} */
}
retval = zend_alter_ini_entry(name, charset, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
if (retval == SUCCESS) {
RETURN_TRUE;
if (!zend_is_callable(cb_arg, 0, NULL)) {
zend_string *cb_name = zend_get_callable_name(cb_arg);
_php_ibase_module_error("Callback argument %s is not a callable function", ZSTR_VAL(cb_name));
- zend_string_release(cb_name);
+ zend_string_release_ex(cb_name, 0);
RETURN_FALSE;
}
err_msg = intl_error_get_message(&oldobj->error);
zend_throw_exception(NULL, ZSTR_VAL(err_msg), 0);
- zend_string_release(err_msg);
+ zend_string_release_ex(err_msg, 0);
return retval;
}
if (!EG(exception)) {
zend_string *err = intl_error_get_message(NULL);
zend_throw_exception(IntlException_ce_ptr, ZSTR_VAL(err), intl_error_get_code(NULL));
- zend_string_release(err);
+ zend_string_release_ex(err, 0);
}
}
zend_restore_error_handling(&error_handling);
}
else {
smart_str_append( &ret, u8str );
- zend_string_release( u8str );
+ zend_string_release_ex( u8str, 0 );
}
smart_str_appends( &ret, "\"" );
any = 1;
else
{
smart_str_append( &ret, u8str );
- zend_string_release( u8str );
+ zend_string_release_ex( u8str, 0 );
}
smart_str_appends( &ret, "\"" );
any = 1;
ini_name = zend_string_init(LOCALE_INI_NAME, sizeof(LOCALE_INI_NAME) - 1, 0);
zend_alter_ini_entry(ini_name, locale_name, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
if (default_locale != NULL) {
- zend_string_release(locale_name);
+ zend_string_release_ex(locale_name, 0);
}
RETURN_TRUE;
/* Error in retriving data */
*result = 0;
if( tag_value ){
- zend_string_release( tag_value );
+ zend_string_release_ex( tag_value, 0 );
}
if( mod_loc_name ){
efree( mod_loc_name);
/* No value found */
*result = -1;
if( tag_value ){
- zend_string_release( tag_value );
+ zend_string_release_ex( tag_value, 0 );
}
if( mod_loc_name ){
efree( mod_loc_name);
/* No value found */
if( result == -1 ) {
if( tag_value){
- zend_string_release( tag_value);
+ zend_string_release_ex( tag_value, 0 );
}
RETURN_STRING( empty_result);
}
*/
}
if (key_value) {
- zend_string_release(key_value);
+ zend_string_release_ex(key_value, 0);
}
} else {
if( result == 1 ){
add_assoc_str( hash_arr, key_name , key_value);
cur_result = 1;
} else if (key_value) {
- zend_string_release(key_value);
+ zend_string_release_ex(key_value, 0);
}
}
}
}
if( variant ){
- zend_string_release( variant );
+ zend_string_release_ex( variant, 0 );
}
}
result = strToMatch( can_lang_tag->val , cur_lang_tag);
if( result == 0) {
efree( cur_lang_tag );
- zend_string_release( can_lang_tag );
+ zend_string_release_ex( can_lang_tag, 0 );
RETURN_FALSE;
}
result = strToMatch( can_loc_range->val , cur_loc_range );
if( result == 0) {
efree( cur_lang_tag );
- zend_string_release( can_lang_tag );
+ zend_string_release_ex( can_lang_tag, 0 );
efree( cur_loc_range );
- zend_string_release( can_loc_range );
+ zend_string_release_ex( can_loc_range, 0 );
RETURN_FALSE;
}
efree( cur_lang_tag );
efree( cur_loc_range );
if( can_lang_tag){
- zend_string_release( can_lang_tag );
+ zend_string_release_ex( can_lang_tag, 0 );
}
if( can_loc_range){
- zend_string_release( can_loc_range );
+ zend_string_release_ex( can_loc_range, 0 );
}
RETURN_TRUE;
}
efree( cur_loc_range );
}
if( can_lang_tag){
- zend_string_release( can_lang_tag );
+ zend_string_release_ex( can_lang_tag, 0 );
}
if( can_loc_range){
- zend_string_release( can_loc_range );
+ zend_string_release_ex( can_loc_range, 0 );
}
RETURN_FALSE;
lang_tag = get_icu_value_internal(cur_arr[i*2], LOC_CANONICALIZE_TAG, &result, 0);
if(result != 1 || lang_tag == NULL || !lang_tag->val[0]) {
if(lang_tag) {
- zend_string_release(lang_tag);
+ zend_string_release_ex(lang_tag, 0);
}
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "lookup_loc_range: unable to canonicalize lang_tag" , 0);
LOOKUP_CLEAN_RETURN(NULL);
}
cur_arr[i*2] = erealloc(cur_arr[i*2], lang_tag->len+1);
result = strToMatch(lang_tag->val, cur_arr[i*2]);
- zend_string_release(lang_tag);
+ zend_string_release_ex(lang_tag, 0);
if(result == 0) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "lookup_loc_range: unable to canonicalize lang_tag" , 0);
LOOKUP_CLEAN_RETURN(NULL);
/* Error */
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "lookup_loc_range: unable to canonicalize loc_range" , 0 );
if(can_loc_range) {
- zend_string_release(can_loc_range);
+ zend_string_release_ex(can_loc_range, 0);
}
LOOKUP_CLEAN_RETURN(NULL);
} else {
/* convert to lower and replace hyphens */
result = strToMatch(loc_range, cur_loc_range);
if(can_loc_range) {
- zend_string_release(can_loc_range);
+ zend_string_release_ex(can_loc_range, 0);
}
if(result == 0) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR, "lookup_loc_range: unable to canonicalize lang_tag" , 0);
spprintf(&message, 0, "The argument for key '%s' "
"cannot be used as a date or time", ZSTR_VAL(u8key));
intl_errors_set(&err, err.code, message, 1);
- zend_string_release(u8key);
+ zend_string_release_ex(u8key, 0);
efree(message);
}
continue;
"is available", ZSTR_VAL(u8key));
intl_errors_set(&err,
U_ILLEGAL_ARGUMENT_ERROR, message, 1);
- zend_string_release(u8key);
+ zend_string_release_ex(u8key, 0);
efree(message);
}
}
/* In a future release of Bison, this section will be replaced
by #include "json_parser.tab.h". */
-#ifndef YY_PHP_JSON_YY_HOME_HUIXINCHEN_OPENSOURCE_TRUNK_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED
-# define YY_PHP_JSON_YY_HOME_HUIXINCHEN_OPENSOURCE_TRUNK_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED
+#ifndef YY_PHP_JSON_YY_HOME_DMITRY_PHP_PHP_MASTER_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED
+# define YY_PHP_JSON_YY_HOME_DMITRY_PHP_PHP_MASTER_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
int php_json_yyparse (php_json_parser *parser);
-#endif /* !YY_PHP_JSON_YY_HOME_HUIXINCHEN_OPENSOURCE_TRUNK_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED */
+#endif /* !YY_PHP_JSON_YY_HOME_DMITRY_PHP_PHP_MASTER_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED */
/* Copy the second part of user declarations. */
case 25: /* pair */
- { zend_string_release(((*yyvaluep).pair).key); zval_dtor(&((*yyvaluep).pair).val); }
+ { zend_string_release_ex(((*yyvaluep).pair).key, 0); zval_dtor(&((*yyvaluep).pair).val); }
break;
zval zkey;
if (ZSTR_LEN(key) > 0 && ZSTR_VAL(key)[0] == '\0') {
parser->scanner.errcode = PHP_JSON_ERROR_INVALID_PROPERTY_NAME;
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
zval_dtor(zvalue);
zval_dtor(object);
return FAILURE;
zend_std_write_property(object, &zkey, zvalue, NULL);
Z_TRY_DELREF_P(zvalue);
}
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
return SUCCESS;
}
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
-#ifndef YY_PHP_JSON_YY_HOME_HUIXINCHEN_OPENSOURCE_TRUNK_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED
-# define YY_PHP_JSON_YY_HOME_HUIXINCHEN_OPENSOURCE_TRUNK_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED
+#ifndef YY_PHP_JSON_YY_HOME_DMITRY_PHP_PHP_MASTER_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED
+# define YY_PHP_JSON_YY_HOME_DMITRY_PHP_PHP_MASTER_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED
/* Debug traces. */
#ifndef YYDEBUG
# define YYDEBUG 0
int php_json_yyparse (php_json_parser *parser);
-#endif /* !YY_PHP_JSON_YY_HOME_HUIXINCHEN_OPENSOURCE_TRUNK_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED */
+#endif /* !YY_PHP_JSON_YY_HOME_DMITRY_PHP_PHP_MASTER_EXT_JSON_JSON_PARSER_TAB_H_INCLUDED */
%type <pair> pair
%destructor { zval_dtor(&$$); } <value>
-%destructor { zend_string_release
($$.key); zval_dtor(&$$.val); } <pair>
+%destructor { zend_string_release
_ex($$.key, 0); zval_dtor(&$$.val); } <pair>
%code {
static int php_json_yylex(union YYSTYPE *value, php_json_parser *parser);
zval zkey;
if (ZSTR_LEN(key) > 0 && ZSTR_VAL(key)[0] == '\0') {
parser->scanner.errcode = PHP_JSON_ERROR_INVALID_PROPERTY_NAME;
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
zval_dtor(zvalue);
zval_dtor(object);
return FAILURE;
zend_std_write_property(object, &zkey, zvalue, NULL);
Z_TRY_DELREF_P(zvalue);
}
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
return SUCCESS;
}
if (!zend_is_callable(callback, 0, NULL)) {
zend_string *callback_name = zend_get_callable_name(callback);
php_error_docref(NULL, E_WARNING, "Two arguments expected for '%s' to be a valid callback", ZSTR_VAL(callback_name));
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
RETURN_FALSE;
}
post_data_str = php_stream_copy_to_mem(SG(request_info).request_body, PHP_STREAM_COPY_ALL, 0);
detected = _php_mb_encoding_handler_ex(&info, arg, post_data_str ? ZSTR_VAL(post_data_str) : NULL);
if (post_data_str) {
- zend_string_release(post_data_str);
+ zend_string_release_ex(post_data_str, 0);
}
MBSTRG(http_input_identify) = detected;
if (ZSTR_LEN(tmp) > 0) {
if (!(re = _php_mb_compile_regex(ZSTR_VAL(tmp)))) {
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
return FAILURE;
}
}
MBSTRG(http_output_conv_mimetypes) = re;
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
return SUCCESS;
}
/* }}} */
ZEND_ASSERT(orig->type == ZEND_INTERNAL_FUNCTION);
str = zend_string_init_interned(p->save_func, strlen(p->save_func), 1);
zend_hash_add_mem(CG(function_table), str, orig, sizeof(zend_internal_function));
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
function_add_ref(orig);
str = zend_string_init_interned(p->orig_func, strlen(p->orig_func), 1);
ret = zend_hash_update_mem(CG(function_table), str, func, sizeof(zend_internal_function));
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
if (ret == NULL) {
php_error_docref("ref.mbstring", E_WARNING, "mbstring couldn't replace function %s.", p->orig_func);
return FAILURE;
} else {
RETVAL_TRUE;
}
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
}
}
/* }}} */
zend_hash_update(ht, fld_name, &val);
- zend_string_release(fld_name);
+ zend_string_release_ex(fld_name, 0);
}
fld_name = fld_val = NULL;
zend_hash_update(ht, fld_name, &val);
- zend_string_release(fld_name);
+ zend_string_release_ex(fld_name, 0);
}
}
return state;
tmp_headers = zend_string_init(Z_STRVAL_P(headers), Z_STRLEN_P(headers), 0);
MAIL_ASCIIZ_CHECK_MBSTRING(ZSTR_VAL(tmp_headers), ZSTR_LEN(tmp_headers));
str_headers = php_trim(tmp_headers, NULL, 0, 2);
- zend_string_release(tmp_headers);
+ zend_string_release_ex(tmp_headers, 0);
break;
case IS_ARRAY:
str_headers = php_mail_build_headers(headers);
if (n > 0 && p[n - 1] != '\n') {
mbfl_memory_device_strncat(&device, "\n", 1);
}
- zend_string_release(str_headers);
+ zend_string_release_ex(str_headers, 0);
}
if (!zend_hash_str_exists(&ht_headers, "MIME-VERSION", sizeof("MIME-VERSION") - 1)) {
}
if (extra_cmd) {
- zend_string_release(extra_cmd);
+ zend_string_release_ex(extra_cmd, 0);
}
if (to_r != to) {
mbfl_memory_device_clear(&device);
zend_hash_destroy(&ht_headers);
if (str_headers) {
- zend_string_release(str_headers);
+ zend_string_release_ex(str_headers, 0);
}
}
/* {{{ php_clear_mysql */
void php_clear_mysql(MY_MYSQL *mysql) {
if (mysql->hash_key) {
- zend_string_release(mysql->hash_key);
+ zend_string_release_ex(mysql->hash_key, 0);
mysql->hash_key = NULL;
}
if (!Z_ISUNDEF(mysql->li_read)) {
p.read_func = (r_func) ? r_func : mysqli_read_na;
p.write_func = (w_func) ? w_func : mysqli_write_na;
zend_hash_add_mem(h, p.name, &p, sizeof(mysqli_prop_handler));
- zend_string_release(p.name);
+ zend_string_release_ex(p.name, 1);
}
/* }}} */
err:
if (mysql->hash_key) {
- zend_string_release(mysql->hash_key);
+ zend_string_release_ex(mysql->hash_key, 0);
mysql->hash_key = NULL;
mysql->persistent = FALSE;
}
BIO_free(bio);
DBG_INF("Successfully loaded");
DBG_INF_FMT("Public key:%*.s", ZSTR_LEN(key_str), ZSTR_VAL(key_str));
- zend_string_release(key_str);
+ zend_string_release_ex(key_str, 0);
}
php_stream_close(stream);
}
if (!conn->options->connect_attr) {
goto oom;
}
- zend_hash_init(conn->options->connect_attr, 0, NULL, ZVAL_PTR_DTOR, conn->persistent);
+ zend_hash_init(conn->options->connect_attr, 0, NULL, conn->persistent ? ZVAL_INTERNAL_PTR_DTOR : ZVAL_PTR_DTOR, conn->persistent);
}
DBG_INF_FMT("Adding [%s][%s]", key, value);
{
ZVAL_NEW_STR(&attrz, zend_string_init(value, strlen(value), conn->persistent));
GC_MAKE_PERSISTENT_LOCAL(Z_COUNTED(attrz));
zend_hash_update(conn->options->connect_attr, str, &attrz);
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
}
break;
default:
UNKNOWN_SQLSTATE,
errstr? ZSTR_VAL(errstr):"Unknown error while connecting");
if (errstr) {
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
DBG_RETURN(NULL);
}
meta->root = NULL;
meta->def = NULL;
if (meta->sname) {
- zend_string_release(meta->sname);
+ zend_string_release_ex(meta->sname, 0);
}
}
}
UNKNOWN_SQLSTATE,
errstr? ZSTR_VAL(errstr):"Unknown error while connecting");
if (errstr) {
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
DBG_RETURN(NULL);
}
if (!zend_is_callable(callback, 0, 0)) {
callback_name = zend_get_callable_name(callback);
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(callback_name));
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
RETURN_FALSE;
}
#else
if (!zend_is_callable(callback, 0, &callback_name)) {
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(callback_name));
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
RETURN_FALSE;
}
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
#endif
}
/* if (zend_hash_add(statement->defines, name, name_len, define, sizeof(php_oci_define), (void **)&tmp_define) == SUCCESS) { */
zvtmp = zend_string_init(name, name_len, 0);
if ((define = zend_hash_add_new_ptr(statement->defines, zvtmp, define)) != NULL) {
- zend_string_release(zvtmp);
+ zend_string_release_ex(zvtmp, 0);
} else {
efree(define);
- zend_string_release(zvtmp);
+ zend_string_release_ex(zvtmp, 0);
RETURN_FALSE;
}
zend_string *zvtmp;
zvtmp = zend_string_init(columns[ i ]->name, columns[ i ]->name_len, 0);
zend_symtable_update(Z_ARRVAL(row), zvtmp, &element);
- zend_string_release(zvtmp);
+ zend_string_release_ex(zvtmp, 0);
}
}
array_init(&tmp);
zvtmp = zend_string_init(columns[ i ]->name, columns[ i ]->name_len, 0);
outarrs[ i ] = zend_symtable_update(Z_ARRVAL_P(array), zvtmp, &tmp);
- zend_string_release(zvtmp);
+ zend_string_release_ex(zvtmp, 0);
}
}
zvtmp = zend_string_init(name, name_len, 0);
bindp = (php_oci_bind *) ecalloc(1, sizeof(php_oci_bind));
bindp = zend_hash_update_ptr(statement->binds, zvtmp, bindp);
- zend_string_release(zvtmp);
+ zend_string_release_ex(zvtmp, 0);
}
/* Make sure the minimum of value_sz is 1 to avoid ORA-3149
zvtmp = zend_string_init(name, name_len, 0);
zend_hash_update_ptr(statement->binds, zvtmp, bind);
- zend_string_release(zvtmp);
+ zend_string_release_ex(zvtmp, 0);
statement->errcode = 0; /* retain backwards compat with OCI8 1.4 */
return 0;
Z_TYPE_INFO(ZEND_OP2_LITERAL(src)) = IS_STRING_EX;
memcpy(Z_STRVAL(ZEND_OP2_LITERAL(src)) + old_len, Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)));
Z_STRVAL(ZEND_OP2_LITERAL(src))[l] = '\0';
- zend_string_release(Z_STR(ZEND_OP2_LITERAL(opline)));
+ zend_string_release_ex(Z_STR(ZEND_OP2_LITERAL(opline)), 0);
ZVAL_STR(&ZEND_OP2_LITERAL(opline), zend_new_interned_string(Z_STR(ZEND_OP2_LITERAL(src))));
ZVAL_NULL(&ZEND_OP2_LITERAL(src));
MAKE_NOP(src);
ZVAL_LONG(&tmp, ret);
zend_hash_add(hash, key, &tmp);
}
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
return ret;
}
(LITERAL_NUM_RELATED(info[i].flags) != 2 ||
((info[i].flags & LITERAL_KIND_MASK) != LITERAL_VALUE &&
(info[Z_LVAL_P(pos)].flags & LITERAL_KIND_MASK) != LITERAL_VALUE))) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
map[i] = Z_LVAL_P(pos);
zval_ptr_dtor_nogc(&op_array->literals[i]);
n = LITERAL_NUM_RELATED(info[i].flags);
map[i] = j;
ZVAL_LONG(&zv, j);
zend_hash_add_new(&hash, key, &zv);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
if (i != j) {
op_array->literals[j] = op_array->literals[i];
info[j] = info[i];
if (vars_map[i] != (uint32_t) -1) {
names[vars_map[i]] = op_array->vars[i];
} else {
- zend_string_release(op_array->vars[i]);
+ zend_string_release_ex(op_array->vars[i], 0);
}
}
efree(op_array->vars);
op_array->vars = names;
} else {
for (i = 0; i < op_array->last_var; i++) {
- zend_string_release(op_array->vars[i]);
+ zend_string_release_ex(op_array->vars[i], 0);
}
efree(op_array->vars);
op_array->vars = NULL;
} else { /* ZEND_ADD_STRING */
memcpy(ptr, Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)));
ptr += Z_STRLEN(ZEND_OP2_LITERAL(opline));
- zend_string_release(Z_STR(ZEND_OP2_LITERAL(opline)));
+ zend_string_release_ex(Z_STR(ZEND_OP2_LITERAL(opline)), 0);
ZVAL_NEW_STR(&ZEND_OP2_LITERAL(opline), str);
}
next_op = opline + 1;
zend_optimizer_update_op1_const(op_array, opline, &t);
}
}
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
break;
} else if (Z_STRLEN(ZEND_OP2_LITERAL(init_opline)) == sizeof("extension_loaded")-1 &&
!memcmp(Z_STRVAL(ZEND_OP2_LITERAL(init_opline)),
zend_module_entry *m = zend_hash_find_ptr(&module_registry,
lc_name);
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
if (!m) {
if (PG(enable_dl)) {
break;
zend_optimizer_update_op1_const(op_array, opline, &t);
}
} else {
- zend_string_release(dirname);
+ zend_string_release_ex(dirname, 0);
}
break;
}
value_str = zval_get_string(value);
ZVAL_STR(result, new_str);
Z_STRVAL_P(result)[index] = ZSTR_VAL(value_str)[0];
- zend_string_release(value_str);
+ zend_string_release_ex(value_str, 0);
#endif
return FAILURE;
default:
if (zend_hash_add_ptr(&func_info, key, (void**)&func_infos[i]) == NULL) {
fprintf(stderr, "ERROR: Duplicate function info for \"%s\"\n", func_infos[i].name);
}
- zend_string_release(key);
+ zend_string_release_ex(key, 1);
}
}
zend_string *lcname = zend_string_tolower(ZEND_TYPE_NAME(arg_info->type));
tmp |= MAY_BE_OBJECT;
*pce = get_class_entry(script, lcname);
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
} else if (ZEND_TYPE_IS_CODE(arg_info->type)) {
zend_uchar type_hint = ZEND_TYPE_CODE(arg_info->type);
orig_chdir(INTERNAL_FUNCTION_PARAM_PASSTHRU);
if (VCWD_GETCWD(cwd, MAXPATHLEN)) {
if (ZCG(cwd)) {
- zend_string_release(ZCG(cwd));
+ zend_string_release_ex(ZCG(cwd), 0);
}
ZCG(cwd) = zend_string_init(cwd, strlen(cwd), 0);
} else {
if (ZCG(cwd)) {
- zend_string_release(ZCG(cwd));
+ zend_string_release_ex(ZCG(cwd), 0);
ZCG(cwd) = NULL;
}
}
if (full_path_ptr &&
persistent_script->script.filename != full_path_ptr &&
!zend_string_equal_content(persistent_script->script.filename, full_path_ptr)) {
- zend_string_release(full_path_ptr);
+ zend_string_release_ex(full_path_ptr, 0);
return FAILURE;
}
file_handle->opened_path = full_path_ptr;
if (persistent_script->timestamp == 0) {
if (full_path_ptr) {
- zend_string_release(full_path_ptr);
+ zend_string_release_ex(full_path_ptr, 0);
file_handle->opened_path = NULL;
}
return FAILURE;
if (zend_get_file_handle_timestamp(file_handle, NULL) == persistent_script->timestamp) {
if (full_path_ptr) {
- zend_string_release(full_path_ptr);
+ zend_string_release_ex(full_path_ptr, 0);
file_handle->opened_path = NULL;
}
return SUCCESS;
}
if (full_path_ptr) {
- zend_string_release(full_path_ptr);
+ zend_string_release_ex(full_path_ptr, 0);
file_handle->opened_path = NULL;
}
zend_shared_alloc_lock();
str = accel_new_interned_string(zend_string_copy(cwd_str));
if (str == cwd_str) {
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
str = NULL;
}
zend_shared_alloc_unlock();
}
accelerator_shm_read_unlock();
- zend_string_release(realpath);
+ zend_string_release_ex(realpath, 0);
return SUCCESS;
}
if (ZCG(root_hash) != buf.st_ino) {
zend_string *key = zend_string_init("opcache.enable", sizeof("opcache.enable")-1, 0);
zend_alter_ini_entry_chars(key, "0", 1, ZEND_INI_SYSTEM, ZEND_INI_STAGE_RUNTIME);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
zend_accel_error(ACCEL_LOG_WARNING, "Can't cache files in chroot() directory with too big inode");
return;
}
*/
if (ZCG(cwd)) {
- zend_string_release(ZCG(cwd));
+ zend_string_release_ex(ZCG(cwd), 0);
ZCG(cwd) = NULL;
}
zend_hash_destroy(&persistent_script->script.class_table);
if (persistent_script->script.filename) {
- zend_string_release(persistent_script->script.filename);
+ zend_string_release_ex(persistent_script->script.filename, 0);
}
efree(persistent_script);
if (!zend_hash_exists(EG(zend_constants), name)) {
zend_register_long_constant(ZSTR_VAL(name), ZSTR_LEN(name), persistent_script->compiler_halt_offset, CONST_CS, 0);
}
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
}
zend_hash_destroy(&ZCG(bind_hash));
if (writev(fd, vec, 3) != (ssize_t)(sizeof(info) + script->size + info.str_size)) {
zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot write to file '%s'\n", filename);
- zend_string_release((zend_string*)ZCG(mem));
+ zend_string_release_ex((zend_string*)ZCG(mem), 0);
close(fd);
efree(mem);
unlink(filename);
write(fd, ((zend_string*)ZCG(mem))->val, info.str_size) != info.str_size
) {
zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot write to file '%s'\n", filename);
- zend_string_release((zend_string*)ZCG(mem));
+ zend_string_release_ex((zend_string*)ZCG(mem), 0);
close(fd);
efree(mem);
unlink(filename);
}
#endif
- zend_string_release((zend_string*)ZCG(mem));
+ zend_string_release_ex((zend_string*)ZCG(mem), 0);
efree(mem);
if (zend_file_cache_flock(fd, LOCK_UN) != 0) {
zend_accel_error(ACCEL_LOG_WARNING, "opcache cannot unlock file '%s'\n", filename);
#define zend_accel_store_string(str) do { \
zend_string *new_str = zend_shared_alloc_get_xlat_entry(str); \
if (new_str) { \
- zend_string_release(str); \
+ zend_string_release_ex(str, 0); \
str = new_str; \
} else { \
new_str = zend_accel_memdup((void*)str, _ZSTR_STRUCT_SIZE(ZSTR_LEN(str))); \
- zend_string_release(str); \
+ zend_string_release_ex(str, 0); \
str = new_str; \
zend_string_hash_val(str); \
zend_set_str_gc_flags(str); \
}
} else {
if (!already_stored) {
- zend_string_release(op_array->doc_comment);
+ zend_string_release_ex(op_array->doc_comment, 0);
}
op_array->doc_comment = NULL;
}
if (!zend_shared_alloc_get_xlat_entry(prop->doc_comment)) {
zend_shared_alloc_register_xlat_entry(prop->doc_comment, prop->doc_comment);
}
- zend_string_release(prop->doc_comment);
+ zend_string_release_ex(prop->doc_comment, 0);
prop->doc_comment = NULL;
}
}
zend_string *doc_comment = zend_shared_alloc_get_xlat_entry(c->doc_comment);
if (!doc_comment) {
zend_shared_alloc_register_xlat_entry(c->doc_comment, c->doc_comment);
- zend_string_release(c->doc_comment);
+ zend_string_release_ex(c->doc_comment, 0);
}
c->doc_comment = NULL;
}
} else {
if (!zend_shared_alloc_get_xlat_entry(ce->info.user.doc_comment)) {
zend_shared_alloc_register_xlat_entry(ce->info.user.doc_comment, ce->info.user.doc_comment);
- zend_string_release(ce->info.user.doc_comment);
+ zend_string_release_ex(ce->info.user.doc_comment, 0);
}
ce->info.user.doc_comment = NULL;
}
} else if (!IS_ACCEL_INTERNED(str)) { \
zend_string *tmp = accel_new_interned_string(str); \
if (tmp != (str)) { \
- if (do_free) { \
- /*zend_string_release(str);*/ \
- } \
(str) = tmp; \
} else { \
ADD_STRING(str); \
}
if (keyresource == NULL && s != NULL) {
- zend_string_release(s);
+ zend_string_release_ex(s, 0);
}
}
/* }}} */
if (len >= 0) {
ZSTR_LEN(data) = len;
ZSTR_VAL(data)[len] = 0;
- RETVAL_STR(data);
+ RETVAL_NEW_STR(data);
} else {
php_openssl_store_errors();
- zend_string_release(data);
+ zend_string_release_ex(data, 0);
RETVAL_FALSE;
}
if (EVP_PKEY_derive(ctx, (unsigned char*)ZSTR_VAL(result), &key_size) > 0) {
ZSTR_LEN(result) = key_size;
ZSTR_VAL(result)[key_size] = 0;
- RETVAL_STR(result);
+ RETVAL_NEW_STR(result);
} else {
php_openssl_store_errors();
- zend_string_release(result);
+ zend_string_release_ex(result, 0);
RETVAL_FALSE;
}
} else {
RETURN_NEW_STR(out_buffer);
} else {
php_openssl_store_errors();
- zend_string_release(out_buffer);
+ zend_string_release_ex(out_buffer, 0);
RETURN_FALSE;
}
}
php_openssl_store_errors();
}
if (cryptedbuf) {
- zend_string_release(cryptedbuf);
+ zend_string_release_ex(cryptedbuf, 0);
}
if (keyresource == NULL) {
EVP_PKEY_free(pkey);
EVP_PKEY_free(pkey);
}
if (cryptedbuf) {
- zend_string_release(cryptedbuf);
+ zend_string_release_ex(cryptedbuf, 0);
}
}
/* }}} */
EVP_PKEY_free(pkey);
}
if (cryptedbuf) {
- zend_string_release(cryptedbuf);
+ zend_string_release_ex(cryptedbuf, 0);
}
}
/* }}} */
}
if (cryptedbuf) {
- zend_string_release(cryptedbuf);
+ zend_string_release_ex(cryptedbuf, 0);
}
if (keyresource == NULL) {
EVP_PKEY_free(pkey);
make_digest_ex(ZSTR_VAL(digest_str), (unsigned char*)ZSTR_VAL(sigbuf), siglen);
ZSTR_VAL(digest_str)[digest_str_len] = '\0';
- zend_string_release(sigbuf);
- RETVAL_STR(digest_str);
+ zend_string_release_ex(sigbuf, 0);
+ RETVAL_NEW_STR(digest_str);
}
} else {
php_openssl_store_errors();
- zend_string_release(sigbuf);
+ zend_string_release_ex(sigbuf, 0);
RETVAL_FALSE;
}
}
*/
php_openssl_store_errors();
- zend_string_release(*poutbuf);
+ zend_string_release_ex(*poutbuf, 0);
return FAILURE;
}
zend_string *base64_str;
base64_str = php_base64_encode((unsigned char*)ZSTR_VAL(outbuf), outlen);
- zend_string_release(outbuf);
+ zend_string_release_ex(outbuf, 0);
outbuf = base64_str;
RETVAL_STR(base64_str);
}
ZVAL_NEW_STR(tag, tag_str);
} else {
php_error_docref(NULL, E_WARNING, "Retrieving verification tag failed");
- zend_string_release(tag_str);
- zend_string_release(outbuf);
+ zend_string_release_ex(tag_str, 0);
+ zend_string_release_ex(outbuf, 0);
RETVAL_FALSE;
}
} else if (tag) {
"The authenticated tag cannot be provided for cipher that doesn not support AEAD");
} else if (mode.is_aead) {
php_error_docref(NULL, E_WARNING, "A tag should be provided when using AEAD mode");
- zend_string_release(outbuf);
+ zend_string_release_ex(outbuf, 0);
RETVAL_FALSE;
}
} else {
php_openssl_store_errors();
- zend_string_release(outbuf);
+ zend_string_release_ex(outbuf, 0);
RETVAL_FALSE;
}
RETVAL_STR(outbuf);
} else {
php_openssl_store_errors();
- zend_string_release(outbuf);
+ zend_string_release_ex(outbuf, 0);
RETVAL_FALSE;
}
efree(iv);
}
if (base64_str) {
- zend_string_release(base64_str);
+ zend_string_release_ex(base64_str, 0);
}
EVP_CIPHER_CTX_cleanup(cipher_ctx);
EVP_CIPHER_CTX_free(cipher_ctx);
#ifdef PHP_WIN32
/* random/urandom equivalent on Windows */
if (php_win32_get_random_bytes((unsigned char*)buffer->val, (size_t) buffer_length) == FAILURE){
- zend_string_release(buffer);
+ zend_string_release_ex(buffer, 0);
if (zstrong_result_returned) {
ZVAL_FALSE(zstrong_result_returned);
}
PHP_OPENSSL_RAND_ADD_TIME();
/* FIXME loop if requested size > INT_MAX */
if (RAND_bytes((unsigned char*)ZSTR_VAL(buffer), (int)buffer_length) <= 0) {
- zend_string_release(buffer);
+ zend_string_release_ex(buffer, 0);
if (zstrong_result_returned) {
ZVAL_FALSE(zstrong_result_returned);
}
#endif
ZSTR_VAL(buffer)[buffer_length] = 0;
- RETVAL_STR(buffer);
+ RETVAL_NEW_STR(buffer);
if (zstrong_result_returned) {
ZVAL_BOOL(zstrong_result_returned, 1);
fingerprint = php_openssl_x509_fingerprint(peer, method, 0);
if (fingerprint) {
result = strcasecmp(expected, ZSTR_VAL(fingerprint));
- zend_string_release(fingerprint);
+ zend_string_release_ex(fingerprint, 0);
}
return result;
strlcat(*pair, Z_STRVAL_P(element), pair_length);
/* Cleanup */
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
envi++;
pair++;
} ZEND_HASH_FOREACH_END();
zend_string *func_name = zend_get_callable_name(handle);
PCNTL_G(last_error) = EINVAL;
php_error_docref(NULL, E_WARNING, "%s is not a callable function name error", ZSTR_VAL(func_name));
- zend_string_release(func_name);
+ zend_string_release_ex(func_name, 0);
RETURN_FALSE;
}
if (zv) {
#if HAVE_SETLOCALE
if (key != regex) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
#endif
return (pcre_cache_entry*)Z_PTR_P(zv);
if (*p == 0) {
#if HAVE_SETLOCALE
if (key != regex) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
#endif
php_error_docref(NULL, E_WARNING,
if (isalnum((int)*(unsigned char *)&delimiter) || delimiter == '\\') {
#if HAVE_SETLOCALE
if (key != regex) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
#endif
php_error_docref(NULL,E_WARNING, "Delimiter must not be alphanumeric or backslash");
if (*pp == 0) {
#if HAVE_SETLOCALE
if (key != regex) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
#endif
if (pp < ZSTR_VAL(regex) + ZSTR_LEN(regex)) {
efree(pattern);
#if HAVE_SETLOCALE
if (key != regex) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
#endif
return NULL;
if (re == NULL) {
#if HAVE_SETLOCALE
if (key != regex) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
#endif
pcre2_get_error_message(errnumber, error, sizeof(error));
if (rc < 0) {
#if HAVE_SETLOCALE
if (key != regex) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
#endif
php_error_docref(NULL, E_WARNING, "Internal pcre2_pattern_info() error %d", rc);
if (rc < 0) {
#if HAVE_SETLOCALE
if (key != regex) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
#endif
php_error_docref(NULL, E_WARNING, "Internal pcre_pattern_info() error %d", rc);
GC_MAKE_PERSISTENT_LOCAL(str);
#if HAVE_SETLOCALE
if (key != regex) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
#endif
key = str;
} else {
pcre_handle_exec_error(count);
if (result) {
- zend_string_release(result);
+ zend_string_release_ex(result, 0);
result = NULL;
}
break;
/* If using custom function, copy result to the buffer and clean up. */
memcpy(ZSTR_VAL(result) + result_len, ZSTR_VAL(eval_result), ZSTR_LEN(eval_result));
result_len += ZSTR_LEN(eval_result);
- zend_string_release(eval_result);
+ zend_string_release_ex(eval_result, 0);
if (limit) {
limit--;
} else {
pcre_handle_exec_error(count);
if (result) {
- zend_string_release(result);
+ zend_string_release_ex(result, 0);
result = NULL;
}
break;
replace_count);
zend_tmp_string_release(tmp_replace_str);
zend_tmp_string_release(tmp_regex_str);
- zend_string_release(subject_str);
+ zend_string_release_ex(subject_str, 0);
subject_str = result;
if (UNEXPECTED(result == NULL)) {
break;
limit,
replace_count);
zend_tmp_string_release(tmp_regex_str);
- zend_string_release(subject_str);
+ zend_string_release_ex(subject_str, 0);
subject_str = result;
if (UNEXPECTED(result == NULL)) {
Z_STR_P(replace),
limit,
replace_count);
- zend_string_release(subject_str);
+ zend_string_release_ex(subject_str, 0);
} else {
result = php_pcre_replace_array(Z_ARRVAL_P(regex),
replace,
fci, fcc,
limit,
replace_count);
- zend_string_release(subject_str);
+ zend_string_release_ex(subject_str, 0);
return result;
} else {
zval *regex_entry;
limit,
replace_count);
zend_tmp_string_release(tmp_regex_str);
- zend_string_release(subject_str);
+ zend_string_release_ex(subject_str, 0);
subject_str = result;
if (UNEXPECTED(result == NULL)) {
break;
if (!is_filter || replace_count > old_replace_count) {
RETVAL_STR(result);
} else {
- zend_string_release(result);
+ zend_string_release_ex(result, 0);
RETVAL_NULL();
}
} else {
zend_hash_index_add_new(Z_ARRVAL_P(return_value), num_key, &zv);
}
} else {
- zend_string_release(result);
+ zend_string_release_ex(result, 0);
}
}
} ZEND_HASH_FOREACH_END();
if (!zend_is_callable_ex(replace, NULL, 0, NULL, &fcc, NULL)) {
zend_string *callback_name = zend_get_callable_name(replace);
php_error_docref(NULL, E_WARNING, "Requires argument 2, '%s', to be a valid callback", ZSTR_VAL(callback_name));
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
ZVAL_STR(return_value, zval_get_string(subject));
return;
}
if (!zend_is_callable_ex(replace, NULL, 0, NULL, &fcc, NULL)) {
zend_string *callback_name = zend_get_callable_name(replace);
php_error_docref(NULL, E_WARNING, "'%s' is not a valid callback", ZSTR_VAL(callback_name));
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
zval_ptr_dtor(®ex);
zval_ptr_dtor(return_value);
ZVAL_COPY(return_value, subject);
count = num_subpats;
} else if (count < 0 && count != PCRE2_ERROR_NOMATCH) {
pcre_handle_exec_error(count);
- zend_string_release(subject_str);
+ zend_string_release_ex(subject_str, 0);
break;
}
}
}
- zend_string_release(subject_str);
+ zend_string_release_ex(subject_str, 0);
} ZEND_HASH_FOREACH_END();
if (match_data != mdata) {
pcre2_match_data_free(match_data);
}
if (message) {
- zend_string_release(message);
+ zend_string_release_ex(message, 0);
}
if (supp) {
static void cls_method_dtor(zval *el) /* {{{ */ {
zend_function *func = (zend_function*)Z_PTR_P(el);
if (func->common.function_name) {
- zend_string_release(func->common.function_name);
+ zend_string_release_ex(func->common.function_name, 0);
}
efree(func);
}
static void cls_method_pdtor(zval *el) /* {{{ */ {
zend_function *func = (zend_function*)Z_PTR_P(el);
if (func->common.function_name) {
- zend_string_release(func->common.function_name);
+ zend_string_release_ex(func->common.function_name, 1);
}
pefree(func, 1);
}
lc_method_name = zend_string_tolower(method_name);
fbc = zend_hash_find_ptr(dbh_obj->inner->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH], lc_method_name);
- zend_string_release(lc_method_name);
+ zend_string_release_ex(lc_method_name, 0);
}
out:
-/* Generated by re2c 1.0.3 */
+/* Generated by re2c 0.16 */
#line 1 "ext/pdo/pdo_sql_parser.re"
/*
+----------------------------------------------------------------------+
if (yych <= 0x00) goto yy7;
goto yy21;
yy9:
- ++YYCURSOR;
+ yych = *++YYCURSOR;
goto yy7;
yy10:
yych = *++YYCURSOR;
default: goto yy7;
}
yy11:
- yych = *++YYCURSOR;
+ yych = *(YYMARKER = ++YYCURSOR);
switch (yych) {
case '*': goto yy28;
default: goto yy7;
default: goto yy7;
}
yy13:
- yych = *++YYCURSOR;
- switch (yych) {
+ ++YYCURSOR;
+ switch ((yych = *YYCURSOR)) {
case '?': goto yy36;
default: goto yy14;
}
}
yy40:
++YYCURSOR;
+ yych = *YYCURSOR;
goto yy27;
}
#line 66 "ext/pdo/pdo_sql_parser.re"
ret = -1;
strncpy(stmt->error_code, stmt->dbh->error_code, 6);
if (buf) {
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
}
goto clean_up;
}
if (buf) {
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
}
} else {
pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource");
ret = -1;
strncpy(stmt->error_code, stmt->dbh->error_code, 6);
if (buf) {
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
}
goto clean_up;
}
}
if (buf) {
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
}
}
} else {
ret = -1;
strncpy(stmt->error_code, stmt->dbh->error_code, 6);
if (buf) {
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
}
goto clean_up;
}
if (buf) {
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
}
} else {
pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource");
ret = -1;
strncpy(stmt->error_code, stmt->dbh->error_code, 6);
if (buf) {
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
}
goto clean_up;
}
}
if (buf) {
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
}
}
} else {
}
if (param->name) {
- zend_string_release(param->name);
+ zend_string_release_ex(param->name, 0);
}
if (!Z_ISUNDEF(param->parameter)) {
if (is_param && !rewrite_name_to_position(stmt, param)) {
if (param->name) {
- zend_string_release(param->name);
+ zend_string_release_ex(param->name, 0);
param->name = NULL;
}
return 0;
if (!stmt->methods->param_hook(stmt, param, PDO_PARAM_EVT_NORMALIZE
)) {
if (param->name) {
- zend_string_release(param->name);
+ zend_string_release_ex(param->name, 0);
param->name = NULL;
}
return 0;
for (i = 0; i < stmt->column_count; i++) {
if (cols[i].name) {
- zend_string_release(cols[i].name);
+ zend_string_release_ex(cols[i].name, 0);
}
}
efree(stmt->columns);
}
out:
- zend_string_release(lc_method_name);
+ zend_string_release_ex(lc_method_name, 0);
if (!fbc) {
fbc = std_object_handlers.get_method(object_pp, method_name, key);
}
for (i = 0; i < stmt->column_count; i++) {
if (cols[i].name) {
- zend_string_release(cols[i].name);
+ zend_string_release_ex(cols[i].name, 0);
cols[i].name = NULL;
}
}
lc_method_name = zend_string_tolower(method_name);
if ((fbc = zend_hash_find_ptr(&pdo_row_ce->function_table, lc_method_name)) == NULL) {
- zend_string_release(lc_method_name);
+ zend_string_release_ex(lc_method_name, 0);
return NULL;
}
- zend_string_release(lc_method_name);
+ zend_string_release_ex(lc_method_name, 0);
return fbc;
}
efree(H->date_format);
}
spprintf(&H->date_format, 0, "%s", ZSTR_VAL(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
return 1;
efree(H->time_format);
}
spprintf(&H->time_format, 0, "%s", ZSTR_VAL(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
return 1;
efree(H->timestamp_format);
}
spprintf(&H->timestamp_format, 0, "%s", ZSTR_VAL(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
return 1;
}
init_cmd = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_INIT_COMMAND, NULL);
if (init_cmd) {
if (mysql_options(H->server, MYSQL_INIT_COMMAND, (const char *)ZSTR_VAL(init_cmd))) {
- zend_string_release(init_cmd);
+ zend_string_release_ex(init_cmd, 0);
pdo_mysql_error(dbh);
goto cleanup;
}
- zend_string_release(init_cmd);
+ zend_string_release_ex(init_cmd, 0);
}
#ifndef PDO_USE_MYSQLND
default_file = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_READ_DEFAULT_FILE, NULL);
if (default_file) {
if (mysql_options(H->server, MYSQL_READ_DEFAULT_FILE, (const char *)ZSTR_VAL(default_file))) {
- zend_string_release(default_file);
+ zend_string_release_ex(default_file, 0);
pdo_mysql_error(dbh);
goto cleanup;
}
- zend_string_release(default_file);
+ zend_string_release_ex(default_file, 0);
}
default_group = pdo_attr_strval(driver_options, PDO_MYSQL_ATTR_READ_DEFAULT_GROUP, NULL);
if (default_group) {
if (mysql_options(H->server, MYSQL_READ_DEFAULT_GROUP, (const char *)ZSTR_VAL(default_group))) {
- zend_string_release(default_group);
+ zend_string_release_ex(default_group, 0);
pdo_mysql_error(dbh);
goto cleanup;
}
- zend_string_release(default_group);
+ zend_string_release_ex(default_group, 0);
}
#endif
compress = pdo_attr_lval(driver_options, PDO_MYSQL_ATTR_COMPRESS, 0);
ssl_capath? ZSTR_VAL(ssl_capath) : NULL,
ssl_cipher? ZSTR_VAL(ssl_cipher) : NULL);
if (ssl_key) {
- zend_string_release(ssl_key);
+ zend_string_release_ex(ssl_key, 0);
}
if (ssl_cert) {
- zend_string_release(ssl_cert);
+ zend_string_release_ex(ssl_cert, 0);
}
if (ssl_ca) {
- zend_string_release(ssl_ca);
+ zend_string_release_ex(ssl_ca, 0);
}
if (ssl_capath) {
- zend_string_release(ssl_capath);
+ zend_string_release_ex(ssl_capath, 0);
}
if (ssl_cipher) {
- zend_string_release(ssl_cipher);
+ zend_string_release_ex(ssl_cipher, 0);
}
}
if (public_key) {
if (mysql_options(H->server, MYSQL_SERVER_PUBLIC_KEY, ZSTR_VAL(public_key))) {
pdo_mysql_error(dbh);
- zend_string_release(public_key);
+ zend_string_release_ex(public_key, 0);
goto cleanup;
}
- zend_string_release(public_key);
+ zend_string_release_ex(public_key, 0);
}
}
#endif
H->server = PQconnectdb(conn_str);
if (tmp_user) {
- zend_string_release(tmp_user);
+ zend_string_release_ex(tmp_user, 0);
}
if (tmp_pass) {
- zend_string_release(tmp_pass);
+ zend_string_release_ex(tmp_pass, 0);
}
efree(conn_str);
if (!zend_is_callable(callback, 0, NULL)) {
zend_string *cbname = zend_get_callable_name(callback);
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
- zend_string_release(cbname);
+ zend_string_release_ex(cbname, 0);
RETURN_FALSE;
}
if (!zend_is_callable(step_callback, 0, NULL)) {
zend_string *cbname = zend_get_callable_name(step_callback);
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
- zend_string_release(cbname);
+ zend_string_release_ex(cbname, 0);
RETURN_FALSE;
}
if (!zend_is_callable(fini_callback, 0, NULL)) {
zend_string *cbname = zend_get_callable_name(fini_callback);
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
- zend_string_release(cbname);
+ zend_string_release_ex(cbname, 0);
RETURN_FALSE;
}
if (!zend_is_callable(callback, 0, NULL)) {
zend_string *cbname = zend_get_callable_name(callback);
php_error_docref(NULL, E_WARNING, "function '%s' is not callable", ZSTR_VAL(cbname));
- zend_string_release(cbname);
+ zend_string_release_ex(cbname, 0);
RETURN_FALSE;
}
}
stream = php_stream_open_wrapper_ex(name, "rb", 0 | REPORT_ERRORS, NULL, context);
if (entry_str) {
- zend_string_release(entry_str);
+ zend_string_release_ex(entry_str, 0);
} else {
efree(name);
}
if (contents && ZSTR_LEN(contents) > 0) {
RETVAL_STR(contents);
} else if (contents) {
- zend_string_release(contents);
+ zend_string_release_ex(contents, 0);
RETVAL_EMPTY_STRING();
} else {
RETVAL_FALSE;
context = php_stream_context_from_zval(zcontext, 0);
stream = php_stream_open_wrapper_ex(name, "rb", 0 | REPORT_ERRORS, NULL, context);
if (entry_str) {
- zend_string_release(entry_str);
+ zend_string_release_ex(entry_str, 0);
} else {
efree(name);
}
context = php_stream_context_from_zval(zcontext, 0);
stream = php_stream_open_wrapper_ex(name, mode, 0 | REPORT_ERRORS, NULL, context);
if (entry_str) {
- zend_string_release(entry_str);
+ zend_string_release_ex(entry_str, 0);
} else {
efree(name);
}
(*pphar)->is_writeable = 1;
}
if (actual) {
- zend_string_release(actual);
+ zend_string_release_ex(actual, 0);
}
return SUCCESS;
} else {
/* file exists, but is either corrupt or not a phar archive */
if (actual) {
- zend_string_release(actual);
+ zend_string_release_ex(actual, 0);
}
return FAILURE;
}
}
if (actual) {
- zend_string_release(actual);
+ zend_string_release_ex(actual, 0);
}
if (PHAR_G(readonly) && !is_data) {
}
}
if (actual) {
- zend_string_release(actual);
+ zend_string_release_ex(actual, 0);
}
return FAILURE;
}
ret = phar_open_from_fp(fp, fname, fname_len, alias, alias_len, options, pphar, is_data, error);
if (actual) {
- zend_string_release(actual);
+ zend_string_release_ex(actual, 0);
}
return ret;
spprintf(error, 0, "unable to open phar for reading \"%s\"", fname);
}
if (actual) {
- zend_string_release(actual);
+ zend_string_release_ex(actual, 0);
}
return FAILURE;
}
ret = phar_open_from_fp(fp, fname, fname_len, alias, alias_len, REPORT_ERRORS, NULL, 0, error);
if (actual) {
- zend_string_release(actual);
+ zend_string_release_ex(actual, 0);
}
return ret;
}
if (opened) {
- zend_string_release(opened);
+ zend_string_release_ex(opened, 0);
}
if (close_fp) {
}
if (opened) {
- zend_string_release(opened);
+ zend_string_release_ex(opened, 0);
}
if (temp) {
}
zend_throw_exception_ex(spl_ce_RuntimeException, 0,
"Unable to read stub");
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
return;
}
entry->filename = estrndup(ZSTR_VAL(new_str_key), ZSTR_LEN(new_str_key));
entry->filename_len = ZSTR_LEN(new_str_key);
- zend_string_release(str_key);
+ zend_string_release_ex(str_key, 0);
b->h = zend_string_hash_val(new_str_key);
b->key = new_str_key;
}
memcpy(ZSTR_VAL(new_str_key) + to_len, ZSTR_VAL(str_key) + from_len, ZSTR_LEN(str_key) - from_len);
ZSTR_VAL(new_str_key)[ZSTR_LEN(new_str_key)] = 0;
- zend_string_release(str_key);
+ zend_string_release_ex(str_key, 0);
b->h = zend_string_hash_val(new_str_key);
b->key = new_str_key;
}
memcpy(ZSTR_VAL(new_str_key) + to_len, ZSTR_VAL(str_key) + from_len, ZSTR_LEN(str_key) - from_len);
ZSTR_VAL(new_str_key)[ZSTR_LEN(new_str_key)] = 0;
- zend_string_release(str_key);
+ zend_string_release_ex(str_key, 0);
b->h = zend_string_hash_val(new_str_key);
b->key = new_str_key;
}
if (str) {
len = ZSTR_LEN(str);
user_stub = estrndup(ZSTR_VAL(str), ZSTR_LEN(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
} else {
user_stub = NULL;
len = 0;
if (FAILURE == phar_call_openssl_signverify(0, fp, end_of_phar, pubkey ? ZSTR_VAL(pubkey) : NULL, pubkey ? ZSTR_LEN(pubkey) : 0, &sig, &tempsig)) {
if (pubkey) {
- zend_string_release(pubkey);
+ zend_string_release_ex(pubkey, 0);
}
if (error) {
}
if (pubkey) {
- zend_string_release(pubkey);
+ zend_string_release_ex(pubkey, 0);
}
sig_len = tempsig;
in = BIO_new_mem_buf(pubkey ? ZSTR_VAL(pubkey) : NULL, pubkey ? ZSTR_LEN(pubkey) : 0);
if (NULL == in) {
- zend_string_release(pubkey);
+ zend_string_release_ex(pubkey, 0);
if (error) {
spprintf(error, 0, "openssl signature could not be processed");
}
key = PEM_read_bio_PUBKEY(in, NULL,NULL, NULL);
BIO_free(in);
- zend_string_release(pubkey);
+ zend_string_release_ex(pubkey, 0);
if (NULL == key) {
if (error) {
if (str) {
entry.uncompressed_filesize = ZSTR_LEN(str);
actual_alias = estrndup(ZSTR_VAL(str), ZSTR_LEN(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
} else {
actual_alias = NULL;
entry.uncompressed_filesize = 0;
if (str) {
entry.uncompressed_filesize = ZSTR_LEN(str);
actual_alias = estrndup(ZSTR_VAL(str), ZSTR_LEN(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
} else {
actual_alias = NULL;
entry.uncompressed_filesize = 0;
if (str) {
entry.uncompressed_filesize = ZSTR_LEN(str);
actual_alias = estrndup(ZSTR_VAL(str), ZSTR_LEN(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
} else {
actual_alias = NULL;
entry.uncompressed_filesize = 0;
if (str) {
len = ZSTR_LEN(str);
user_stub = estrndup(ZSTR_VAL(str), ZSTR_LEN(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
} else {
user_stub = NULL;
len = 0;
if (!zend_is_callable(arg, 0, NULL)) {
zend_string *name = zend_get_callable_name(arg);
php_error_docref(NULL, E_WARNING, "%s is not callable", ZSTR_VAL(name));
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
RETURN_FALSE;
}
if (!zend_is_callable(callback, 0, NULL)) {
zend_string *name = zend_get_callable_name(callback);
php_error_docref(NULL, E_WARNING, "%s is not callable", ZSTR_VAL(name));
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
RETURN_FALSE;
}
class_name = zend_string_alloc(class_name_len, 0);
zend_str_tolower_copy(ZSTR_VAL(class_name), text, class_name_len);
if ((ce = zend_lookup_class(class_name)) == NULL) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return NULL;
}
lc_text = zend_str_tolower_dup(class_name_end + 2, textlen - 2 - class_name_len);
}
efree(lc_text);
if (class_name_end) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
}
if (ce && retval) {
int len = class_name_len + 2 + strlen(retval) + 1;
cmd = zend_string_init(&line[1], param - &line[1] - 1, 0);
zend_alter_ini_entry_chars_ex(cmd, param, strlen(param), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
- zend_string_release(cmd);
+ zend_string_release_ex(cmd, 0);
add_history(line);
- zend_string_release(prompt);
+ zend_string_release_ex(prompt, 0);
/* TODO: This might be wrong! */
prompt = cli_get_prompt("php", '>');
continue;
}
free(line);
- zend_string_release(prompt);
+ zend_string_release_ex(prompt, 0);
if (!cli_is_valid_code(code, pos, &prompt)) {
continue;
free(history_file);
#endif
efree(code);
- zend_string_release(prompt);
+ zend_string_release_ex(prompt, 0);
return EG(exit_status);
}
/* }}} */
if (fptr
&& (fptr->internal_function.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE))
{
- zend_string_release(fptr->internal_function.function_name);
+ zend_string_release_ex(fptr->internal_function.function_name, 0);
zend_free_trampoline(fptr);
}
}
break;
case REF_TYPE_DYNAMIC_PROPERTY:
prop_reference = (property_reference*)intern->ptr;
- zend_string_release(prop_reference->prop.name);
+ zend_string_release_ex(prop_reference->prop.name, 0);
efree(intern->ptr);
break;
case REF_TYPE_GENERATOR:
smart_str_append_printf(str, "%s }\n", indent);
smart_str_append_printf(str, "%s}\n", indent);
- zend_string_release(sub_indent);
+ zend_string_release_ex(sub_indent, 0);
}
/* }}} */
smart_str_append_printf(str, ", overwrites %s", ZSTR_VAL(overwrites->common.scope->name));
}
}
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
}
}
if (fptr->common.prototype && fptr->common.prototype->common.scope) {
smart_str_append_printf(str, "%s }\n", indent);
}
smart_str_free(&str_classes);
- zend_string_release(sub_indent);
+ zend_string_release_ex(sub_indent, 0);
}
smart_str_append_printf(str, "%s}\n", indent);
if (position < 0 || (uint32_t)position >= num_args) {
if (fptr->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
if (fptr->type != ZEND_OVERLOADED_FUNCTION) {
- zend_string_release(fptr->common.function_name);
+ zend_string_release_ex(fptr->common.function_name, 0);
}
zend_free_trampoline(fptr);
}
if (position == -1) {
if (fptr->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE) {
if (fptr->type != ZEND_OVERLOADED_FUNCTION) {
- zend_string_release(fptr->common.function_name);
+ zend_string_release_ex(fptr->common.function_name, 0);
}
zend_free_trampoline(fptr);
}
if (!EG(exception)) {
zend_throw_exception_ex(reflection_exception_ptr, -1, "Class %s does not exist", ZSTR_VAL(classname));
}
- zend_string_release(classname);
+ zend_string_release_ex(classname, 0);
return;
}
- zend_string_release(classname);
+ zend_string_release_ex(classname, 0);
if (!instanceof_function(ce, ce2)) {
zend_throw_exception_ex(reflection_exception_ptr, -1, "Fully qualified property name %s::%s does not specify a base class of %s", ZSTR_VAL(ce2->name), str_name, ZSTR_VAL(ce->name));
} else {
php_error_docref(NULL, E_WARNING, "read returned less bytes than requested");
}
- zend_string_release(*val);
+ zend_string_release_ex(*val, 0);
*val = ZSTR_EMPTY_ALLOC();
return FAILURE;
}
/* FIXME: mod_data(data) should not be NULL (User handler could be NULL) */
if (data && ps_files_key_exists(data, ZSTR_VAL(sid)) == SUCCESS) {
if (sid) {
- zend_string_release(sid);
+ zend_string_release_ex(sid, 0);
sid = NULL;
}
if (--maxfail < 0) {
/* Check collision */
if (ps_mm_key_exists(data, sid->val) == SUCCESS) {
if (sid) {
- zend_string_release(sid);
+ zend_string_release_ex(sid, 0);
sid = NULL;
}
if (!(maxfail--)) {
} zend_end_try();
}
if (PS(id)) {
- zend_string_release(PS(id));
+ zend_string_release_ex(PS(id), 0);
PS(id) = NULL;
}
if (PS(session_vars)) {
- zend_string_release(PS(session_vars));
+ zend_string_release_ex(PS(session_vars), 0);
PS(session_vars) = NULL;
}
ZVAL_NEW_REF(&PS(http_session_vars), &session_vars);
Z_ADDREF_P(&PS(http_session_vars));
zend_hash_update_ind(&EG(symbol_table), var_name, &PS(http_session_vars));
- zend_string_release(var_name);
+ zend_string_release_ex(var_name, 0);
}
/* }}} */
/* If there is no ID, use session module to create one */
if (!PS(id) || !ZSTR_VAL(PS(id))[0]) {
if (PS(id)) {
- zend_string_release(PS(id));
+ zend_string_release_ex(PS(id), 0);
}
PS(id) = PS(mod)->s_create_sid(&PS(mod_data));
if (!PS(id)) {
} else if (PS(use_strict_mode) && PS(mod)->s_validate_sid &&
PS(mod)->s_validate_sid(&PS(mod_data), PS(id)) == FAILURE) {
if (PS(id)) {
- zend_string_release(PS(id));
+ zend_string_release_ex(PS(id), 0);
}
PS(id) = PS(mod)->s_create_sid(&PS(mod_data));
if (!PS(id)) {
php_session_gc(0);
if (PS(session_vars)) {
- zend_string_release(PS(session_vars));
+ zend_string_release_ex(PS(session_vars), 0);
PS(session_vars) = NULL;
}
if (val) {
PS(session_vars) = zend_string_copy(val);
}
php_session_decode(val);
- zend_string_release(val);
+ zend_string_release_ex(val, 0);
}
return SUCCESS;
}
} else {
ret = PS(mod)->s_write(&PS(mod_data), PS(id), val, PS(gc_maxlifetime));
}
- zend_string_release(val);
+ zend_string_release_ex(val, 0);
} else {
ret = PS(mod)->s_write(&PS(mod_data), PS(id), ZSTR_EMPTY_ALLOC(), PS(gc_maxlifetime));
}
ZVAL_NEW_REF(&PS(http_session_vars), &session_vars);
Z_ADDREF_P(&PS(http_session_vars));
zend_hash_update_ind(&EG(symbol_table), var_name, &PS(http_session_vars));
- zend_string_release(var_name);
+ zend_string_release_ex(var_name, 0);
return SUCCESS;
}
/* }}} */
ZVAL_PTR(&rv, current);
php_set_session_var(name, &rv, &var_hash);
} else {
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
php_session_normalize_vars();
PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
return FAILURE;
}
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
}
php_session_normalize_vars();
ZVAL_PTR(&rv, current);
php_set_session_var(name, &rv, &var_hash);
} else {
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
retval = FAILURE;
goto break_outer_loop;
}
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
p = q;
}
smart_str_appendc(&ncookie, '=');
smart_str_appendl(&ncookie, ZSTR_VAL(e_id), ZSTR_LEN(e_id));
- zend_string_release(e_session_name);
- zend_string_release(e_id);
+ zend_string_release_ex(e_session_name, 0);
+ zend_string_release_ex(e_id, 0);
if (PS(cookie_lifetime) > 0) {
struct timeval tv;
date_fmt = php_format_date("D, d-M-Y H:i:s T", sizeof("D, d-M-Y H:i:s T")-1, t, 0);
smart_str_appends(&ncookie, COOKIE_EXPIRES);
smart_str_appendl(&ncookie, ZSTR_VAL(date_fmt), ZSTR_LEN(date_fmt));
- zend_string_release(date_fmt);
+ zend_string_release_ex(date_fmt, 0);
smart_str_appends(&ncookie, COOKIE_MAX_AGE);
smart_str_append_long(&ncookie, PS(cookie_lifetime));
smart_str_appends(&var, ZSTR_VAL(PS(id)));
smart_str_0(&var);
if (sid) {
- zend_string_release(Z_STR_P(sid));
+ zend_string_release_ex(Z_STR_P(sid), 0);
ZVAL_NEW_STR(sid, var.s);
} else {
REGISTER_STRINGL_CONSTANT("SID", ZSTR_VAL(var.s), ZSTR_LEN(var.s), 0);
}
} else {
if (sid) {
- zend_string_release(Z_STR_P(sid));
+ zend_string_release_ex(Z_STR_P(sid), 0);
ZVAL_EMPTY_STRING(sid);
} else {
REGISTER_STRINGL_CONSTANT("SID", "", 0, 0);
zend_string *sname;
sname = zend_string_init(PS(session_name), strlen(PS(session_name)), 0);
php_url_scanner_reset_session_var(sname, 1); /* This may fail when session name has changed */
- zend_string_release(sname);
+ zend_string_release_ex(sname, 0);
php_url_scanner_add_session_var(PS(session_name), strlen(PS(session_name)), ZSTR_VAL(PS(id)), ZSTR_LEN(PS(id)), 1);
}
return SUCCESS;
Z_STRLEN_P(data) != 0 &&
strstr(Z_STRVAL_P(data), PS(extern_referer_chk)) == NULL
) {
- zend_string_release(PS(id));
+ zend_string_release_ex(PS(id), 0);
PS(id) = NULL;
}
}
/* Finally check session id for dangerous characters
* Security note: session id may be embedded in HTML pages.*/
if (PS(id) && strpbrk(ZSTR_VAL(PS(id)), "\r\n\t <>'\"\\")) {
- zend_string_release(PS(id));
+ zend_string_release_ex(PS(id), 0);
PS(id) = NULL;
}
|| php_session_cache_limiter() == -2) {
PS(session_status) = php_session_none;
if (PS(id)) {
- zend_string_release(PS(id));
+ zend_string_release_ex(PS(id), 0);
PS(id) = NULL;
}
return FAILURE;
ini_name = zend_string_init("session.cookie_lifetime", sizeof("session.cookie_lifetime") - 1, 0);
if (zend_alter_ini_entry(ini_name, Z_STR_P(lifetime), PHP_INI_USER, PHP_INI_STAGE_RUNTIME) == FAILURE) {
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
RETURN_FALSE;
}
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
if (path) {
ini_name = zend_string_init("session.cookie_path", sizeof("session.cookie_path") - 1, 0);
if (zend_alter_ini_entry(ini_name, path, PHP_INI_USER, PHP_INI_STAGE_RUNTIME) == FAILURE) {
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
RETURN_FALSE;
}
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
}
if (domain) {
ini_name = zend_string_init("session.cookie_domain", sizeof("session.cookie_domain") - 1, 0);
if (zend_alter_ini_entry(ini_name, domain, PHP_INI_USER, PHP_INI_STAGE_RUNTIME) == FAILURE) {
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
RETURN_FALSE;
}
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
}
if (argc > 3) {
ini_name = zend_string_init("session.cookie_secure", sizeof("session.cookie_secure") - 1, 0);
if (zend_alter_ini_entry_chars(ini_name, secure ? "1" : "0", 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME) == FAILURE) {
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
RETURN_FALSE;
}
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
}
if (argc > 4) {
ini_name = zend_string_init("session.cookie_httponly", sizeof("session.cookie_httponly") - 1, 0);
if (zend_alter_ini_entry_chars(ini_name, httponly ? "1" : "0", 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME) == FAILURE) {
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
RETURN_FALSE;
}
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
}
RETURN_TRUE;
if (name) {
ini_name = zend_string_init("session.name", sizeof("session.name") - 1, 0);
zend_alter_ini_entry(ini_name, name, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
}
}
/* }}} */
ini_name = zend_string_init("session.save_handler", sizeof("session.save_handler") - 1, 0);
zend_alter_ini_entry(ini_name, name, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
}
}
/* }}} */
PS(set_handler) = 1;
zend_alter_ini_entry(ini_name, ini_val, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
PS(set_handler) = 0;
- zend_string_release(ini_val);
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_val, 0);
+ zend_string_release_ex(ini_name, 0);
}
RETURN_TRUE;
if (!zend_is_callable(&args[i], 0, NULL)) {
zend_string *name = zend_get_callable_name(&args[i]);
php_error_docref(NULL, E_WARNING, "Argument %d is not a valid callback", i+1);
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
RETURN_FALSE;
}
}
PS(set_handler) = 1;
zend_alter_ini_entry(ini_name, ini_val, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
PS(set_handler) = 0;
- zend_string_release(ini_val);
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_val, 0);
+ zend_string_release_ex(ini_name, 0);
}
for (i = 0; i < argc; i++) {
}
ini_name = zend_string_init("session.save_path", sizeof("session.save_path") - 1, 0);
zend_alter_ini_entry(ini_name, name, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
}
}
/* }}} */
if (name) {
if (PS(id)) {
- zend_string_release(PS(id));
+ zend_string_release_ex(PS(id), 0);
}
PS(id) = zend_string_copy(name);
}
data = php_session_encode();
if (data) {
ret = PS(mod)->s_write(&PS(mod_data), PS(id), data, PS(gc_maxlifetime));
- zend_string_release(data);
+ zend_string_release_ex(data, 0);
} else {
ret = PS(mod)->s_write(&PS(mod_data), PS(id), ZSTR_EMPTY_ALLOC(), PS(gc_maxlifetime));
}
/* New session data */
if (PS(session_vars)) {
- zend_string_release(PS(session_vars));
+ zend_string_release_ex(PS(session_vars), 0);
PS(session_vars) = NULL;
}
- zend_string_release(PS(id));
+ zend_string_release_ex(PS(id), 0);
PS(id) = NULL;
if (PS(mod)->s_open(&PS(mod_data), PS(save_path), PS(session_name)) == FAILURE) {
}
if (PS(use_strict_mode) && PS(mod)->s_validate_sid &&
PS(mod)->s_validate_sid(&PS(mod_data), PS(id)) == FAILURE) {
- zend_string_release(PS(id));
+ zend_string_release_ex(PS(id), 0);
PS(id) = PS(mod)->s_create_sid(&PS(mod_data));
if (!PS(id)) {
PS(mod)->s_close(&PS(mod_data));
RETURN_FALSE;
}
if (data) {
- zend_string_release(data);
+ zend_string_release_ex(data, 0);
}
if (PS(use_cookies)) {
} else {
/* Detect collision and retry */
if (PS(mod)->s_validate_sid(&PS(mod_data), new_id) == FAILURE) {
- zend_string_release(new_id);
+ zend_string_release_ex(new_id, 0);
continue;
}
break;
if (new_id) {
smart_str_append(&id, new_id);
- zend_string_release(new_id);
+ zend_string_release_ex(new_id, 0);
} else {
smart_str_free(&id);
php_error_docref(NULL, E_WARNING, "Failed to create new ID");
if (limiter) {
ini_name = zend_string_init("session.cache_limiter", sizeof("session.cache_limiter") - 1, 0);
zend_alter_ini_entry(ini_name, limiter, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
}
}
/* }}} */
convert_to_string_ex(expires);
ini_name = zend_string_init("session.cache_expire", sizeof("session.cache_expire") - 1, 0);
zend_alter_ini_entry(ini_name, Z_STR_P(expires), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
- zend_string_release(ini_name);
+ zend_string_release_ex(ini_name, 0);
}
}
/* }}} */
if (Z_TYPE_P(member) != IS_STRING) {
trim_str = zval_get_string_func(member);
ZVAL_STR(&tmp_zv, php_trim(trim_str, NULL, 0, 3));
- zend_string_release(trim_str);
+ zend_string_release_ex(trim_str, 0);
member = &tmp_zv;
}
} else {
zend_hash_add_new(rv, key, value);
}
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
/* }}} */
ZVAL_STRING(&zv, (char*)ns->href);
zend_hash_add_new(Z_ARRVAL_P(return_value), key, &zv);
}
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
/* }}} */
p.write_func = (write_func) ? write_func : NULL;
str = zend_string_init_interned(name, name_length, 1);
zend_hash_add_mem(h, str, &p, sizeof(php_snmp_prop_handler));
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
}
/* }}} */
zend_string *tmp = zval_get_string_func(data);
str = estrndup(ZSTR_VAL(tmp), ZSTR_LEN(tmp));
new_len = ZSTR_LEN(tmp);
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
}
if (SOAP_GLOBAL(encoding) != NULL) {
} else {
zend_string *tmp = zval_get_string_func(data);
str = php_base64_encode((unsigned char*) ZSTR_VAL(tmp), ZSTR_LEN(tmp));
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
}
text = xmlNewTextLen(BAD_CAST(ZSTR_VAL(str)), ZSTR_LEN(str));
xmlAddChild(ret, text);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
if (style == SOAP_ENCODED) {
set_ns_and_type(ret, type);
} else {
zend_string *str = zend_long_to_str(zval_get_long(data));
xmlNodeSetContentLen(ret, BAD_CAST(ZSTR_VAL(str)), ZSTR_LEN(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
if (style == SOAP_ENCODED) {
} else {
zend_string *tmp = zval_get_string_func(data);
ret = xmlNewTextLen(BAD_CAST(ZSTR_VAL(tmp)), ZSTR_LEN(tmp));
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
}
ret->name = xmlStringTextNoenc;
smart_str_append_const(soap_headers, "Proxy-Authorization: Basic ");
smart_str_appendl(soap_headers, (char*)ZSTR_VAL(buf), ZSTR_LEN(buf));
smart_str_append_const(soap_headers, "\r\n");
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
smart_str_free(&auth);
return 1;
}
smart_str_append_const(soap_headers, "Authorization: Basic ");
smart_str_appendl(soap_headers, (char*)ZSTR_VAL(buf), ZSTR_LEN(buf));
smart_str_append_const(soap_headers, "\r\n");
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
smart_str_free(&auth);
return 1;
}
zval_ptr_dtor(¶ms[0]);
zval_ptr_dtor(&func);
if (request != buf) {
- zend_string_release(request);
+ zend_string_release_ex(request, 0);
}
smart_str_free(&soap_headers_z);
return FALSE;
if (phpurl == NULL || phpurl->host == NULL) {
if (phpurl != NULL) {php_url_free(phpurl);}
if (request != buf) {
- zend_string_release(request);
+ zend_string_release_ex(request, 0);
}
add_soap_fault(this_ptr, "HTTP", "Unable to parse URL", NULL, NULL);
smart_str_free(&soap_headers_z);
} else if (phpurl->scheme == NULL || !zend_string_equals_literal(phpurl->scheme, "http")) {
php_url_free(phpurl);
if (request != buf) {
- zend_string_release(request);
+ zend_string_release_ex(request, 0);
}
add_soap_fault(this_ptr, "HTTP", "Unknown protocol. Only http and https are allowed.", NULL, NULL);
smart_str_free(&soap_headers_z);
if (use_ssl && php_stream_locate_url_wrapper("https://", NULL, STREAM_LOCATE_WRAPPERS_ONLY) == NULL) {
php_url_free(phpurl);
if (request != buf) {
- zend_string_release(request);
+ zend_string_release_ex(request, 0);
}
add_soap_fault(this_ptr, "HTTP", "SSL support is not available in this build", NULL, NULL);
PG(allow_url_fopen) = old_allow_url_fopen;
} else {
php_url_free(phpurl);
if (request != buf) {
- zend_string_release(request);
+ zend_string_release_ex(request, 0);
}
add_soap_fault(this_ptr, "HTTP", "Could not connect to host", NULL, NULL);
PG(allow_url_fopen) = old_allow_url_fopen;
smart_str_append_const(&soap_headers, "Authorization: Basic ");
smart_str_appendl(&soap_headers, (char*)ZSTR_VAL(buf), ZSTR_LEN(buf));
smart_str_append_const(&soap_headers, "\r\n");
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
smart_str_free(&auth);
}
}
err = php_stream_write(stream, ZSTR_VAL(soap_headers.s), ZSTR_LEN(soap_headers.s));
if (err != ZSTR_LEN(soap_headers.s)) {
if (request != buf) {
- zend_string_release(request);
+ zend_string_release_ex(request, 0);
}
php_stream_close(stream);
zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpurl", sizeof("httpurl")-1);
http_headers = get_http_headers(stream);
if (!http_headers) {
if (request != buf) {
- zend_string_release(request);
+ zend_string_release_ex(request, 0);
}
php_stream_close(stream);
zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket")-1);
/* Try and get headers again */
if (http_status == 100) {
- zend_string_release(http_headers);
+ zend_string_release_ex(http_headers, 0);
}
}
} while (http_status == 100);
http_body = get_http_body(stream, http_close, ZSTR_VAL(http_headers));
if (!http_body) {
if (request != buf) {
- zend_string_release(request);
+ zend_string_release_ex(request, 0);
}
php_stream_close(stream);
- zend_string_release(http_headers);
+ zend_string_release_ex(http_headers, 0);
zend_hash_str_del(Z_OBJPROP_P(this_ptr), "httpsocket", sizeof("httpsocket")-1);
zend_hash_str_del(Z_OBJPROP_P(this_ptr), "_use_proxy", sizeof("_use_proxy")-1);
add_soap_fault(this_ptr, "HTTP", "Error Fetching http body, No Content-Length, connection closed or chunked data", NULL, NULL);
}
if (request != buf) {
- zend_string_release(request);
+ zend_string_release_ex(request, 0);
}
if (http_close) {
php_url *new_url = php_url_parse(loc);
if (new_url != NULL) {
- zend_string_release(http_headers);
- zend_string_release(http_body);
+ zend_string_release_ex(http_headers, 0);
+ zend_string_release_ex(http_body, 0);
efree(loc);
if (new_url->scheme == NULL && new_url->path != NULL) {
new_url->scheme = phpurl->scheme ? zend_string_copy(phpurl->scheme) : NULL;
strncpy(ZSTR_VAL(s), t, (p - t) + 1);
ZSTR_VAL(s)[(p - t) + 1] = 0;
strcat(ZSTR_VAL(s), ZSTR_VAL(new_url->path));
- zend_string_release(new_url->path);
+ zend_string_release_ex(new_url->path, 0);
new_url->path = s;
}
} else {
ZSTR_VAL(s)[0] = '/';
ZSTR_VAL(s)[1] = 0;
strcat(ZSTR_VAL(s), ZSTR_VAL(new_url->path));
- zend_string_release(new_url->path);
+ zend_string_release_ex(new_url->path, 0);
new_url->path = s;
}
}
phpurl = new_url;
efree(auth);
- zend_string_release(http_headers);
- zend_string_release(http_body);
+ zend_string_release_ex(http_headers, 0);
+ zend_string_release_ex(http_body, 0);
goto try_again;
}
ZVAL_STRINGL(err, http_body, http_body_size, 1);
add_soap_fault(this_ptr, "HTTP", "Didn't receive an xml document", NULL, err);
efree(content_type);
- zend_string_release(http_headers);
+ zend_string_release_ex(http_headers, 0);
efree(http_body);
return FALSE;
}
ZVAL_STR_COPY(¶ms[0], http_body);
} else {
efree(content_encoding);
- zend_string_release(http_headers);
- zend_string_release(http_body);
+ zend_string_release_ex(http_headers, 0);
+ zend_string_release_ex(http_body, 0);
if (http_msg) {
efree(http_msg);
}
Z_TYPE(retval) == IS_STRING) {
zval_ptr_dtor(¶ms[0]);
zval_ptr_dtor(&func);
- zend_string_release(http_body);
+ zend_string_release_ex(http_body, 0);
ZVAL_COPY_VALUE(return_value, &retval);
} else {
zval_ptr_dtor(¶ms[0]);
zval_ptr_dtor(&func);
efree(content_encoding);
- zend_string_release(http_headers);
- zend_string_release(http_body);
+ zend_string_release_ex(http_headers, 0);
+ zend_string_release_ex(http_body, 0);
add_soap_fault(this_ptr, "HTTP", "Can't uncompress compressed response", NULL, NULL);
if (http_msg) {
efree(http_msg);
ZVAL_STR(return_value, http_body);
}
- zend_string_release(http_headers);
+ zend_string_release_ex(http_headers, 0);
if (http_status >= 400) {
int error = 0;
if (http_buf_size + buf_size + 1 < 0) {
if (http_buf) {
- zend_string_release(http_buf);
+ zend_string_release_ex(http_buf, 0);
}
return NULL;
}
if (ch != '\n') {
/* Somthing wrong in chunked encoding */
if (http_buf) {
- zend_string_release(http_buf);
+ zend_string_release_ex(http_buf, 0);
}
return NULL;
}
} else {
/* Somthing wrong in chunked encoding */
if (http_buf) {
- zend_string_release(http_buf);
+ zend_string_release_ex(http_buf, 0);
}
return NULL;
}
}
add_soap_fault(this_ptr, faultcode, faultstring ? ZSTR_VAL(faultstring) : NULL, faultactor ? ZSTR_VAL(faultactor) : NULL, &details);
if (faultstring) {
- zend_string_release(faultstring);
+ zend_string_release_ex(faultstring, 0);
}
if (faultactor) {
- zend_string_release(faultactor);
+ zend_string_release_ex(faultactor, 0);
}
if (Z_REFCOUNTED(details)) {
Z_DELREF(details);
ZSTR_VAL(faultcode_val), ZSTR_VAL(faultstring_val), ZSTR_VAL(file_val), line_val,
Z_STRLEN(trace) ? Z_STRVAL(trace) : "#0 {main}\n");
- zend_string_release(file_val);
- zend_string_release(faultstring_val);
- zend_string_release(faultcode_val);
+ zend_string_release_ex(file_val, 0);
+ zend_string_release_ex(faultstring_val, 0);
+ zend_string_release_ex(faultcode_val, 0);
zval_ptr_dtor(&trace);
RETVAL_STR(str);
ZVAL_STR_COPY(&function_copy, f->common.function_name);
zend_hash_update(service->soap_functions.ft, key, &function_copy);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
} ZEND_HASH_FOREACH_END();
}
} else if (Z_TYPE_P(function_name) == IS_STRING) {
ZVAL_STR_COPY(&function_copy, f->common.function_name);
zend_hash_update(service->soap_functions.ft, key, &function_copy);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
} else if (Z_TYPE_P(function_name) == IS_LONG) {
if (Z_LVAL_P(function_name) == SOAP_FUNCTIONS_ALL) {
if (service->soap_functions.ft != NULL) {
zval rv;
zend_string *msg = zval_get_string(zend_read_property(zend_ce_error, &exception_object, "message", sizeof("message")-1, 0, &rv));
add_soap_fault_ex(&exception_object, this_ptr, "Server", ZSTR_VAL(msg), NULL, NULL);
- zend_string_release(msg);
+ zend_string_release_ex(msg, 0);
} else {
add_soap_fault_ex(&exception_object, this_ptr, "Server", "Internal Error", NULL, NULL);
}
php_stream_filter_append(&SG(request_info).request_body->readfilters, zf);
} else {
php_error_docref(NULL, E_WARNING,"Can't uncompress compressed request");
- zend_string_release(server);
+ zend_string_release_ex(server, 0);
return;
}
} else {
php_error_docref(NULL, E_WARNING,"Request is compressed with unknown compression '%s'",Z_STRVAL_P(encoding));
- zend_string_release(server);
+ zend_string_release_ex(server, 0);
return;
}
}
- zend_string_release(server);
+ zend_string_release_ex(server, 0);
doc_request = soap_xmlParseFile("php://input");
/* change class */
EG(exception)->ce = soap_fault_class_entry;
set_soap_fault(&exception_object, NULL, "Client", ZSTR_VAL(msg), NULL, NULL, NULL);
- zend_string_release(msg);
+ zend_string_release_ex(msg, 0);
} else if ((fault = zend_hash_str_find(Z_OBJPROP_P(this_ptr), "__soap_fault", sizeof("__soap_fault")-1)) == NULL) {
add_soap_fault(this_ptr, "Client", "SoapClient::__doRequest() returned non string value", NULL, NULL);
}
} else {
xmlNodeSetContentLen(node, BAD_CAST(ZSTR_VAL(str)), (int)ZSTR_LEN(str));
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
if ((tmp = zend_hash_str_find(prop, "faultstring", sizeof("faultstring")-1)) != NULL) {
xmlNodePtr node = master_to_xml(get_conversion(IS_STRING), tmp, SOAP_LITERAL, param);
} else {
xmlNodeSetContentLen(node, BAD_CAST(ZSTR_VAL(str)), (int)ZSTR_LEN(str));
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
if ((tmp = zend_hash_str_find(prop, "faultstring", sizeof("faultstring")-1)) != NULL) {
xmlNodePtr node = xmlNewChild(param, ns, BAD_CAST("Reason"), NULL);
DWORD err = GetLastError();
php_error_docref(NULL, E_WARNING, "Unable to create file mapping [0x%08lx]", err);
}
- zend_string_release(seg_name);
+ zend_string_release_ex(seg_name, 0);
RETURN_FALSE;
}
new_op_array = NULL;
zend_file_handle_dtor(&file_handle);
}
- zend_string_release(opened_path);
+ zend_string_release_ex(opened_path, 0);
if (new_op_array) {
ZVAL_UNDEF(&result);
zend_execute(new_op_array, &result);
}
if (file_exts) {
if (SPL_G(autoload_extensions)) {
- zend_string_release(SPL_G(autoload_extensions));
+ zend_string_release_ex(SPL_G(autoload_extensions), 0);
}
SPL_G(autoload_extensions) = zend_string_copy(file_exts);
}
}
if (alfi->func_ptr &&
UNEXPECTED(alfi->func_ptr->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
- zend_string_release(alfi->func_ptr->common.function_name);
+ zend_string_release_ex(alfi->func_ptr->common.function_name, 0);
zend_free_trampoline(alfi->func_ptr);
}
if (!Z_ISUNDEF(alfi->closure)) {
}
zend_hash_move_forward_ex(SPL_G(autoload_functions), &pos);
}
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
SPL_G(autoload_running) = l_autoload_running;
} else {
/* do not use or overwrite &EG(autoload_func) here */
if (error) {
efree(error);
}
- zend_string_release(func_name);
+ zend_string_release_ex(func_name, 0);
RETURN_FALSE;
} else if (do_throw) {
zend_throw_exception_ex(spl_ce_LogicException, 0, "Passed array does not specify %s %smethod (%s)", alfi.func_ptr ? "a callable" : "an existing", !obj_ptr ? "static " : "", error);
if (error) {
efree(error);
}
- zend_string_release(func_name);
+ zend_string_release_ex(func_name, 0);
RETURN_FALSE;
} else if (Z_TYPE_P(zcallable) == IS_STRING) {
if (do_throw) {
if (error) {
efree(error);
}
- zend_string_release(func_name);
+ zend_string_release_ex(func_name, 0);
RETURN_FALSE;
} else {
if (do_throw) {
if (error) {
efree(error);
}
- zend_string_release(func_name);
+ zend_string_release_ex(func_name, 0);
RETURN_FALSE;
}
} else if (fcc.function_handler->type == ZEND_INTERNAL_FUNCTION &&
if (error) {
efree(error);
}
- zend_string_release(func_name);
+ zend_string_release_ex(func_name, 0);
RETURN_FALSE;
}
alfi.ce = fcc.calling_scope;
lc_name = zend_string_tolower(func_name);
}
}
- zend_string_release(func_name);
+ zend_string_release_ex(func_name, 0);
if (SPL_G(autoload_functions) && zend_hash_exists(SPL_G(autoload_functions), lc_name)) {
if (!Z_ISUNDEF(alfi.closure)) {
Z_DELREF(alfi.closure);
}
if (UNEXPECTED(alfi.func_ptr->common.fn_flags & ZEND_ACC_CALL_VIA_TRAMPOLINE)) {
- zend_string_release(alfi.func_ptr->common.function_name);
+ zend_string_release_ex(alfi.func_ptr->common.function_name, 0);
zend_free_trampoline(alfi.func_ptr);
}
}
HT_MOVE_TAIL_TO_HEAD(SPL_G(autoload_functions));
}
skip:
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
}
if (SPL_G(autoload_functions)) {
efree(error);
}
if (func_name) {
- zend_string_release(func_name);
+ zend_string_release_ex(func_name, 0);
}
RETURN_FALSE;
}
lc_name = zend_string_tolower(func_name);
}
}
- zend_string_release(func_name);
+ zend_string_release_ex(func_name, 0);
if (SPL_G(autoload_functions)) {
if (ZSTR_LEN(lc_name) == sizeof("spl_autoload_call") - 1 && !strcmp(ZSTR_VAL(lc_name), "spl_autoload_call")) {
}
}
- zend_string_release(lc_name);
+ zend_string_release_ex(lc_name, 0);
RETURN_BOOL(success == SUCCESS);
} /* }}} */
PHP_RSHUTDOWN_FUNCTION(spl) /* {{{ */
{
if (SPL_G(autoload_extensions)) {
- zend_string_release(SPL_G(autoload_extensions));
+ zend_string_release_ex(SPL_G(autoload_extensions), 0);
SPL_G(autoload_extensions) = NULL;
}
if (SPL_G(autoload_functions)) {
? spl_ce_ArrayIterator : spl_ce_ArrayObject;
zname = spl_gen_private_prop_name(base, "storage", sizeof("storage")-1);
zend_symtable_update(debug_info, zname, storage);
- zend_string_release(zname);
+ zend_string_release_ex(zname, 0);
return debug_info;
}
path = spl_filesystem_object_get_pathname(intern, &path_len);
ZVAL_STRINGL(&tmp, path, path_len);
zend_symtable_update(rv, pnstr, &tmp);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
if (intern->file_name) {
pnstr = spl_gen_private_prop_name(spl_ce_SplFileInfo, "fileName", sizeof("fileName")-1);
ZVAL_STRINGL(&tmp, intern->file_name, intern->file_name_len);
}
zend_symtable_update(rv, pnstr, &tmp);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
}
if (intern->type == SPL_FS_DIR) {
#ifdef HAVE_GLOB
ZVAL_FALSE(&tmp);
}
zend_symtable_update(rv, pnstr, &tmp);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
#endif
pnstr = spl_gen_private_prop_name(spl_ce_RecursiveDirectoryIterator, "subPathName", sizeof("subPathName")-1);
if (intern->u.dir.sub_path) {
ZVAL_EMPTY_STRING(&tmp);
}
zend_symtable_update(rv, pnstr, &tmp);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
}
if (intern->type == SPL_FS_FILE) {
pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "openMode", sizeof("openMode")-1);
ZVAL_STRINGL(&tmp, intern->u.file.open_mode, intern->u.file.open_mode_len);
zend_symtable_update(rv, pnstr, &tmp);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
stmp[1] = '\0';
stmp[0] = intern->u.file.delimiter;
pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "delimiter", sizeof("delimiter")-1);
ZVAL_STRINGL(&tmp, stmp, 1);
zend_symtable_update(rv, pnstr, &tmp);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
stmp[0] = intern->u.file.enclosure;
pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "enclosure", sizeof("enclosure")-1);
ZVAL_STRINGL(&tmp, stmp, 1);
zend_symtable_update(rv, pnstr, &tmp);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
}
return rv;
zend_function *func;
zend_string *tmp = zend_string_init("_bad_state_ex", sizeof("_bad_state_ex") - 1, 0);
func = zend_get_std_object_handlers()->get_method(object, tmp, NULL);
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
return func;
}
if (p) {
idx = p - ZSTR_VAL(ret);
RETVAL_STRINGL(ZSTR_VAL(ret) + idx + 1, ZSTR_LEN(ret) - idx - 1);
- zend_string_release(ret);
+ zend_string_release_ex(ret, 0);
return;
} else {
- zend_string_release(ret);
+ zend_string_release_ex(ret, 0);
RETURN_EMPTY_STRING();
}
}
if (p) {
idx = p - ZSTR_VAL(fname);
RETVAL_STRINGL(ZSTR_VAL(fname) + idx + 1, ZSTR_LEN(fname) - idx - 1);
- zend_string_release(fname);
+ zend_string_release_ex(fname, 0);
} else {
- zend_string_release(fname);
+ zend_string_release_ex(fname, 0);
RETURN_EMPTY_STRING();
}
}
pnstr = spl_gen_private_prop_name(spl_ce_SplDoublyLinkedList, "flags", sizeof("flags")-1);
ZVAL_LONG(&tmp, intern->flags);
zend_hash_add(debug_info, pnstr, &tmp);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
array_init(&dllist_array);
pnstr = spl_gen_private_prop_name(spl_ce_SplDoublyLinkedList, "dllist", sizeof("dllist")-1);
zend_hash_add(debug_info, pnstr, &dllist_array);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
return debug_info;
}
pnstr = spl_gen_private_prop_name(ce, "flags", sizeof("flags")-1);
ZVAL_LONG(&tmp, intern->flags);
zend_hash_update(debug_info, pnstr, &tmp);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
pnstr = spl_gen_private_prop_name(ce, "isCorrupted", sizeof("isCorrupted")-1);
ZVAL_BOOL(&tmp, intern->heap->flags&SPL_HEAP_CORRUPTED);
zend_hash_update(debug_info, pnstr, &tmp);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
array_init(&heap_array);
pnstr = spl_gen_private_prop_name(ce, "heap", sizeof("heap")-1);
zend_hash_update(debug_info, pnstr, &heap_array);
- zend_string_release(pnstr);
+ zend_string_release_ex(pnstr, 0);
return debug_info;
}
if (intern->u.regex.flags & REGIT_INVERTED) {
RETVAL_BOOL(Z_TYPE_P(return_value) != IS_TRUE);
}
- zend_string_release(subject);
+ zend_string_release_ex(subject, 0);
} /* }}} */
/* {{{ proto string RegexIterator::getRegex()
php_pcre_pce_decref(object->u.regex.pce);
}
if (object->u.regex.regex) {
- zend_string_release(object->u.regex.regex);
+ zend_string_release_ex(object->u.regex.regex, 0);
}
}
#endif
static void spl_object_storage_free_hash(spl_SplObjectStorage *intern, zend_hash_key *key) {
if (key->key) {
- zend_string_release(key->key);
+ zend_string_release_ex(key->key, 0);
}
}
add_assoc_zval_ex(&tmp, "obj", sizeof("obj") - 1, &element->obj);
add_assoc_zval_ex(&tmp, "inf", sizeof("inf") - 1, &element->inf);
zend_hash_update(Z_ARRVAL(storage), md5str, &tmp);
- zend_string_release(md5str);
+ zend_string_release_ex(md5str, 0);
} ZEND_HASH_FOREACH_END();
zname = spl_gen_private_prop_name(spl_ce_SplObjectStorage, "storage", sizeof("storage")-1);
zend_symtable_update(debug_info, zname, &storage);
- zend_string_release(zname);
+ zend_string_release_ex(zname, 0);
return debug_info;
}
if (!zend_is_callable(callback_func, 0, NULL)) {
zend_string *callback_name = zend_get_callable_name(callback_func);
php_sqlite3_error(db_obj, "Not a valid callback function %s", ZSTR_VAL(callback_name));
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
RETURN_FALSE;
}
if (!zend_is_callable(step_callback, 0, NULL)) {
zend_string *callback_name = zend_get_callable_name(step_callback);
php_sqlite3_error(db_obj, "Not a valid callback function %s", ZSTR_VAL(callback_name));
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
RETURN_FALSE;
}
if (!zend_is_callable(fini_callback, 0, NULL)) {
zend_string *callback_name = zend_get_callable_name(fini_callback);
php_sqlite3_error(db_obj, "Not a valid callback function %s", ZSTR_VAL(callback_name));
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
RETURN_FALSE;
}
if (!zend_is_callable(callback_func, 0, NULL)) {
zend_string *callback_name = zend_get_callable_name(callback_func);
php_sqlite3_error(db_obj, "Not a valid callback function %s", ZSTR_VAL(callback_name));
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
RETURN_FALSE;
}
if (param->param_number < 1) {
if (param->name) {
- zend_string_release(param->name);
+ zend_string_release_ex(param->name, 0);
}
return 0;
}
if (buffer) {
sqlite3_bind_blob(stmt_obj->stmt, param->param_number, ZSTR_VAL(buffer), ZSTR_LEN(buffer), SQLITE_TRANSIENT);
- zend_string_release(buffer);
+ zend_string_release_ex(buffer, 0);
} else {
sqlite3_bind_null(stmt_obj->stmt, param->param_number);
}
struct php_sqlite3_bound_param *param = (struct php_sqlite3_bound_param*)Z_PTR_P(data);
if (param->name) {
- zend_string_release(param->name);
+ zend_string_release_ex(param->name, 0);
}
if (!Z_ISNULL(param->parameter)) {
count++;
}
}
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
}
} ZEND_HASH_FOREACH_END();
count++;
}
}
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
}
} ZEND_HASH_FOREACH_END();
count++;
}
}
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
} else {
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))) {
continue;
count++;
}
}
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
} else {
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))) {
continue;
} else {
zend_string *str = zend_long_to_str(num_key);
php_prefix_varname(&final_name, prefix, ZSTR_VAL(str), ZSTR_LEN(str), 1);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
if (php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
if (zend_string_equals_literal(Z_STR(final_name), "this")) {
count++;
}
}
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
} ZEND_HASH_FOREACH_END();
return count;
} else {
zend_string *str = zend_long_to_str(num_key);
php_prefix_varname(&final_name, prefix, ZSTR_VAL(str), ZSTR_LEN(str), 1);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
if (php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
if (zend_string_equals_literal(Z_STR(final_name), "this")) {
count++;
}
}
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
} ZEND_HASH_FOREACH_END();
return count;
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))) {
php_prefix_varname(&final_name, prefix, ZSTR_VAL(var_name), ZSTR_LEN(var_name), 1);
if (!php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
continue;
}
} else {
} else {
zend_string *str = zend_long_to_str(num_key);
php_prefix_varname(&final_name, prefix, ZSTR_VAL(str), ZSTR_LEN(str), 1);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
if (!php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
continue;
}
}
}
count++;
}
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
} ZEND_HASH_FOREACH_END();
return count;
if (!php_valid_var_name(ZSTR_VAL(var_name), ZSTR_LEN(var_name))) {
php_prefix_varname(&final_name, prefix, ZSTR_VAL(var_name), ZSTR_LEN(var_name), 1);
if (!php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
continue;
}
} else {
} else {
zend_string *str = zend_long_to_str(num_key);
php_prefix_varname(&final_name, prefix, ZSTR_VAL(str), ZSTR_LEN(str), 1);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
if (!php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
continue;
}
}
}
count++;
}
- zend_string_release(Z_STR(final_name));
+ zend_string_release_ex(Z_STR(final_name), 0);
} ZEND_HASH_FOREACH_END();
return count;
for (j = 0; j < n_elems; j++) {
p = hash->arData + j;
if (p->key) {
- zend_string_release(p->key);
+ zend_string_release_ex(p->key, 0);
}
p->h = j;
p->key = NULL;
new_key = php_string_tolower(string_key);
}
entry = zend_hash_update(Z_ARRVAL_P(return_value), new_key, entry);
- zend_string_release(new_key);
+ zend_string_release_ex(new_key, 0);
}
zval_add_ref(entry);
} else {
zend_string *str = zval_get_string(description);
zend_throw_error(NULL, "Failure evaluating code: %s%s:\"%s\"", PHP_EOL, ZSTR_VAL(str), myeval);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
if (ASSERTG(bail)) {
zend_bailout();
} else {
zend_string *str = zval_get_string(description);
zend_throw_exception(assertion_error_ce, ZSTR_VAL(str), E_ERROR);
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
} else if (ASSERTG(warning)) {
if (!description) {
} else {
php_error_docref(NULL, E_WARNING, "%s failed", ZSTR_VAL(str));
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
}
zend_string *value_str = zval_get_string(value);
key = zend_string_init("assert.active", sizeof("assert.active")-1, 0);
zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
- zend_string_release(key);
- zend_string_release(value_str);
+ zend_string_release_ex(key, 0);
+ zend_string_release_ex(value_str, 0);
}
RETURN_LONG(oldint);
break;
zend_string *value_str = zval_get_string(value);
key = zend_string_init("assert.bail", sizeof("assert.bail")-1, 0);
zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
- zend_string_release(key);
- zend_string_release(value_str);
+ zend_string_release_ex(key, 0);
+ zend_string_release_ex(value_str, 0);
}
RETURN_LONG(oldint);
break;
zend_string *value_str = zval_get_string(value);
key = zend_string_init("assert.quiet_eval", sizeof("assert.quiet_eval")-1, 0);
zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
- zend_string_release(key);
- zend_string_release(value_str);
+ zend_string_release_ex(key, 0);
+ zend_string_release_ex(value_str, 0);
}
RETURN_LONG(oldint);
break;
zend_string *value_str = zval_get_string(value);
key = zend_string_init("assert.warning", sizeof("assert.warning")-1, 0);
zend_alter_ini_entry_ex(key, value_str, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
- zend_string_release(key);
- zend_string_release(value_str);
+ zend_string_release_ex(key, 0);
+ zend_string_release_ex(value_str, 0);
}
RETURN_LONG(oldint);
break;
zend_string *key = zend_string_init("assert.exception", sizeof("assert.exception")-1, 0);
zend_string *val = zval_get_string(value);
zend_alter_ini_entry_ex(key, val, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0);
- zend_string_release(val);
- zend_string_release(key);
+ zend_string_release_ex(val, 0);
+ zend_string_release_ex(key, 0);
}
RETURN_LONG(oldint);
break;
setlocale(LC_CTYPE, "");
zend_update_current_locale();
if (BG(locale_string)) {
- zend_string_release(BG(locale_string));
+ zend_string_release_ex(BG(locale_string), 0);
BG(locale_string) = NULL;
}
}
zend_string *function_name
= zend_get_callable_name(&shutdown_function_entry->arguments[0]);
php_error(E_WARNING, "(Registered shutdown functions) Unable to call %s() - function does not exist", ZSTR_VAL(function_name));
- zend_string_release(function_name);
+ zend_string_release_ex(function_name, 0);
return 0;
}
= zend_get_callable_name(&shutdown_function_entry.arguments[0]);
php_error_docref(NULL, E_WARNING, "Invalid shutdown callback '%s' passed", ZSTR_VAL(callback_name));
efree(shutdown_function_entry.arguments);
- zend_string_release(callback_name);
+ zend_string_release_ex(callback_name, 0);
RETVAL_FALSE;
} else {
if (!BG(user_shutdown_function_names)) {
key = zend_string_init("include_path", sizeof("include_path") - 1, 0);
if (zend_alter_ini_entry_ex(key, new_value, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0) == FAILURE) {
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
zval_dtor(return_value);
RETURN_FALSE;
}
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
/* }}} */
if (ZEND_NUM_ARGS()) {
zend_string *key = zend_string_init("ignore_user_abort", sizeof("ignore_user_abort") - 1, 0);
zend_alter_ini_entry_chars(key, arg ? "1" : "0", 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
RETURN_LONG(old_setting);
if (!zend_is_callable(&tick_fe.arguments[0], 0, &function_name)) {
efree(tick_fe.arguments);
php_error_docref(NULL, E_WARNING, "Invalid tick callback '%s' passed", ZSTR_VAL(function_name));
- zend_string_release(function_name);
+ zend_string_release_ex(function_name, 0);
RETURN_FALSE;
} else if (function_name) {
- zend_string_release(function_name);
+ zend_string_release_ex(function_name, 0);
}
if (Z_TYPE(tick_fe.arguments[0]) != IS_ARRAY && Z_TYPE(tick_fe.arguments[0]) != IS_OBJECT) {
static void browscap_entry_dtor(zval *zvalue)
{
browscap_entry *entry = Z_PTR_P(zvalue);
- zend_string_release(entry->pattern);
+ zend_string_release_ex(entry->pattern, 0);
if (entry->parent) {
- zend_string_release(entry->parent);
+ zend_string_release_ex(entry->parent, 0);
}
efree(entry);
}
static void browscap_entry_dtor_persistent(zval *zvalue)
{
browscap_entry *entry = Z_PTR_P(zvalue);
- zend_string_release(entry->pattern);
+ zend_string_release_ex(entry->pattern, 1);
if (entry->parent) {
- zend_string_release(entry->parent);
+ zend_string_release_ex(entry->parent, 1);
}
pefree(entry, 1);
}
efree(agent_ht);
}
- zend_string_release(lookup_browser_name);
+ zend_string_release_ex(lookup_browser_name, 0);
}
/* }}} */
if (y > cmd_max_len + 1) {
php_error_docref(NULL, E_ERROR, "Escaped command exceeds the allowed length of %zu bytes", cmd_max_len);
- zend_string_release(cmd);
+ zend_string_release_ex(cmd, 0);
return ZSTR_EMPTY_ALLOC();
}
if (y > cmd_max_len + 1) {
php_error_docref(NULL, E_ERROR, "Escaped argument exceeds the allowed length of %zu bytes", cmd_max_len);
- zend_string_release(cmd);
+ zend_string_release_ex(cmd, 0);
return ZSTR_EMPTY_ALLOC();
}
close(fd);
RETVAL_STR(opened_path);
}
- zend_string_release(p);
+ zend_string_release_ex(p, 0);
}
/* }}} */
zval_ptr_dtor(zerrstr);
ZVAL_STR(zerrstr, errstr);
} else if (!zerrstr && errstr) {
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
RETURN_FALSE;
}
if (errstr) {
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
php_stream_to_zval(stream, return_value);
tmp_len = MIN(sizeof(ent->d_name), ZSTR_LEN(basename) - 1);
memcpy(ent->d_name, ZSTR_VAL(basename), tmp_len);
ent->d_name[tmp_len - 1] = '\0';
- zend_string_release(basename);
+ zend_string_release_ex(basename, 0);
/* Trim off trailing whitespace characters */
while (tmp_len > 0 &&
if (!p || *(p + 5) != ' ') {
zend_string_free(dt);
efree(cookie);
- zend_string_release(encoded_value);
+ zend_string_release_ex(encoded_value, 0);
zend_error(E_WARNING, "Expiry date cannot have a year greater than 9999");
return FAILURE;
}
}
if (encoded_value) {
- zend_string_release(encoded_value);
+ zend_string_release_ex(encoded_value, 0);
}
if (path && ZSTR_LEN(path)) {
if (errstr) {
php_stream_wrapper_log_error(wrapper, options, "%s", ZSTR_VAL(errstr));
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
errstr = NULL;
}
}
if (tmp) {
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
}
}
if (!s) {
s = ZSTR_VAL(resource->path);
if (!ZSTR_LEN(resource->path)) {
- zend_string_release(resource->path);
+ zend_string_release_ex(resource->path, 0);
resource->path = zend_string_init("/", 1, 0);
s = ZSTR_VAL(resource->path);
} else {
} while ((status==Z_BUF_ERROR)&&(factor<maxfactor));
if (bufz) {
- zend_string_release(bufz);
+ zend_string_release_ex(bufz, 0);
}
if (status == Z_OK) {
if (class_name) {
php_error_docref(NULL, error_type, INCOMPLETE_CLASS_MSG, ZSTR_VAL(class_name));
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
} else {
php_error_docref(NULL, error_type, INCOMPLETE_CLASS_MSG, "unknown");
}
php_info_print("<pre>");
php_info_print_html_esc(ZSTR_VAL(str), ZSTR_LEN(str));
php_info_print("</pre>");
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
} else {
zend_print_zval_r(tmp, 0);
}
tmp_headers = zend_string_init(Z_STRVAL_P(headers), Z_STRLEN_P(headers), 0);
MAIL_ASCIIZ_CHECK(ZSTR_VAL(tmp_headers), ZSTR_LEN(tmp_headers));
str_headers = php_trim(tmp_headers, NULL, 0, 2);
- zend_string_release(tmp_headers);
+ zend_string_release_ex(tmp_headers, 0);
break;
case IS_ARRAY:
str_headers = php_mail_build_headers(headers);
}
if (str_headers) {
- zend_string_release(str_headers);
+ zend_string_release_ex(str_headers, 0);
}
if (extra_cmd) {
- zend_string_release(extra_cmd);
+ zend_string_release_ex(extra_cmd, 0);
}
if (to_r != to) {
efree(to_r);
} else {
spprintf(&hdr, 0, "X-PHP-Originating-Script: " ZEND_LONG_FMT ":%s", php_getuid(), ZSTR_VAL(f));
}
- zend_string_release(f);
+ zend_string_release_ex(f, 0);
}
if (hdr && php_mail_detect_multiple_crlf(hdr)) {
}
ZSTR_LEN(res) = reslen;
- zend_string_release(tmpbuf);
+ zend_string_release_ex(tmpbuf, 0);
return res;
}
buffer = php_base64_encode((unsigned char*) str, str_len);
if (ZSTR_LEN(buffer) < out_len) {
/* Too short of an encoded string generated */
- zend_string_release(buffer);
+ zend_string_release_ex(buffer, 0);
return FAILURE;
}
for (pos = 0; pos < out_len; pos++) {
buffer = zend_string_alloc(length * 3 / 4 + 1, 0);
if (FAILURE == php_random_bytes_silent(ZSTR_VAL(buffer), ZSTR_LEN(buffer))) {
php_error_docref(NULL, E_WARNING, "Unable to generate salt");
- zend_string_release(buffer);
+ zend_string_release_ex(buffer, 0);
return NULL;
}
ret = zend_string_alloc(length, 0);
if (php_password_salt_to64(ZSTR_VAL(buffer), ZSTR_LEN(buffer), length, ZSTR_VAL(ret)) == FAILURE) {
php_error_docref(NULL, E_WARNING, "Generated salt too short");
- zend_string_release(buffer);
- zend_string_release(ret);
+ zend_string_release_ex(buffer, 0);
+ zend_string_release_ex(ret, 0);
return NULL;
}
- zend_string_release(buffer);
+ zend_string_release_ex(buffer, 0);
ZSTR_VAL(ret)[length] = 0;
return ret;
}
the > INT_MAX check. */
if (ZEND_SIZE_T_INT_OVFL(ZSTR_LEN(buffer))) {
php_error_docref(NULL, E_WARNING, "Supplied salt is too long");
- zend_string_release(buffer);
+ zend_string_release_ex(buffer, 0);
return NULL;
}
if (ZSTR_LEN(buffer) < required_salt_len) {
php_error_docref(NULL, E_WARNING, "Provided salt is too short: %zd expecting %zd", ZSTR_LEN(buffer), required_salt_len);
- zend_string_release(buffer);
+ zend_string_release_ex(buffer, 0);
return NULL;
}
zend_string *salt = zend_string_alloc(required_salt_len, 0);
if (php_password_salt_to64(ZSTR_VAL(buffer), ZSTR_LEN(buffer), required_salt_len, ZSTR_VAL(salt)) == FAILURE) {
php_error_docref(NULL, E_WARNING, "Provided salt is too short: %zd", ZSTR_LEN(buffer));
- zend_string_release(salt);
- zend_string_release(buffer);
+ zend_string_release_ex(salt, 0);
+ zend_string_release_ex(buffer, 0);
return NULL;
}
- zend_string_release(buffer);
+ zend_string_release_ex(buffer, 0);
return salt;
} else {
zend_string *salt = zend_string_alloc(required_salt_len, 0);
memcpy(ZSTR_VAL(salt), ZSTR_VAL(buffer), required_salt_len);
- zend_string_release(buffer);
+ zend_string_release_ex(buffer, 0);
return salt;
}
}
sprintf(ZSTR_VAL(hash), "%s%s", hash_format, ZSTR_VAL(salt));
ZSTR_VAL(hash)[hash_format_len + ZSTR_LEN(salt)] = 0;
- zend_string_release(salt);
+ zend_string_release_ex(salt, 0);
/* This cast is safe, since both values are defined here in code and cannot overflow */
result = php_crypt(ZSTR_VAL(password), (int)ZSTR_LEN(password), ZSTR_VAL(hash), (int)ZSTR_LEN(hash), 1);
- zend_string_release(hash);
+ zend_string_release_ex(hash, 0);
if (!result) {
RETURN_FALSE;
ARGON2_VERSION_NUMBER
);
- zend_string_release(out);
- zend_string_release(salt);
+ zend_string_release_ex(out, 0);
+ zend_string_release_ex(salt, 0);
if (status != ARGON2_OK) {
zend_string_efree(encoded);
}
#define PHP_CLEANUP_CLASS_ATTRIBUTES() \
- zend_string_release(class_name)
+ zend_string_release_ex(class_name, 0)
#define PHP_CLASS_ATTRIBUTES \
zend_string *class_name; \
str = zval_get_string(element);
if (ZSTR_LEN(str) == 0) {
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
continue;
}
#endif
p += ZSTR_LEN(str) + 1;
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
} ZEND_HASH_FOREACH_END();
assert((uint32_t)(p - env.envp) <= sizeenv);
bytes = zend_string_alloc(size, 0);
if (php_random_bytes_throw(ZSTR_VAL(bytes), size) == FAILURE) {
- zend_string_release(bytes);
+ zend_string_release_ex(bytes, 0);
return;
}
zend_string *quoted_host = php_addslashes(host, 0);
php_error_docref(NULL, E_WARNING, "unable to connect to %s (%s)", ZSTR_VAL(quoted_host), errstr == NULL ? "Unknown error" : ZSTR_VAL(errstr));
- zend_string_release(quoted_host);
+ zend_string_release_ex(quoted_host, 0);
}
if (hashkey) {
zval_ptr_dtor(zerrstr);
ZVAL_STR(zerrstr, errstr);
} else if (errstr) {
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
RETURN_FALSE;
}
if (errstr) {
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
php_stream_to_zval(stream, return_value);
zval_ptr_dtor(zerrstr);
ZVAL_STR(zerrstr, errstr);
} else if (errstr) {
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
RETURN_FALSE;
}
if (errstr) {
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
php_stream_to_zval(stream, return_value);
}
if (errstr) {
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
}
/* }}} */
}
if ((ZSTR_LEN(name) == 0) || (ZSTR_VAL(name)[0] == 0)) {
- zend_string_release(name);
+ zend_string_release_ex(name, 0);
RETURN_FALSE;
}
cptr -= ZSTR_LEN(ptr->str);
memcpy(cptr, ZSTR_VAL(ptr->str), ZSTR_LEN(ptr->str));
if (ptr->lval) {
- zend_string_release(ptr->str);
+ zend_string_release_ex(ptr->str, 0);
}
} else {
char *oldPtr = cptr;
}
if (ret) {
- zend_string_release(ret);
+ zend_string_release_ex(ret, 0);
}
if (opt == PHP_PATHINFO_ALL) {
RETVAL_FALSE;
}
- zend_string_release(haystack_dup);
+ zend_string_release_ex(haystack_dup, 0);
if (needle_dup) {
- zend_string_release(needle_dup);
+ zend_string_release_ex(needle_dup, 0);
}
}
/* }}} */
haystack_dup = php_string_tolower(haystack);
if (offset >= 0) {
if ((size_t)offset > ZSTR_LEN(haystack)) {
- zend_string_release(haystack_dup);
+ zend_string_release_ex(haystack_dup, 0);
ZSTR_ALLOCA_FREE(ord_needle, use_heap);
php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string");
RETURN_FALSE;
e = ZSTR_VAL(haystack_dup) + ZSTR_LEN(haystack);
} else {
if (offset < -INT_MAX || (size_t)(-offset) > ZSTR_LEN(haystack)) {
- zend_string_release(haystack_dup);
+ zend_string_release_ex(haystack_dup, 0);
ZSTR_ALLOCA_FREE(ord_needle, use_heap);
php_error_docref(NULL, E_WARNING, "Offset is greater than the length of haystack string");
RETURN_FALSE;
needle_dup = php_string_tolower(needle);
if ((found = (char *)zend_memnrstr(p, ZSTR_VAL(needle_dup), ZSTR_LEN(needle_dup), e))) {
RETVAL_LONG(found - ZSTR_VAL(haystack_dup));
- zend_string_release(needle_dup);
- zend_string_release(haystack_dup);
+ zend_string_release_ex(needle_dup, 0);
+ zend_string_release_ex(haystack_dup, 0);
ZSTR_ALLOCA_FREE(ord_needle, use_heap);
} else {
- zend_string_release(needle_dup);
- zend_string_release(haystack_dup);
+ zend_string_release_ex(needle_dup, 0);
+ zend_string_release_ex(haystack_dup, 0);
ZSTR_ALLOCA_FREE(ord_needle, use_heap);
RETURN_FALSE;
}
}
zend_hash_add(&str_hash, key_used, entry);
if (UNEXPECTED(!str_key)) {
- zend_string_release(key_used);
+ zend_string_release_ex(key_used, 0);
}
} ZEND_HASH_FOREACH_END();
pats = &str_hash;
memcpy(ZSTR_VAL(new_str) + (r - lc_haystack), str, str_len);
(*replace_count)++;
}
- zend_string_release(lc_needle);
+ zend_string_release_ex(lc_needle, 0);
if (!new_str) {
goto nothing_todo;
}
if (count == 0) {
/* Needle doesn't occur, shortcircuit the actual replacement. */
- zend_string_release(lc_needle);
+ zend_string_release_ex(lc_needle, 0);
goto nothing_todo;
}
}
*e = '\0';
- zend_string_release(lc_needle);
+ zend_string_release_ex(lc_needle, 0);
return new_str;
}
lc_needle = php_string_tolower(needle);
if (memcmp(lc_haystack, ZSTR_VAL(lc_needle), ZSTR_LEN(lc_needle))) {
- zend_string_release(lc_needle);
+ zend_string_release_ex(lc_needle, 0);
goto nothing_todo;
}
- zend_string_release(lc_needle);
+ zend_string_release_ex(lc_needle, 0);
new_str = zend_string_init(str, str_len, 0);
new_str = zend_string_truncate(new_str, newlen, 0);
}
if (should_free) {
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
return new_str;
}
*target = '\0';
if (should_free) {
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
if (ZSTR_LEN(new_str) - (target - ZSTR_VAL(new_str)) > 16) {
*target = '\0';
if (should_free) {
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
if (ZSTR_LEN(new_str) - (target - ZSTR_VAL(new_str)) > 16) {
case_sensitivity,
&replace_count);
if (lc_subject_str && replace_count != old_replace_count) {
- zend_string_release(lc_subject_str);
+ zend_string_release_ex(lc_subject_str, 0);
lc_subject_str = NULL;
}
} else if (ZSTR_LEN(search_str) > 1) {
tmp_result = php_str_to_str_i_ex(Z_STR_P(result), ZSTR_VAL(lc_subject_str),
search_str, replace_value, replace_len, &replace_count);
if (replace_count != old_replace_count) {
- zend_string_release(lc_subject_str);
+ zend_string_release_ex(lc_subject_str, 0);
lc_subject_str = NULL;
}
}
zend_tmp_string_release(tmp_search_str);
if (tmp_replace_entry_str) {
- zend_string_release(tmp_replace_entry_str);
+ zend_string_release_ex(tmp_replace_entry_str, 0);
tmp_replace_entry_str = NULL;
}
- zend_string_release(Z_STR_P(result));
+ zend_string_release_ex(Z_STR_P(result), 0);
ZVAL_STR(result, tmp_result);
if (Z_STRLEN_P(result) == 0) {
if (lc_subject_str) {
- zend_string_release(lc_subject_str);
+ zend_string_release_ex(lc_subject_str, 0);
}
zend_tmp_string_release(tmp_subject_str);
return replace_count;
}
} ZEND_HASH_FOREACH_END();
if (lc_subject_str) {
- zend_string_release(lc_subject_str);
+ zend_string_release_ex(lc_subject_str, 0);
}
} else {
ZEND_ASSERT(Z_TYPE_P(search) == IS_STRING);
ZVAL_STR(result, php_str_to_str_i_ex(subject_str, ZSTR_VAL(lc_subject_str),
Z_STR_P(search),
Z_STRVAL_P(replace), Z_STRLEN_P(replace), &replace_count));
- zend_string_release(lc_subject_str);
+ zend_string_release_ex(lc_subject_str, 0);
}
} else {
ZVAL_STR_COPY(result, subject_str);
if (convert_newlines) {
RETVAL_STR(php_char_to_str_ex(broken_str, '\n', "<br />\n", 7, 1, NULL));
- zend_string_release(broken_str);
+ zend_string_release_ex(broken_str, 0);
} else {
RETURN_NEW_STR(broken_str);
}
loc = zval_get_string(plocale);
if (!strcmp("0", ZSTR_VAL(loc))) {
- zend_string_release(loc);
+ zend_string_release_ex(loc, 0);
loc = NULL;
} else {
if (ZSTR_LEN(loc) >= 255) {
php_error_docref(NULL, E_WARNING, "Specified locale name is too long");
- zend_string_release(loc);
+ zend_string_release_ex(loc, 0);
break;
}
}
BG(locale_changed) = 1;
if (cat == LC_CTYPE || cat == LC_ALL) {
if (BG(locale_string)) {
- zend_string_release(BG(locale_string));
+ zend_string_release_ex(BG(locale_string), 0);
}
if (len == ZSTR_LEN(loc) && !memcmp(ZSTR_VAL(loc), retval, len)) {
BG(locale_string) = zend_string_copy(loc);
RETURN_STR(BG(locale_string));
} else {
BG(locale_string) = zend_string_init(retval, len, 0);
- zend_string_release(loc);
+ zend_string_release_ex(loc, 0);
RETURN_STR_COPY(BG(locale_string));
}
} else if (len == ZSTR_LEN(loc) && !memcmp(ZSTR_VAL(loc), retval, len)) {
RETURN_STR(loc);
}
- zend_string_release(loc);
+ zend_string_release_ex(loc, 0);
}
RETURN_STRING(retval);
}
if (loc) {
- zend_string_release(loc);
+ zend_string_release_ex(loc, 0);
}
if (Z_TYPE(args[0]) == IS_ARRAY) {
PHPAPI void php_url_free(php_url *theurl)
{
if (theurl->scheme)
- zend_string_release(theurl->scheme);
+ zend_string_release_ex(theurl->scheme, 0);
if (theurl->user)
- zend_string_release(theurl->user);
+ zend_string_release_ex(theurl->user, 0);
if (theurl->pass)
- zend_string_release(theurl->pass);
+ zend_string_release_ex(theurl->pass, 0);
if (theurl->host)
- zend_string_release(theurl->host);
+ zend_string_release_ex(theurl->host, 0);
if (theurl->path)
- zend_string_release(theurl->path);
+ zend_string_release_ex(theurl->path, 0);
if (theurl->query)
- zend_string_release(theurl->query);
+ zend_string_release_ex(theurl->query, 0);
if (theurl->fragment)
- zend_string_release(theurl->fragment);
+ zend_string_release_ex(theurl->fragment, 0);
efree(theurl);
}
/* }}} */
str = zend_string_init(key, keylen, 1);
GC_MAKE_PERSISTENT_LOCAL(str);
zend_hash_add_mem(ctx->tags, str, val, strlen(val)+1);
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
}
}
if (keylen > 0) {
tmp_key = zend_string_init(key, keylen, 0);
zend_hash_add_empty_element(hosts, tmp_key);
- zend_string_release(tmp_key);
+ zend_string_release_ex(tmp_key, 0);
}
}
efree(tmp);
if (url_parts->host) {
zend_string *tmp = zend_string_tolower(url_parts->host);
if (!zend_hash_exists(&BG(url_adapt_session_hosts_ht), tmp)) {
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
smart_str_append_smart_str(dest, url);
php_url_free(url_parts);
return;
}
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
}
/*
ZSTR_VAL(host_tmp)[ZSTR_LEN(host_tmp)] = '\0';
}
if (!strcasecmp(ZSTR_VAL(host_tmp), target)) {
- zend_string_release(host_tmp);
+ zend_string_release_ex(host_tmp, 0);
return SUCCESS;
}
- zend_string_release(host_tmp);
+ zend_string_release_ex(host_tmp, 0);
}
return FAILURE;
}
str = zend_string_init(key, keylen, 1);
GC_MAKE_PERSISTENT_LOCAL(str);
zend_hash_add_mem(ctx->tags, str, val, strlen(val)+1);
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
}
}
if (keylen > 0) {
tmp_key = zend_string_init(key, keylen, 0);
zend_hash_add_empty_element(hosts, tmp_key);
- zend_string_release(tmp_key);
+ zend_string_release_ex(tmp_key, 0);
}
}
efree(tmp);
if (url_parts->host) {
zend_string *tmp = zend_string_tolower(url_parts->host);
if (!zend_hash_exists(&BG(url_adapt_session_hosts_ht), tmp)) {
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
smart_str_append_smart_str(dest, url);
php_url_free(url_parts);
return;
}
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
}
/*
ZSTR_VAL(host_tmp)[ZSTR_LEN(host_tmp)] = '\0';
}
if (!strcasecmp(ZSTR_VAL(host_tmp), target)) {
- zend_string_release(host_tmp);
+ zend_string_release_ex(host_tmp, 0);
return SUCCESS;
}
- zend_string_release(host_tmp);
+ zend_string_release_ex(host_tmp, 0);
}
return FAILURE;
}
static void filter_item_dtor(zval *zv)
{
struct php_user_filter_data *fdat = Z_PTR_P(zv);
- zend_string_release(fdat->classname);
+ zend_string_release_ex(fdat->classname, 0);
efree(fdat);
}
php_stream_filter_register_factory_volatile(filtername, &user_filter_factory) == SUCCESS) {
RETVAL_TRUE;
} else {
- zend_string_release(classname);
+ zend_string_release_ex(classname, 0);
efree(fdat);
}
}
myht = Z_OBJDEBUG_P(struc, is_temp);
class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc));
php_printf("%sobject(%s)#%d (%d) {\n", COMMON, ZSTR_VAL(class_name), Z_OBJ_HANDLE_P(struc), myht ? zend_array_count(myht) : 0);
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
if (myht) {
zend_ulong num;
}
class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc));
php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, ZSTR_VAL(class_name), Z_OBJ_HANDLE_P(struc), myht ? zend_array_count(myht) : 0, Z_REFCOUNT_P(struc));
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
if (myht) {
ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, val) {
zval_object_property_dump(val, index, key, level);
smart_str_appendc(buf, '\'');
smart_str_append(buf, pname_esc);
smart_str_appendc(buf, '\'');
- zend_string_release(pname_esc);
+ zend_string_release_ex(pname_esc, 0);
} else {
smart_str_append_long(buf, (zend_long) index);
}
convert_to_string_ex(entry);
lcname = zend_string_tolower(Z_STR_P(entry));
zend_hash_add_empty_element(class_hash, lcname);
- zend_string_release(lcname);
+ zend_string_release_ex(lcname, 0);
} ZEND_HASH_FOREACH_END();
}
php_var_unserialize_set_allowed_classes(var_hash, class_hash);
if (existing_propinfo->flags & ZEND_ACC_PROTECTED) {
new_key = zend_mangle_property_name(
"*", 1, ZSTR_VAL(unmangled), ZSTR_LEN(unmangled), 0);
- zend_string_release(unmangled);
+ zend_string_release_ex(unmangled, 0);
} else if (existing_propinfo->flags & ZEND_ACC_PRIVATE) {
if (unmangled_class != NULL && strcmp(unmangled_class, "*") != 0) {
new_key = zend_mangle_property_name(
ZSTR_VAL(unmangled), ZSTR_LEN(unmangled),
0);
}
- zend_string_release(unmangled);
+ zend_string_release_ex(unmangled, 0);
} else {
ZEND_ASSERT(existing_propinfo->flags & ZEND_ACC_PUBLIC);
new_key = unmangled;
}
- zend_string_release(Z_STR(key));
+ zend_string_release_ex(Z_STR(key), 0);
ZVAL_STR(&key, new_key);
} else {
- zend_string_release(unmangled);
+ zend_string_release_ex(unmangled, 0);
}
}
if (ce) {
BG(serialize_lock)--;
if (EG(exception)) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return 0;
}
break;
BG(serialize_lock)--;
if (EG(exception)) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return 0;
}
if (call_user_function_ex(CG(function_table), NULL, &user_func, &retval, 1, args, 0, NULL) != SUCCESS) {
BG(serialize_lock)--;
if (EG(exception)) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
zval_ptr_dtor(&user_func);
zval_ptr_dtor(&args[0]);
return 0;
BG(serialize_lock)--;
zval_ptr_dtor(&retval);
if (EG(exception)) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
zval_ptr_dtor(&user_func);
zval_ptr_dtor(&args[0]);
return 0;
if (ret && incomplete_class) {
php_store_class_name(rval, ZSTR_VAL(class_name), len2);
}
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return ret;
}
elements = object_common1(UNSERIALIZE_PASSTHRU, ce);
if (elements < 0) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return 0;
}
if (incomplete_class) {
php_store_class_name(rval, ZSTR_VAL(class_name), len2);
}
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return object_common2(UNSERIALIZE_PASSTHRU, elements);
}
if (existing_propinfo->flags & ZEND_ACC_PROTECTED) {
new_key = zend_mangle_property_name(
"*", 1, ZSTR_VAL(unmangled), ZSTR_LEN(unmangled), 0);
- zend_string_release(unmangled);
+ zend_string_release_ex(unmangled, 0);
} else if (existing_propinfo->flags & ZEND_ACC_PRIVATE) {
if (unmangled_class != NULL && strcmp(unmangled_class, "*") != 0) {
new_key = zend_mangle_property_name(
ZSTR_VAL(unmangled), ZSTR_LEN(unmangled),
0);
}
- zend_string_release(unmangled);
+ zend_string_release_ex(unmangled, 0);
} else {
ZEND_ASSERT(existing_propinfo->flags & ZEND_ACC_PUBLIC);
new_key = unmangled;
}
- zend_string_release(Z_STR(key));
+ zend_string_release_ex(Z_STR(key), 0);
ZVAL_STR(&key, new_key);
} else {
- zend_string_release(unmangled);
+ zend_string_release_ex(unmangled, 0);
}
}
if (ce) {
BG(serialize_lock)--;
if (EG(exception)) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return 0;
}
break;
BG(serialize_lock)--;
if (EG(exception)) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return 0;
}
if (call_user_function_ex(CG(function_table), NULL, &user_func, &retval, 1, args, 0, NULL) != SUCCESS) {
BG(serialize_lock)--;
if (EG(exception)) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
zval_ptr_dtor(&user_func);
zval_ptr_dtor(&args[0]);
return 0;
BG(serialize_lock)--;
zval_ptr_dtor(&retval);
if (EG(exception)) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
zval_ptr_dtor(&user_func);
zval_ptr_dtor(&args[0]);
return 0;
if (ret && incomplete_class) {
php_store_class_name(rval, ZSTR_VAL(class_name), len2);
}
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return ret;
}
elements = object_common1(UNSERIALIZE_PASSTHRU, ce);
if (elements < 0) {
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return 0;
}
if (incomplete_class) {
php_store_class_name(rval, ZSTR_VAL(class_name), len2);
}
- zend_string_release(class_name);
+ zend_string_release_ex(class_name, 0);
return object_common2(UNSERIALIZE_PASSTHRU, elements);
}
}
if (is_file) {
- zend_string_release(data);
+ zend_string_release_ex(data, 0);
}
tidyBufFree(errbuf);
RETVAL_FALSE;
}
- zend_string_release(contents);
+ zend_string_release_ex(contents, 0);
}
/* }}} */
php_tidy_parse_string(obj, ZSTR_VAL(contents), (uint32_t)ZSTR_LEN(contents), enc);
- zend_string_release(contents);
+ zend_string_release_ex(contents, 0);
}
}
RETVAL_TRUE;
}
- zend_string_release(contents);
+ zend_string_release_ex(contents, 0);
}
static TIDY_DOC_METHOD(parseString)
Z_TRY_ADDREF_P(ent);
}
PS_ADD_VAR(key);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
} ZEND_HASH_FOREACH_END();
}
php_wddx_add_chunk_static(packet, WDDX_COMMENT_E);
php_wddx_add_chunk_static(packet, WDDX_HEADER_E);
- zend_string_release(escaped);
+ zend_string_release_ex(escaped, 0);
} else {
php_wddx_add_chunk_static(packet, WDDX_HEADER);
}
php_wddx_add_chunk_ex(packet, ZSTR_VAL(buf), ZSTR_LEN(buf));
- zend_string_release(buf);
+ zend_string_release_ex(buf, 0);
}
php_wddx_add_chunk_static(packet, WDDX_STRING_E);
}
char tmp_buf[WDDX_BUF_LEN], *dec_point;
zend_string *str = zval_get_string_func(var);
snprintf(tmp_buf, sizeof(tmp_buf), WDDX_NUMBER, ZSTR_VAL(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
dec_point = strchr(tmp_buf, ',');
if (dec_point) {
zend_unmangle_property_name_ex(key, &class_name, &prop_name, &prop_name_len);
tmp = zend_string_init(prop_name, prop_name_len, 0);
php_wddx_serialize_var(packet, ent, tmp);
- zend_string_release(tmp);
+ zend_string_release_ex(tmp, 0);
} else {
key = zend_long_to_str(idx);
php_wddx_serialize_var(packet, ent, key);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
} ZEND_HASH_FOREACH_END();
php_wddx_add_chunk_static(packet, WDDX_STRUCT_E);
} else {
key = zend_long_to_str(idx);
php_wddx_serialize_var(packet, ent, key);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
} else {
php_wddx_serialize_var(packet, ent, NULL);
snprintf(tmp_buf, ZSTR_LEN(name_esc) + sizeof(WDDX_VAR_S), WDDX_VAR_S, ZSTR_VAL(name_esc));
php_wddx_add_chunk(packet, tmp_buf);
efree(tmp_buf);
- zend_string_release(name_esc);
+ zend_string_release_ex(name_esc, 0);
}
if (Z_TYPE_P(var) == IS_INDIRECT) {
ZVAL_STR_COPY(&ent->data, str);
}
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
}
break;
attributes += 2;
- zend_string_release(att);
+ zend_string_release_ex(att, 0);
}
xml_call_handler(parser, &parser->startElementHandler, parser->startElementPtr, 3, args, &retval);
atcnt++;
attributes += 2;
- zend_string_release(att);
+ zend_string_release_ex(att, 0);
}
if (atcnt) {
}
}
- zend_string_release(tag_name);
+ zend_string_release_ex(tag_name, 0);
}
}
/* }}} */
parser->lastwasopen = 0;
}
- zend_string_release(tag_name);
+ zend_string_release_ex(tag_name, 0);
if ((parser->ltags) && (parser->level <= XML_MAXLEVEL)) {
efree(parser->ltags[parser->level-1]);
Z_STR_P(myval) = zend_string_extend(Z_STR_P(myval), newlen, 0);
strncpy(Z_STRVAL_P(myval) + Z_STRLEN_P(myval) - ZSTR_LEN(decoded_value),
ZSTR_VAL(decoded_value), ZSTR_LEN(decoded_value) + 1);
- zend_string_release(decoded_value);
+ zend_string_release_ex(decoded_value, 0);
} else {
add_assoc_str(parser->ctag, "value", decoded_value);
}
Z_STR_P(myval) = zend_string_extend(Z_STR_P(myval), newlen, 0);
strncpy(Z_STRVAL_P(myval) + Z_STRLEN_P(myval) - ZSTR_LEN(decoded_value),
ZSTR_VAL(decoded_value), ZSTR_LEN(decoded_value) + 1);
- zend_string_release(decoded_value);
+ zend_string_release_ex(decoded_value, 0);
return;
}
}
}
}
} else {
- zend_string_release(decoded_value);
+ zend_string_release_ex(decoded_value, 0);
}
}
}
hnd.type = rettype;
str = zend_string_init_interned(name, strlen(name), 1);
zend_hash_add_mem(prop_handler, str, &hnd, sizeof(xmlreader_prop_handler));
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
}
/* }}} */
if (Z_TYPE(val) != IS_STRING) {
zend_string *str = zval_get_string_func(&val);
xReturn = XMLRPC_CreateValueBase64(key, ZSTR_VAL(str), ZSTR_LEN(str));
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
} else {
xReturn = XMLRPC_CreateValueBase64(key, Z_STRVAL(val), Z_STRLEN(val));
}
} else {
php_error_docref(NULL, E_WARNING, "Invalid callback '%s' passed", ZSTR_VAL(php_function_name));
}
- zend_string_release(php_function_name);
+ zend_string_release_ex(php_function_name, 0);
} ZEND_HASH_FOREACH_END();
/* so we don't call the same callbacks ever again */
zval_ptr_dtor(&retval);
}
}
- zend_string_release(callable);
+ zend_string_release_ex(callable, 0);
zval_ptr_dtor(&handler);
if (fci.param_count > 0) {
for (i = 0; i < nargs - 1; i++) {
if (ZIP_OPENBASEDIR_CHECKPATH(file_dirname_fullpath)) {
efree(file_dirname_fullpath);
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
CWD_STATE_FREE(new_state.cwd);
return 0;
}
if (!ret) {
efree(file_dirname_fullpath);
if (!is_dir_only) {
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
CWD_STATE_FREE(new_state.cwd);
}
return 0;
len = spprintf(&fullpath, 0, "%s/%s", file_dirname_fullpath, ZSTR_VAL(file_basename));
if (!len) {
efree(file_dirname_fullpath);
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
CWD_STATE_FREE(new_state.cwd);
return 0;
} else if (len > MAXPATHLEN) {
php_error_docref(NULL, E_WARNING, "Full extraction path exceed MAXPATHLEN (%i)", MAXPATHLEN);
efree(file_dirname_fullpath);
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
CWD_STATE_FREE(new_state.cwd);
return 0;
}
if (ZIP_OPENBASEDIR_CHECKPATH(fullpath)) {
efree(fullpath);
efree(file_dirname_fullpath);
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
CWD_STATE_FREE(new_state.cwd);
return 0;
}
done:
efree(fullpath);
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
efree(file_dirname_fullpath);
CWD_STATE_FREE(new_state.cwd);
if ((namelist_len == 1 && ZSTR_VAL(namelist[i])[0] == '.') ||
(namelist_len == 2 && ZSTR_VAL(namelist[i])[0] == '.' && ZSTR_VAL(namelist[i])[1] == '.')) {
- zend_string_release(namelist[i]);
+ zend_string_release_ex(namelist[i], 0);
continue;
}
if ((path_len + namelist_len + 1) >= MAXPATHLEN) {
php_error_docref(NULL, E_WARNING, "add_path string too long (max: %u, %zu given)",
MAXPATHLEN - 1, (path_len + namelist_len + 1));
- zend_string_release(namelist[i]);
+ zend_string_release_ex(namelist[i], 0);
break;
}
if (0 != VCWD_STAT(fullpath, &s)) {
php_error_docref(NULL, E_WARNING, "Cannot read <%s>", fullpath);
- zend_string_release(namelist[i]);
+ zend_string_release_ex(namelist[i], 0);
continue;
}
if (S_IFDIR == (s.st_mode & S_IFMT)) {
- zend_string_release(namelist[i]);
+ zend_string_release_ex(namelist[i], 0);
continue;
}
match_data = php_pcre_create_match_data(capture_count, re);
if (!match_data) {
/* Allocation failed, but can proceed to the next pattern. */
- zend_string_release(namelist[i]);
+ zend_string_release_ex(namelist[i], 0);
continue;
}
rc = pcre2_match(re, (PCRE2_SPTR)ZSTR_VAL(namelist[i]), ZSTR_LEN(namelist[i]), 0, preg_options, match_data, mctx);
php_pcre_free_match_data(match_data);
/* 0 means that the vector is too small to hold all the captured substring offsets */
if (rc < 0) {
- zend_string_release(namelist[i]);
+ zend_string_release_ex(namelist[i], 0);
continue;
}
add_next_index_string(return_value, fullpath);
- zend_string_release(namelist[i]);
+ zend_string_release_ex(namelist[i], 0);
}
efree(namelist);
}
/* Register for reflection */
ZVAL_NULL(&tmp);
zend_declare_property_ex(zip_class_entry, str, &tmp, ZEND_ACC_PUBLIC, NULL);
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
}
/* }}} */
entry_name = entry_name_buf;
entry_name_len = strlen(entry_name);
if (basename) {
- zend_string_release(basename);
+ zend_string_release_ex(basename, 0);
basename = NULL;
}
fragment++;
if (ZIP_OPENBASEDIR_CHECKPATH(file_dirname)) {
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
return -1;
}
memset(ssb, 0, sizeof(php_stream_statbuf));
if (zip_stat(za, fragment, ZIP_FL_NOCASE, &sb) != 0) {
zip_close(za);
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
return -1;
}
zip_close(za);
#endif
ssb->sb.st_ino = -1;
}
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
return 0;
}
/* }}} */
fragment++;
if (ZIP_OPENBASEDIR_CHECKPATH(file_dirname)) {
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
return NULL;
}
}
}
- zend_string_release(file_basename);
+ zend_string_release_ex(file_basename, 0);
if (!stream) {
return NULL;
memcpy(dictptr, ZSTR_VAL(*ptr), ZSTR_LEN(*ptr));
dictptr += ZSTR_LEN(*ptr);
*dictptr++ = 0;
- zend_string_release(*ptr);
+ zend_string_release_ex(*ptr, 0);
} while (++ptr != end);
efree(strings);
}
case Z_DATA_ERROR:
php_error_docref(NULL, E_WARNING, "dictionary does not match expected dictionary (incorrect adler32 hash)");
efree(php_ctx->inflateDict);
- zend_string_release(out);
+ zend_string_release_ex(out, 0);
php_ctx->inflateDict = NULL;
RETURN_FALSE;
EMPTY_SWITCH_DEFAULT_CASE()
RETURN_FALSE;
}
default:
- zend_string_release(out);
+ zend_string_release_ex(out, 0);
php_error_docref(NULL, E_WARNING, "%s", zError(status));
RETURN_FALSE;
}
RETURN_STR(out);
break;
default:
- zend_string_release(out);
+ zend_string_release_ex(out, 0);
php_error_docref(NULL, E_WARNING, "zlib error (%s)", zError(status));
RETURN_FALSE;
}
if (!strncmp(ptr, "image/", sizeof("image/")-1)) {
zend_string *key = zend_string_init("zlib.output_compression", sizeof("zlib.output_compression")-1, 0);
zend_alter_ini_entry_chars(key, "0", sizeof("0") - 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
mimetype = estrdup(ptr);
zend_string *key = zend_string_init("zlib.output_compression", sizeof("zlib.output_compression")-1, 0);
zend_alter_ini_entry_chars(key,
"0", sizeof("0") - 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
} else if (!strcasecmp(header_line, "Location")) {
if ((SG(sapi_headers).http_response_code < 300 ||
SG(sapi_headers).http_response_code > 399) &&
GC_MAKE_PERSISTENT_LOCAL(key);
ret = zend_hash_add_mem(&SG(known_post_content_types), key,
(void *) post_entry, sizeof(sapi_post_entry)) ? SUCCESS : FAILURE;
- zend_string_release(key);
+ zend_string_release_ex(key, 1);
return ret;
}
GC_MAKE_PERSISTENT_LOCAL(key);
GC_MAKE_PERSISTENT_LOCAL(Z_STR(zvalue));
zend_hash_add(&fcgi_mgmt_vars, key, &zvalue);
- zend_string_release(key);
+ zend_string_release_ex(key, 1);
}
void fcgi_free_mgmt_var_cb(zval *zv)
}
return FAILURE;
}
- zend_string_release(resolved_path);
+ zend_string_release_ex(resolved_path, 0);
orig_display_errors = PG(display_errors);
PG(display_errors) = 0;
} else {
RETVAL_FALSE;
}
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
efree(new_timeout_str);
}
/* }}} */
if (n == 0) {
if (errstr) {
php_error_docref(NULL, E_WARNING, "Failed to resolve `%s': %s", tmp, ZSTR_VAL(errstr));
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
goto out;
}
}
/* free error string received during previous iteration (if any) */
if (error_string && *error_string) {
- zend_string_release(*error_string);
+ zend_string_release_ex(*error_string, 0);
*error_string = NULL;
}
efree(error);
}
if (handler_name) {
- zend_string_release(handler_name);
+ zend_string_release_ex(handler_name, 0);
}
}
handler = php_output_handler_init(str, chunk_size, (flags & ~0xf) | PHP_OUTPUT_HANDLER_INTERNAL);
handler->func.internal = output_handler;
- zend_string_release(str);
+ zend_string_release_ex(str, 0);
return handler;
}
}
str = zend_string_init_interned(name, name_len, 1);
ret = zend_hash_update_ptr(&php_output_handler_conflicts, str, check_func) ? SUCCESS : FAILURE;
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
return ret;
}
/* }}} */
}
str = zend_string_init_interned(name, name_len, 1);
ret = zend_hash_update_mem(&php_output_handler_reverse_conflicts, str, &rev, sizeof(HashTable)) ? SUCCESS : FAILURE;
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
if (ret != SUCCESS) {
zend_hash_destroy(&rev);
}
}
str = zend_string_init_interned(name, name_len, 1);
ret = zend_hash_update_ptr(&php_output_handler_aliases, str, func) ? SUCCESS : FAILURE;
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
return ret;
}
/* }}} */
PHPAPI void php_output_handler_dtor(php_output_handler *handler)
{
if (handler->name) {
- zend_string_release(handler->name);
+ zend_string_release_ex(handler->name, 0);
}
if (handler->buffer.data) {
efree(handler->buffer.data);
zend_hash_destroy(Z_ARRVAL_P(zvalue));
free(Z_ARR_P(zvalue));
} else if (Z_TYPE_P(zvalue) == IS_STRING) {
- zend_string_release(Z_STR_P(zvalue));
+ zend_string_release_ex(Z_STR_P(zvalue), 1);
}
}
/* Reset / free active_ini_sectin global */
ZVAL_NEW_STR(&tmp, zend_string_init(fh.filename, strlen(fh.filename), 1));
zend_hash_str_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path")-1, &tmp);
if (opened_path) {
- zend_string_release(opened_path);
+ zend_string_release_ex(opened_path, 0);
} else {
efree((char *)fh.filename);
}
zend_string *key = zend_string_init_interned(name, name_len, 0);
zend_hash_update_ind(ht, key, val);
- zend_string_release(key);
+ zend_string_release_ex(key, 0);
}
PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars_array)
static void free_filename(zval *el) {
zend_string *filename = Z_STR_P(el);
- zend_string_release(filename);
+ zend_string_release_ex(filename, 0);
}
PHPAPI void destroy_uploaded_files_hash(void) /* {{{ */
if (cancel_upload != UPLOAD_ERROR_E) { /* file creation failed */
unlink(ZSTR_VAL(temp_filename));
}
- zend_string_release(temp_filename);
+ zend_string_release_ex(temp_filename, 0);
}
temp_filename = NULL;
} else {
if (php_stream_cast(stream, PHP_STREAM_AS_STDIO|PHP_STREAM_CAST_TRY_HARD|PHP_STREAM_CAST_RELEASE, (void**)&fp, REPORT_ERRORS) == FAILURE) {
php_stream_close(stream);
if (opened_path && *opened_path) {
- zend_string_release(*opened_path);
+ zend_string_release_ex(*opened_path, 0);
}
return NULL;
}
int ret;
zend_string *str = zend_string_init_interned(filterpattern, strlen(filterpattern), 1);
ret = zend_hash_add_ptr(&stream_filters_hash, str, (void*)factory) ? SUCCESS : FAILURE;
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
return ret;
}
unlink(ZSTR_VAL(data->temp_name));
#endif
/* temporary streams are never persistent */
- zend_string_release(data->temp_name);
+ zend_string_release_ex(data->temp_name, 0);
data->temp_name = NULL;
}
} else {
r = do_fstat(self, 0);
if ((r == 0 && !S_ISREG(self->sb.st_mode))) {
if (opened_path) {
- zend_string_release(*opened_path);
+ zend_string_release_ex(*opened_path, 0);
*opened_path = NULL;
}
php_stream_close(ret);
str = zend_string_init_interned(protocol, protocol_len, 1);
ret = zend_hash_add_ptr(&url_stream_wrappers_hash, str, (void*)wrapper) ? SUCCESS : FAILURE;
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
return ret;
}
if (options & STREAM_USE_URL && (!wrapper || !wrapper->is_url)) {
php_error_docref(NULL, E_WARNING, "This function may only be used against URLs");
if (resolved_path) {
- zend_string_release(resolved_path);
+ zend_string_release_ex(resolved_path, 0);
}
return NULL;
}
? PHP_STREAM_PREFER_STDIO : PHP_STREAM_NO_PREFERENCE)) {
case PHP_STREAM_UNCHANGED:
if (resolved_path) {
- zend_string_release(resolved_path);
+ zend_string_release_ex(resolved_path, 0);
}
return stream;
case PHP_STREAM_RELEASED:
}
newstream->orig_path = pestrdup(path, persistent);
if (resolved_path) {
- zend_string_release(resolved_path);
+ zend_string_release_ex(resolved_path, 0);
}
return newstream;
default:
if (stream == NULL && (options & REPORT_ERRORS)) {
php_stream_display_wrapper_errors(wrapper, path, "failed to open stream");
if (opened_path && *opened_path) {
- zend_string_release(*opened_path);
+ zend_string_release_ex(*opened_path, 0);
*opened_path = NULL;
}
}
}
#endif
if (resolved_path) {
- zend_string_release(resolved_path);
+ zend_string_release_ex(resolved_path, 0);
}
return stream;
}
zend_string *str = zend_string_init_interned(protocol, strlen(protocol), 1);
ret = zend_hash_update_ptr(&xport_hash, str, factory) ? SUCCESS : FAILURE;
- zend_string_release(str);
+ zend_string_release_ex(str, 1);
return ret;
}
#define ERR_RETURN(out_err, local_err, fmt) \
if (out_err) { *out_err = local_err; } \
else { php_error_docref(NULL, E_WARNING, fmt, local_err ? ZSTR_VAL(local_err) : "Unspecified error"); \
- if (local_err) { zend_string_release(local_err); local_err = NULL; } \
+ if (local_err) { zend_string_release_ex(local_err, 0); local_err = NULL; } \
}
PHPAPI php_stream *_php_stream_xport_create(const char *name, size_t namelen, int options,
smart_str_appendl_ex(buffer, "Date: ", 6, persistent);
smart_str_appends_ex(buffer, dt->val, persistent);
smart_str_appendl_ex(buffer, "\r\n", 2, persistent);
- zend_string_release(dt);
+ zend_string_release_ex(dt, 0);
}
smart_str_appendl_ex(buffer, "Connection: close\r\n", sizeof("Connection: close\r\n") - 1, persistent);
GC_MAKE_PERSISTENT_LOCAL(lc_header_name);
zend_hash_add_ptr(&client->request.headers, lc_header_name, client->current_header_value);
zend_hash_add_ptr(&client->request.headers_original_case, orig_header_name, client->current_header_value);
- zend_string_release(lc_header_name);
- zend_string_release(orig_header_name);
+ zend_string_release_ex(lc_header_name, 1);
+ zend_string_release_ex(orig_header_name, 1);
if (client->current_header_name_allocated) {
pefree(client->current_header_name, 1);
php_network_populate_name_from_sockaddr(addr, addr_len, &addr_str, NULL, 0);
client->addr_str = pestrndup(ZSTR_VAL(addr_str), ZSTR_LEN(addr_str), 1);
client->addr_str_len = ZSTR_LEN(addr_str);
- zend_string_release(addr_str);
+ zend_string_release_ex(addr_str, 0);
}
php_http_parser_init(&client->parser, PHP_HTTP_REQUEST);
client->request_read = 0;
chunk = php_cli_server_chunk_heap_new(buffer.s, ZSTR_VAL(buffer.s), ZSTR_LEN(buffer.s));
if (!chunk) {
- smart_str_free(&buffer);
+ smart_str_free_ex(&buffer, 1);
goto fail;
}
php_cli_server_buffer_prepend(&client->content_sender.buffer, chunk);
smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
chunk = php_cli_server_chunk_heap_new(buffer.s, ZSTR_VAL(buffer.s), ZSTR_LEN(buffer.s));
if (!chunk) {
- smart_str_free(&buffer);
+ smart_str_free_ex(&buffer, 1);
php_cli_server_log_response(client, 500, NULL);
return FAILURE;
}
if (server_sock == SOCK_ERR) {
php_cli_server_logf("Failed to listen on %s:%d (reason: %s)", host, port, errstr ? ZSTR_VAL(errstr) : "?");
if (errstr) {
- zend_string_release(errstr);
+ zend_string_release_ex(errstr, 0);
}
retval = FAILURE;
goto out;
ini_entry->modifiable = mode;
}
} else {
- zend_string_release(duplicate);
+ zend_string_release_ex(duplicate, 1);
}
return SUCCESS;
PUTS(buffer);
efree(buffer);
- zend_string_release(_GET_str);
+ zend_string_release_ex(_GET_str, 0);
if (short_post) {
PUTS(short_post);
zend_alter_ini_entry_chars(psKey,
(char *)pValue, valLen,
type, stage);
- zend_string_release(psKey);
+ zend_string_release_ex(psKey, 1);
}
}
return 1;
zend_alter_ini_entry_chars(psKey,
(char *)*(ini+1), strlen( *(ini+1) ),
PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE);
- zend_string_release(psKey);
+ zend_string_release_ex(psKey, 1);
}
while (( p < argend )&&(**p == '-' )) {
-1,
NULL);
- zend_string_release(replace);
- zend_string_release(regex);
+ zend_string_release_ex(replace, 0);
+ zend_string_release_ex(regex, 0);
if (NULL == result) {
return NULL;
replace,
-1,
NULL);
- zend_string_release(replace);
- zend_string_release(regex);
- zend_string_release(result);
+ zend_string_release_ex(replace, 0);
+ zend_string_release_ex(regex, 0);
+ zend_string_release_ex(result, 0);
return result2;
}
* insensitive when searching for a pattern. */
headers_lc = zend_string_tolower(headers_trim);
if (headers_lc == headers_trim) {
- zend_string_release(headers_lc);
+ zend_string_release_ex(headers_lc, 0);
}
}
projects / php / commitdiff