diff options
43 files changed, 481 insertions, 320 deletions
diff --git a/Zend/zend.c b/Zend/zend.c index 92c938a5df..a060602aba 100644 --- a/Zend/zend.c +++ b/Zend/zend.c @@ -505,7 +505,7 @@ static void compiler_globals_ctor(zend_compiler_globals *compiler_globals TSRMLS compiler_globals->class_table = (HashTable *) malloc(sizeof(HashTable)); zend_hash_init_ex(compiler_globals->class_table, 10, NULL, ZEND_CLASS_DTOR, 1, 0); - zend_hash_copy(compiler_globals->class_table, global_class_table, (copy_ctor_func_t) zend_class_add_ref, &tmp_class, sizeof(zend_class_entry *)); + zend_hash_copy(compiler_globals->class_table, global_class_table, zend_class_add_ref); zend_set_default_compile_time_values(TSRMLS_C); @@ -612,6 +612,21 @@ static void php_scanner_globals_ctor(zend_php_scanner_globals *scanner_globals_p void zend_init_opcodes_handlers(void); +static void module_destructor_zval(zval *zv) /* {{{ */ +{ + zend_module_entry *module = (zend_module_entry*)Z_PTR_P(zv); + + module_destructor(module); + free(module); +} +/* }}} */ + +static void auto_global_dtor(zval *zv) /* {{{ */ +{ + free(Z_PTR_P(zv)); +} +/* }}} */ + static zend_bool php_auto_globals_create_globals(zend_string *name TSRMLS_DC) /* {{{ */ { zval globals; @@ -694,10 +709,10 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions TS zend_hash_init_ex(GLOBAL_FUNCTION_TABLE, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0); zend_hash_init_ex(GLOBAL_CLASS_TABLE, 10, NULL, ZEND_CLASS_DTOR, 1, 0); - zend_hash_init_ex(GLOBAL_AUTO_GLOBALS_TABLE, 8, NULL, NULL, 1, 0); + zend_hash_init_ex(GLOBAL_AUTO_GLOBALS_TABLE, 8, NULL, auto_global_dtor, 1, 0); zend_hash_init_ex(GLOBAL_CONSTANTS_TABLE, 20, NULL, ZEND_CONSTANT_DTOR, 1, 0); - zend_hash_init_ex(&module_registry, 50, NULL, ZEND_MODULE_DTOR, 1, 0); + zend_hash_init_ex(&module_registry, 50, NULL, module_destructor_zval, 1, 0); zend_init_rsrc_list_dtors(); #ifdef ZTS @@ -730,7 +745,7 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions TS zend_interned_strings_init(TSRMLS_C); zend_startup_builtin_functions(TSRMLS_C); zend_register_standard_constants(TSRMLS_C); - zend_register_auto_global(STR_INIT("GLOBALS", sizeof("GLOBALS") - 1, 0), 1, php_auto_globals_create_globals TSRMLS_CC); + zend_register_auto_global(STR_INIT("GLOBALS", sizeof("GLOBALS") - 1, 1), 1, php_auto_globals_create_globals TSRMLS_CC); #ifndef ZTS zend_init_rsrc_plist(TSRMLS_C); @@ -1361,6 +1376,12 @@ void free_estring(char **str_p) /* {{{ */ { efree(*str_p); } + +void free_string_zval(zval *zv) /* {{{ */ +{ + zend_string *str = Z_PTR_P(zv); + STR_RELEASE(str); +} /* }}} */ /* diff --git a/Zend/zend.h b/Zend/zend.h index eb771866b5..4d212c5e1f 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -575,6 +575,7 @@ END_EXTERN_C() BEGIN_EXTERN_C() ZEND_API void free_estring(char **str_p); +ZEND_API void free_string_zval(zval *zv); END_EXTERN_C() /* FIXME: Check if we can save if (ptr) too */ diff --git a/Zend/zend_API.c b/Zend/zend_API.c index bd5867f3a5..cb539b0f4c 100644 --- a/Zend/zend_API.c +++ b/Zend/zend_API.c @@ -2071,7 +2071,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio while (ptr->fname) { fname_len = strlen(ptr->fname); internal_function->handler = ptr->handler; - internal_function->function_name = STR_INIT(ptr->fname, fname_len, 1); + internal_function->function_name = zend_new_interned_string(STR_INIT(ptr->fname, fname_len, 1)); internal_function->scope = scope; internal_function->prototype = NULL; if (ptr->flags) { @@ -2140,8 +2140,11 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio lowercase_name = STR_ALLOC(fname_len, 1); zend_str_tolower_copy(lowercase_name->val, ptr->fname, fname_len); lowercase_name = zend_new_interned_string(lowercase_name TSRMLS_CC); - if ((reg_function = zend_hash_add_mem(target_function_table, lowercase_name, &function, sizeof(zend_function))) == NULL) { + reg_function = malloc(sizeof(zend_internal_function)); + memcpy(reg_function, &function, sizeof(zend_internal_function)); + if (zend_hash_add_ptr(target_function_table, lowercase_name, reg_function) == NULL) { unload=1; + free(reg_function); STR_RELEASE(lowercase_name); break; } @@ -2421,8 +2424,10 @@ ZEND_API void zend_activate_modules(TSRMLS_D) /* {{{ */ /* }}} */ /* call request shutdown for all modules */ -int module_registry_cleanup(zend_module_entry *module TSRMLS_DC) /* {{{ */ +static int module_registry_cleanup(zval *zv TSRMLS_DC) /* {{{ */ { + zend_module_entry *module = Z_PTR_P(zv); + if (module->request_shutdown_func) { #if 0 zend_printf("%s: Request shutdown\n", module->name); @@ -2439,7 +2444,7 @@ ZEND_API void zend_deactivate_modules(TSRMLS_D) /* {{{ */ zend_try { if (EG(full_tables_cleanup)) { - zend_hash_reverse_apply(&module_registry, (apply_func_t) module_registry_cleanup TSRMLS_CC); + zend_hash_reverse_apply(&module_registry, module_registry_cleanup TSRMLS_CC); } else { zend_module_entry **p = module_request_shutdown_handlers; @@ -3480,19 +3485,11 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, z } switch (access_type & ZEND_ACC_PPP_MASK) { case ZEND_ACC_PRIVATE: { - char *priv_name; - int priv_name_length; - - zend_mangle_property_name(&priv_name, &priv_name_length, ce->name->val, ce->name->len, name->val, name->len, ce->type & ZEND_INTERNAL_CLASS); - property_info.name = STR_INIT(priv_name, priv_name_length, ce->type & ZEND_INTERNAL_CLASS); + property_info.name = zend_mangle_property_name(ce->name->val, ce->name->len, name->val, name->len, ce->type & ZEND_INTERNAL_CLASS); } break; case ZEND_ACC_PROTECTED: { - char *prot_name; - int prot_name_length; - - zend_mangle_property_name(&prot_name, &prot_name_length, "*", 1, name->val, name->len, ce->type & ZEND_INTERNAL_CLASS); - property_info.name = STR_INIT(prot_name, prot_name_length, ce->type & ZEND_INTERNAL_CLASS); + property_info.name = zend_mangle_property_name("*", 1, name->val, name->len, ce->type & ZEND_INTERNAL_CLASS); } break; case ZEND_ACC_PUBLIC: diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c index c35a102171..85c52dd953 100644 --- a/Zend/zend_builtin_functions.c +++ b/Zend/zend_builtin_functions.c @@ -1766,22 +1766,23 @@ ZEND_FUNCTION(create_function) efree(eval_name); if (retval==SUCCESS) { - zend_function new_function, *func; + zend_function *new_function, *func; func = zend_hash_str_find_ptr(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME)-1); if (!func) { zend_error(E_ERROR, "Unexpected inconsistency in create_function()"); RETURN_FALSE; } - new_function = *func; - function_add_ref(&new_function); + new_function = pemalloc(sizeof(zend_function), func->type == ZEND_INTERNAL_FUNCTION); + memcpy(new_function, func, sizeof(zend_function)); + function_add_ref(new_function); function_name = STR_ALLOC(sizeof("0lambda_")+MAX_LENGTH_OF_LONG, 0); function_name->val[0] = '\0'; do { function_name->len = snprintf(function_name->val + 1, sizeof("lambda_")+MAX_LENGTH_OF_LONG, "lambda_%d", ++EG(lambda_count)); - } while (zend_hash_add_mem(EG(function_table), function_name, &new_function, sizeof(zend_function)) == NULL); + } while (zend_hash_add_ptr(EG(function_table), function_name, new_function) == NULL); zend_hash_str_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME)-1); RETURN_STR(function_name); } else { diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 75c5a827d5..58d4cc1e50 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -108,7 +108,10 @@ static void zend_duplicate_property_info(zend_property_info *property_info) /* { static void zend_duplicate_property_info_zval(zval *zv) /* {{{ */ { - zend_duplicate_property_info((zend_property_info*)Z_PTR_P(zv)); + zend_property_info* property_info = emalloc(sizeof(zend_property_info)); + memcpy(property_info, Z_PTR_P(zv), sizeof(zend_property_info)); + Z_PTR_P(zv) = property_info; + zend_duplicate_property_info(property_info); } /* }}} */ @@ -120,7 +123,10 @@ static void zend_duplicate_property_info_internal(zend_property_info *property_i static void zend_duplicate_property_info_internal_zval(zval *zv) /* {{{ */ { - zend_duplicate_property_info_internal((zend_property_info*)Z_PTR_P(zv)); + zend_property_info* property_info = pemalloc(sizeof(zend_property_info), 1); + memcpy(property_info, Z_PTR_P(zv), sizeof(zend_property_info)); + Z_PTR_P(zv) = property_info; + zend_duplicate_property_info_internal(property_info); } /* }}} */ @@ -132,6 +138,7 @@ static void zend_destroy_property_info(zval *zv) /* {{{ */ if (property_info->doc_comment) { STR_RELEASE(property_info->doc_comment); } + efree(property_info); } /* }}} */ @@ -140,6 +147,7 @@ static void zend_destroy_property_info_internal(zval *zv) /* {{{ */ zend_property_info *property_info = Z_PTR_P(zv); STR_RELEASE(property_info->name); + free(property_info); } /* }}} */ @@ -226,7 +234,7 @@ void init_compiler(TSRMLS_D) /* {{{ */ memset(&CG(context), 0, sizeof(CG(context))); zend_init_compiler_data_structures(TSRMLS_C); zend_init_rsrc_list(TSRMLS_C); - zend_hash_init(&CG(filenames_table), 5, NULL, (dtor_func_t) free_estring, 0); + zend_hash_init(&CG(filenames_table), 5, NULL, free_string_zval, 0); zend_llist_init(&CG(open_files), sizeof(zend_file_handle), (void (*)(void *)) file_handle_dtor, 0); CG(unclean_shutdown) = 0; } @@ -1395,12 +1403,12 @@ void zend_do_add_string(znode *result, const znode *op1, znode *op2 TSRMLS_DC) / int ch = *Z_STRVAL(op2->u.constant); /* Free memory and use ZEND_ADD_CHAR in case of 1 character strings */ - efree(Z_STRVAL(op2->u.constant)); + STR_FREE(Z_STR(op2->u.constant)); ZVAL_LONG(&op2->u.constant, ch); opline = get_next_op(CG(active_op_array) TSRMLS_CC); opline->opcode = ZEND_ADD_CHAR; } else { /* String can be empty after a variable at the end of a heredoc */ - efree(Z_STRVAL(op2->u.constant)); + STR_FREE(Z_STR(op2->u.constant)); return; } @@ -1564,7 +1572,9 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n lcname = STR_ALLOC(name->len, 0); zend_str_tolower_copy(lcname->val, name->val, name->len); lcname = zend_new_interned_string(lcname TSRMLS_CC); - if ((CG(active_op_array) = zend_hash_add_mem(&CG(active_class_entry)->function_table, lcname, &op_array, sizeof(zend_op_array))) == NULL) { + CG(active_op_array) = emalloc(sizeof(zend_op_array)); + memcpy(CG(active_op_array), &op_array, sizeof(zend_op_array)); + if (zend_hash_add_ptr(&CG(active_class_entry)->function_table, lcname, CG(active_op_array)) == NULL) { zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", CG(active_class_entry)->name->val, name->val); } @@ -1718,7 +1728,9 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n opline->op2_type = IS_CONST; LITERAL_STR(opline->op2, STR_COPY(lcname)); opline->extended_value = ZEND_DECLARE_FUNCTION; - CG(active_op_array) = zend_hash_update_mem(CG(function_table), Z_STR(key), &op_array, sizeof(zend_op_array)); + CG(active_op_array) = emalloc(sizeof(zend_op_array)); + memcpy(CG(active_op_array), &op_array, sizeof(zend_op_array)); + zend_hash_update_ptr(CG(function_table), Z_STR(key), CG(active_op_array)); zend_stack_push(&CG(context_stack), (void *) &CG(context), sizeof(CG(context))); zend_init_compiler_context(TSRMLS_C); STR_RELEASE(lcname); @@ -2226,9 +2238,9 @@ void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */ if (Z_STRVAL(class_name->u.constant)[0] == '\\') { /* The STRING name has "\" prefix */ memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant)-1); - Z_STR(class_name->u.constant) = STR_EREALLOC( + Z_STR(class_name->u.constant) = STR_REALLOC( Z_STR(class_name->u.constant), - Z_STRLEN(class_name->u.constant) - 1); + Z_STRLEN(class_name->u.constant) - 1, 0); if (ZEND_FETCH_CLASS_DEFAULT != zend_get_class_fetch_type(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant))) { zend_error_noreturn(E_COMPILE_ERROR, "'\\%s' is an invalid class name", Z_STRVAL(class_name->u.constant)); @@ -2447,14 +2459,14 @@ void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_c if (is_class_member) { int old_len = Z_STRLEN(result->u.constant); length = sizeof("::")-1 + old_len + Z_STRLEN(name->u.constant); - Z_STR(result->u.constant) = STR_EREALLOC(Z_STR(result->u.constant), length); + Z_STR(result->u.constant) = STR_REALLOC(Z_STR(result->u.constant), length, 0); memcpy(&Z_STRVAL(result->u.constant)[old_len], "::", sizeof("::")-1); memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1); STR_RELEASE(Z_STR(name->u.constant)); } else { int old_len = Z_STRLEN(result->u.constant); length = sizeof("\\")-1 + old_len + Z_STRLEN(name->u.constant); - Z_STR(result->u.constant) = STR_EREALLOC(Z_STR(result->u.constant), length); + Z_STR(result->u.constant) = STR_REALLOC(Z_STR(result->u.constant), length, 0); memcpy(&Z_STRVAL(result->u.constant)[old_len], "\\", sizeof("\\")-1); memcpy(&Z_STRVAL(result->u.constant)[old_len + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1); STR_RELEASE(Z_STR(name->u.constant)); @@ -3119,7 +3131,14 @@ static void do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */ if ((function = zend_hash_str_find_ptr(&ce->parent->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1)) != NULL) { /* inherit parent's constructor */ - new_function = zend_hash_str_update_mem(&ce->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1, function, sizeof(zend_function)); + if (function->type == ZEND_INTERNAL_FUNCTION) { + new_function = pemalloc(sizeof(zend_internal_function), 1); + memcpy(new_function, function, sizeof(zend_internal_function)); + } else { + new_function = emalloc(sizeof(zend_op_array)); + memcpy(new_function, function, sizeof(zend_op_array)); + } + zend_hash_str_update_ptr(&ce->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1, new_function); function_add_ref(new_function); } else { /* Don't inherit the old style constructor if we already have the new style constructor */ @@ -3135,7 +3154,9 @@ static void do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */ (function = zend_hash_find_ptr(&ce->parent->function_table, lc_parent_class_name)) != NULL) { if (function->common.fn_flags & ZEND_ACC_CTOR) { /* inherit parent's constructor */ - zend_hash_update_mem(&ce->function_table, lc_parent_class_name, function, sizeof(zend_function)); + new_function = pemalloc(sizeof(zend_function), function->type == ZEND_INTERNAL_FUNCTION); + memcpy(new_function, function, sizeof(zend_function)); + zend_hash_update_ptr(&ce->function_table, lc_parent_class_name, new_function); function_add_ref(new_function); } } @@ -3162,13 +3183,24 @@ char *zend_visibility_string(zend_uint fn_flags) /* {{{ */ } /* }}} */ -static void do_inherit_method(zend_function *function) /* {{{ */ +static void do_inherit_method(zval *zv) /* {{{ */ { + zend_function *old_function = Z_PTR_P(zv); + zend_function *new_function; + + if (old_function->type == ZEND_INTERNAL_FUNCTION) { + new_function = pemalloc(sizeof(zend_internal_function), 1); + memcpy(new_function, old_function, sizeof(zend_internal_function)); + } else { + new_function = emalloc(sizeof(zend_op_array)); + memcpy(new_function, old_function, sizeof(zend_op_array)); + } /* The class entry of the derived function intentionally remains the same * as that of the parent class. That allows us to know in which context * we're running, and handle private method calls properly. */ - function_add_ref(function); + function_add_ref(new_function); + Z_PTR_P(zv) = new_function; } /* }}} */ @@ -3802,7 +3834,7 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent zend_hash_merge_ex(&ce->properties_info, &parent_ce->properties_info, (ce->type & ZEND_INTERNAL_CLASS ? zend_duplicate_property_info_internal_zval : zend_duplicate_property_info_zval), (merge_checker_func_t) do_inherit_property_access_check, ce); zend_hash_merge(&ce->constants_table, &parent_ce->constants_table, zval_property_ctor(parent_ce, ce), 0); - zend_hash_merge_ex(&ce->function_table, &parent_ce->function_table, (copy_ctor_func_t) do_inherit_method, (merge_checker_func_t) do_inherit_method_check, ce); + zend_hash_merge_ex(&ce->function_table, &parent_ce->function_table, do_inherit_method, (merge_checker_func_t) do_inherit_method_check, ce); do_inherit_parent_constructor(ce); if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS && ce->type == ZEND_INTERNAL_CLASS) { @@ -3871,7 +3903,7 @@ ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry ce->interfaces[ce->num_interfaces++] = iface; zend_hash_merge_ex(&ce->constants_table, &iface->constants_table, (copy_ctor_func_t) zval_add_ref, (merge_checker_func_t) do_inherit_constant_check, iface); - zend_hash_merge_ex(&ce->function_table, &iface->function_table, (copy_ctor_func_t) do_inherit_method, (merge_checker_func_t) do_inherit_method_check, ce); + zend_hash_merge_ex(&ce->function_table, &iface->function_table, do_inherit_method, (merge_checker_func_t) do_inherit_method_check, ce); do_implement_interface(ce, iface TSRMLS_CC); zend_do_inherit_interfaces(ce, iface TSRMLS_CC); @@ -4512,7 +4544,7 @@ ZEND_API void zend_do_bind_traits(zend_class_entry *ce TSRMLS_DC) /* {{{ */ ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, HashTable *function_table, zend_bool compile_time) /* {{{ */ { - zend_function *function; + zend_function *function, *new_function; zval *op1, *op2; if (compile_time) { @@ -4524,10 +4556,13 @@ ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, Ha } function = zend_hash_find_ptr(function_table, Z_STR_P(op1)); - if (zend_hash_add_mem(function_table, Z_STR_P(op2), function, sizeof(zend_function)) == NULL) { + new_function = emalloc(sizeof(zend_op_array)); + memcpy(new_function, function, sizeof(zend_op_array)); + if (zend_hash_add_ptr(function_table, Z_STR_P(op2), new_function) == NULL) { int error_level = compile_time ? E_COMPILE_ERROR : E_ERROR; zend_function *old_function; + efree(new_function); if ((old_function = zend_hash_find_ptr(function_table, Z_STR_P(op2))) != NULL && old_function->type == ZEND_USER_FUNCTION && old_function->op_array.last > 0) { @@ -4540,8 +4575,8 @@ ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, Ha } return FAILURE; } else { - (*function->op_array.refcount)++; - function->op_array.static_variables = NULL; /* NULL out the unbound function */ + (*new_function->op_array.refcount)++; + new_function->op_array.static_variables = NULL; /* NULL out the unbound function */ return SUCCESS; } } @@ -5283,19 +5318,17 @@ void zend_do_use_trait(znode *trait_name TSRMLS_DC) /* {{{ */ } /* }}} */ -ZEND_API void zend_mangle_property_name(char **dest, int *dest_length, const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */ +ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal) /* {{{ */ { - char *prop_name; + zend_string *prop_name; int prop_name_length; prop_name_length = 1 + src1_length + 1 + src2_length; - prop_name = pemalloc(prop_name_length + 1, internal); - prop_name[0] = '\0'; - memcpy(prop_name + 1, src1, src1_length+1); - memcpy(prop_name + 1 + src1_length + 1, src2, src2_length+1); - - *dest = prop_name; - *dest_length = prop_name_length; + prop_name = STR_ALLOC(prop_name_length, internal); + prop_name->val[0] = '\0'; + memcpy(prop_name->val + 1, src1, src1_length+1); + memcpy(prop_name->val + 1 + src1_length + 1, src2, src2_length+1); + return prop_name; } /* }}} */ @@ -5493,19 +5526,18 @@ void zend_do_fetch_property(znode *result, znode *object, const znode *property void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */ { - char *name; + zend_string *name; zend_string *cfilename; char haltoff[] = "__COMPILER_HALT_OFFSET__"; - int len; if (CG(has_bracketed_namespaces) && CG(in_namespace)) { zend_error_noreturn(E_COMPILE_ERROR, "__HALT_COMPILER() can only be used from the outermost scope"); } cfilename = zend_get_compiled_filename(TSRMLS_C); - zend_mangle_property_name(&name, &len, haltoff, sizeof(haltoff) - 1, cfilename->val, cfilename->len, 0); - zend_register_long_constant(name, len+1, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC); - pefree(name, 0); + name = zend_mangle_property_name(haltoff, sizeof(haltoff) - 1, cfilename->val, cfilename->len, 0); + zend_register_long_constant(name->val, name->len, zend_get_scanned_file_offset(TSRMLS_C), CONST_CS, 0 TSRMLS_CC); + STR_FREE(name); if (CG(in_namespace)) { zend_do_end_namespace(TSRMLS_C); @@ -6787,8 +6819,10 @@ int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global } /* }}} */ -static int zend_auto_global_init(zend_auto_global *auto_global TSRMLS_DC) /* {{{ */ +static int zend_auto_global_init(zval *zv TSRMLS_DC) /* {{{ */ { + zend_auto_global *auto_global = Z_PTR_P(zv); + if (auto_global->jit) { auto_global->armed = 1; } else if (auto_global->auto_global_callback) { diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 96c3c34a7a..8af44237bf 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -669,17 +669,17 @@ ZEND_API int zend_cleanup_function_data(zend_function *function TSRMLS_DC); ZEND_API int zend_cleanup_function_data_full(zend_function *function TSRMLS_DC); ZEND_API void destroy_zend_function(zend_function *function TSRMLS_DC); -ZEND_API void zend_function_dtor(zend_function *function); -ZEND_API void destroy_zend_class(zend_class_entry **pce); -void zend_class_add_ref(zend_class_entry **ce); +ZEND_API void zend_function_dtor(zval *zv); +ZEND_API void destroy_zend_class(zval *zv); +void zend_class_add_ref(zval *zv); -ZEND_API void zend_mangle_property_name(char **dest, int *dest_length, const char *src1, int src1_length, const char *src2, int src2_length, int internal); +ZEND_API zend_string *zend_mangle_property_name(const char *src1, int src1_length, const char *src2, int src2_length, int internal); #define zend_unmangle_property_name(mangled_property, mangled_property_len, class_name, prop_name) \ zend_unmangle_property_name_ex(mangled_property, mangled_property_len, class_name, prop_name, NULL) ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int mangled_property_len, const char **class_name, const char **prop_name, int *prop_len); -#define ZEND_FUNCTION_DTOR (void (*)(zval *)) zend_function_dtor -#define ZEND_CLASS_DTOR (void (*)(zval *)) destroy_zend_class +#define ZEND_FUNCTION_DTOR zend_function_dtor +#define ZEND_CLASS_DTOR destroy_zend_class zend_op *get_next_op(zend_op_array *op_array TSRMLS_DC); void init_op(zend_op *op TSRMLS_DC); diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c index f6cbac3968..04162c8b70 100644 --- a/Zend/zend_constants.c +++ b/Zend/zend_constants.c @@ -27,12 +27,17 @@ #include "zend_globals.h" #include "zend_API.h" -void free_zend_constant(zend_constant *c) +void free_zend_constant(zval *zv) { + zend_constant *c = Z_PTR_P(zv); + if (!(c->flags & CONST_PERSISTENT)) { zval_dtor(&c->value); + } else { + zval_internal_dtor(&c->value); } STR_RELEASE(c->name); + free(c); } @@ -40,12 +45,12 @@ static void copy_zend_constant(zval *zv) { zend_constant *c = Z_PTR_P(zv); - Z_PTR_P(zv) = pemalloc(sizeof(zend_constant), c->flags & CONST_PERSISTENT); + Z_PTR_P(zv) = malloc(sizeof(zend_constant)/*, c->flags & CONST_PERSISTENT*/); memcpy(Z_PTR_P(zv), c, sizeof(zend_constant)); c->name = STR_DUP(c->name, c->flags & CONST_PERSISTENT); - if (!(c->flags & CONST_PERSISTENT)) { +//??? if (!(c->flags & CONST_PERSISTENT)) { zval_copy_ctor(&c->value); - } +//??? } } @@ -55,14 +60,16 @@ void zend_copy_constants(HashTable *target, HashTable *source) } -static int clean_non_persistent_constant(const zend_constant *c TSRMLS_DC) +static int clean_non_persistent_constant(zval *zv TSRMLS_DC) { + zend_constant *c = Z_PTR_P(zv); return (c->flags & CONST_PERSISTENT) ? ZEND_HASH_APPLY_STOP : ZEND_HASH_APPLY_REMOVE; } -static int clean_non_persistent_constant_full(const zend_constant *c TSRMLS_DC) +static int clean_non_persistent_constant_full(zval *zv TSRMLS_DC) { + zend_constant *c = Z_PTR_P(zv); return (c->flags & CONST_PERSISTENT) ? 0 : 1; } @@ -139,9 +146,9 @@ int zend_shutdown_constants(TSRMLS_D) void clean_non_persistent_constants(TSRMLS_D) { if (EG(full_tables_cleanup)) { - zend_hash_apply(EG(zend_constants), (apply_func_t) clean_non_persistent_constant_full TSRMLS_CC); + zend_hash_apply(EG(zend_constants), clean_non_persistent_constant_full TSRMLS_CC); } else { - zend_hash_reverse_apply(EG(zend_constants), (apply_func_t) clean_non_persistent_constant TSRMLS_CC); + zend_hash_reverse_apply(EG(zend_constants), clean_non_persistent_constant TSRMLS_CC); } } @@ -151,8 +158,7 @@ ZEND_API void zend_register_null_constant(const char *name, uint name_len, int f ZVAL_NULL(&c.value); c.flags = flags; - // TODO: remove -1 ??? - c.name = STR_INIT(name, name_len-1, flags & CONST_PERSISTENT); + c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT); c.module_number = module_number; zend_register_constant(&c TSRMLS_CC); } @@ -163,8 +169,7 @@ ZEND_API void zend_register_bool_constant(const char *name, uint name_len, zend_ ZVAL_BOOL(&c.value, bval); c.flags = flags; - // TODO: remove -1 ??? - c.name = STR_INIT(name, name_len-1, flags & CONST_PERSISTENT); + c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT); c.module_number = module_number; zend_register_constant(&c TSRMLS_CC); } @@ -175,8 +180,7 @@ ZEND_API void zend_register_long_constant(const char *name, uint name_len, long ZVAL_LONG(&c.value, lval); c.flags = flags; - // TODO: remove -1 ??? - c.name = STR_INIT(name, name_len-1, flags & CONST_PERSISTENT); + c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT); c.module_number = module_number; zend_register_constant(&c TSRMLS_CC); } @@ -188,8 +192,7 @@ ZEND_API void zend_register_double_constant(const char *name, uint name_len, dou ZVAL_DOUBLE(&c.value, dval); c.flags = flags; - // TODO: remove -1 ??? - c.name = STR_INIT(name, name_len-1, flags & CONST_PERSISTENT); + c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT); c.module_number = module_number; zend_register_constant(&c TSRMLS_CC); } @@ -200,10 +203,9 @@ ZEND_API void zend_register_stringl_constant(const char *name, uint name_len, ch zend_constant c; //??? ZVAL_STRINGL(&c.value, strval, strlen, 0); - ZVAL_STRINGL(&c.value, strval, strlen); + ZVAL_STR(&c.value, STR_INIT(strval, strlen, flags & CONST_PERSISTENT)); c.flags = flags; - // TODO: remove -1 ??? - c.name = STR_INIT(name, name_len-1, flags & CONST_PERSISTENT); + c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT); c.module_number = module_number; zend_register_constant(&c TSRMLS_CC); } @@ -254,16 +256,16 @@ static zend_constant *zend_get_special_constant(const char *name, uint name_len } else if (name_len == sizeof("__COMPILER_HALT_OFFSET__")-1 && !memcmp(name, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1)) { const char *cfilename; - char *haltname; - int len, clen; + zend_string *haltname; + int clen; cfilename = zend_get_executed_filename(TSRMLS_C); clen = strlen(cfilename); /* check for __COMPILER_HALT_OFFSET__ */ - zend_mangle_property_name(&haltname, &len, haltoff, + haltname = zend_mangle_property_name(haltoff, sizeof("__COMPILER_HALT_OFFSET__") - 1, cfilename, clen, 0); - c = zend_hash_str_find_ptr(EG(zend_constants), haltname, len); - efree(haltname); + c = zend_hash_find_ptr(EG(zend_constants), haltname); + STR_FREE(haltname); return c; } else { return NULL; @@ -469,14 +471,14 @@ ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC) if (!(c->flags & CONST_CS)) { //??? /* keep in mind that c->name_len already contains the '\0' */ - lowercase_name = STR_ALLOC(c->name->len, 0); + lowercase_name = STR_ALLOC(c->name->len, c->flags & CONST_PERSISTENT); zend_str_tolower_copy(lowercase_name->val, c->name->val, c->name->len); lowercase_name = zend_new_interned_string(lowercase_name TSRMLS_CC); name = lowercase_name; } else { char *slash = strrchr(c->name->val, '\\'); if (slash) { - lowercase_name = STR_ALLOC(c->name->len, 0); + lowercase_name = STR_ALLOC(c->name->len, c->flags & CONST_PERSISTENT); zend_str_tolower_copy(lowercase_name->val, c->name->val, c->name->len); lowercase_name = zend_new_interned_string(lowercase_name TSRMLS_CC); name = lowercase_name; diff --git a/Zend/zend_constants.h b/Zend/zend_constants.h index 86c5d56f0a..5ededead25 100644 --- a/Zend/zend_constants.h +++ b/Zend/zend_constants.h @@ -37,12 +37,12 @@ typedef struct _zend_constant { int module_number; } zend_constant; -#define REGISTER_NULL_CONSTANT(name, flags) zend_register_null_constant((name), sizeof(name), (flags), module_number TSRMLS_CC) -#define REGISTER_BOOL_CONSTANT(name, bval, flags) zend_register_bool_constant((name), sizeof(name), (bval), (flags), module_number TSRMLS_CC) -#define REGISTER_LONG_CONSTANT(name, lval, flags) zend_register_long_constant((name), sizeof(name), (lval), (flags), module_number TSRMLS_CC) -#define REGISTER_DOUBLE_CONSTANT(name, dval, flags) zend_register_double_constant((name), sizeof(name), (dval), (flags), module_number TSRMLS_CC) -#define REGISTER_STRING_CONSTANT(name, str, flags) zend_register_string_constant((name), sizeof(name), (str), (flags), module_number TSRMLS_CC) -#define REGISTER_STRINGL_CONSTANT(name, str, len, flags) zend_register_stringl_constant((name), sizeof(name), (str), (len), (flags), module_number TSRMLS_CC) +#define REGISTER_NULL_CONSTANT(name, flags) zend_register_null_constant((name), sizeof(name)-1, (flags), module_number TSRMLS_CC) +#define REGISTER_BOOL_CONSTANT(name, bval, flags) zend_register_bool_constant((name), sizeof(name)-1, (bval), (flags), module_number TSRMLS_CC) +#define REGISTER_LONG_CONSTANT(name, lval, flags) zend_register_long_constant((name), sizeof(name)-1, (lval), (flags), module_number TSRMLS_CC) +#define REGISTER_DOUBLE_CONSTANT(name, dval, flags) zend_register_double_constant((name), sizeof(name)-1, (dval), (flags), module_number TSRMLS_CC) +#define REGISTER_STRING_CONSTANT(name, str, flags) zend_register_string_constant((name), sizeof(name)-1, (str), (flags), module_number TSRMLS_CC) +#define REGISTER_STRINGL_CONSTANT(name, str, len, flags) zend_register_stringl_constant((name), sizeof(name)-1, (str), (len), (flags), module_number TSRMLS_CC) #define REGISTER_NS_NULL_CONSTANT(ns, name, flags) zend_register_null_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (flags), module_number TSRMLS_CC) #define REGISTER_NS_BOOL_CONSTANT(ns, name, bval, flags) zend_register_bool_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (bval), (flags), module_number TSRMLS_CC) @@ -51,16 +51,16 @@ typedef struct _zend_constant { #define REGISTER_NS_STRING_CONSTANT(ns, name, str, flags) zend_register_string_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (str), (flags), module_number TSRMLS_CC) #define REGISTER_NS_STRINGL_CONSTANT(ns, name, str, len, flags) zend_register_stringl_constant(ZEND_NS_NAME(ns, name), sizeof(ZEND_NS_NAME(ns, name)), (str), (len), (flags), module_number TSRMLS_CC) -#define REGISTER_MAIN_NULL_CONSTANT(name, flags) zend_register_null_constant((name), sizeof(name), (flags), 0 TSRMLS_CC) -#define REGISTER_MAIN_BOOL_CONSTANT(name, bval, flags) zend_register_bool_constant((name), sizeof(name), (bval), (flags), 0 TSRMLS_CC) -#define REGISTER_MAIN_LONG_CONSTANT(name, lval, flags) zend_register_long_constant((name), sizeof(name), (lval), (flags), 0 TSRMLS_CC) -#define REGISTER_MAIN_DOUBLE_CONSTANT(name, dval, flags) zend_register_double_constant((name), sizeof(name), (dval), (flags), 0 TSRMLS_CC) -#define REGISTER_MAIN_STRING_CONSTANT(name, str, flags) zend_register_string_constant((name), sizeof(name), (str), (flags), 0 TSRMLS_CC) -#define REGISTER_MAIN_STRINGL_CONSTANT(name, str, len, flags) zend_register_stringl_constant((name), sizeof(name), (str), (len), (flags), 0 TSRMLS_CC) +#define REGISTER_MAIN_NULL_CONSTANT(name, flags) zend_register_null_constant((name), sizeof(name)-1, (flags), 0 TSRMLS_CC) +#define REGISTER_MAIN_BOOL_CONSTANT(name, bval, flags) zend_register_bool_constant((name), sizeof(name)-1, (bval), (flags), 0 TSRMLS_CC) +#define REGISTER_MAIN_LONG_CONSTANT(name, lval, flags) zend_register_long_constant((name), sizeof(name)-1, (lval), (flags), 0 TSRMLS_CC) +#define REGISTER_MAIN_DOUBLE_CONSTANT(name, dval, flags) zend_register_double_constant((name), sizeof(name)-1, (dval), (flags), 0 TSRMLS_CC) +#define REGISTER_MAIN_STRING_CONSTANT(name, str, flags) zend_register_string_constant((name), sizeof(name)-1, (str), (flags), 0 TSRMLS_CC) +#define REGISTER_MAIN_STRINGL_CONSTANT(name, str, len, flags) zend_register_stringl_constant((name), sizeof(name)-1, (str), (len), (flags), 0 TSRMLS_CC) BEGIN_EXTERN_C() void clean_module_constants(int module_number TSRMLS_DC); -void free_zend_constant(zend_constant *c); +void free_zend_constant(zval *zv); int zend_startup_constants(TSRMLS_D); int zend_shutdown_constants(TSRMLS_D); void zend_register_standard_constants(TSRMLS_D); @@ -78,7 +78,7 @@ void zend_copy_constants(HashTable *target, HashTable *sourc); zend_constant *zend_quick_get_constant(const zend_literal *key, ulong flags TSRMLS_DC); END_EXTERN_C() -#define ZEND_CONSTANT_DTOR (void (*)(zval *)) free_zend_constant +#define ZEND_CONSTANT_DTOR free_zend_constant #endif diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 14f060d0c7..08df347770 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -658,7 +658,7 @@ static inline int zend_assign_to_string_offset(zval *str_offset, zval *value, in } if (offset >= str->len) { - str = STR_EREALLOC(str, offset + 1); + str = STR_REALLOC(str, offset + 1, 0); memset(str->val + str->len, ' ', offset - str->len); str->val[offset+1] = 0; } else if (IS_INTERNED(str)) { diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h index 8ad16de2d8..5a287e0570 100644 --- a/Zend/zend_execute.h +++ b/Zend/zend_execute.h @@ -76,7 +76,7 @@ static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC if (!Z_DELREF_P(zval_ptr)) { ZEND_ASSERT(zval_ptr != &EG(uninitialized_zval)); GC_REMOVE_ZVAL_FROM_BUFFER(zval_ptr); - zval_dtor(zval_ptr); + _zval_dtor_func_for_ptr(zval_ptr ZEND_FILE_LINE_CC); } else { if (Z_REFCOUNT_P(zval_ptr) == 1 && Z_TYPE_P(zval_ptr) == IS_REFERENCE) { /* convert reference to regular value */ @@ -95,7 +95,7 @@ static zend_always_inline void i_zval_ptr_dtor_nogc(zval *zval_ptr ZEND_FILE_LIN if (!Z_DELREF_P(zval_ptr)) { ZEND_ASSERT(zval_ptr != &EG(uninitialized_zval)); GC_REMOVE_ZVAL_FROM_BUFFER(zval_ptr); - zval_dtor(zval_ptr); + _zval_dtor_func_for_ptr(zval_ptr ZEND_FILE_LINE_CC); } else { if (Z_REFCOUNT_P(zval_ptr) == 1 && Z_TYPE_P(zval_ptr) == IS_REFERENCE) { /* convert reference to regular value */ diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c index 7176c1f147..32a2a7545a 100644 --- a/Zend/zend_execute_API.c +++ b/Zend/zend_execute_API.c @@ -152,7 +152,7 @@ void init_executor(TSRMLS_D) /* {{{ */ EG(error_handling) = EH_NORMAL; zend_vm_stack_init(TSRMLS_C); - zend_vm_stack_push((void *) NULL TSRMLS_CC); +//??? zend_vm_stack_push((void *) NULL TSRMLS_CC); zend_hash_init(&EG(symbol_table).ht, 50, NULL, ZVAL_PTR_DTOR, 0); EG(active_symbol_table) = &EG(symbol_table).ht; @@ -426,15 +426,16 @@ ZEND_API void _zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ */ ZEND_API void _zval_internal_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ */ { - Z_DELREF_P(zval_ptr); - if (Z_REFCOUNT_P(zval_ptr) == 0) { - zval_internal_dtor(zval_ptr); - } else if (Z_REFCOUNT_P(zval_ptr) == 1) { -//??? Z_UNSET_ISREF_P(zval_ptr); - if (Z_ISREF_P(zval_ptr)) { - zend_reference *ref = Z_REF_P(zval_ptr); - ZVAL_COPY_VALUE(zval_ptr, Z_REFVAL_P(zval_ptr)); - efree(ref); + if (IS_REFCOUNTED(Z_TYPE_P(zval_ptr))) { + Z_DELREF_P(zval_ptr); + if (Z_REFCOUNT_P(zval_ptr) == 0) { + _zval_internal_dtor_for_ptr(zval_ptr ZEND_FILE_LINE_CC); + } else if (Z_REFCOUNT_P(zval_ptr) == 1) { + if (Z_ISREF_P(zval_ptr)) { + zend_reference *ref = Z_REF_P(zval_ptr); + ZVAL_COPY_VALUE(zval_ptr, Z_REFVAL_P(zval_ptr)); + efree(ref); + } } } } @@ -563,7 +564,7 @@ ZEND_API int zval_update_constant_ex(zval *p, void *arg, zend_class_entry *scope HashTable *ht = Z_ARRVAL_P(p); ZVAL_NEW_ARR(p); zend_hash_init(Z_ARRVAL_P(p), zend_hash_num_elements(ht), NULL, ZVAL_PTR_DTOR, 0); - zend_hash_copy(Z_ARRVAL_P(p), ht, (copy_ctor_func_t) zval_deep_copy); + zend_hash_copy(Z_ARRVAL_P(p), ht, zval_deep_copy); } /* First go over the array and see if there are any constant indices */ diff --git a/Zend/zend_ini.c b/Zend/zend_ini.c index a4adb46639..882049830b 100644 --- a/Zend/zend_ini.c +++ b/Zend/zend_ini.c @@ -83,6 +83,12 @@ static int zend_restore_ini_entry_wrapper(zend_ini_entry **ini_entry TSRMLS_DC) } /* }}} */ +static void _free_ptr(zval *zv) /* {{{ */ +{ + free(Z_PTR_P(zv)); +} +/* }}} */ + /* * Startup / shutdown */ @@ -93,7 +99,7 @@ ZEND_API int zend_ini_startup(TSRMLS_D) /* {{{ */ EG(ini_directives) = registered_zend_ini_directives; EG(modified_ini_directives) = NULL; EG(error_reporting_ini_entry) = NULL; - if (zend_hash_init_ex(registered_zend_ini_directives, 100, NULL, NULL, 1, 0) == FAILURE) { + if (zend_hash_init_ex(registered_zend_ini_directives, 100, NULL, _free_ptr, 1, 0) == FAILURE) { return FAILURE; } return SUCCESS; diff --git a/Zend/zend_ini_parser.y b/Zend/zend_ini_parser.y index 37943bc222..268f21bb86 100644 --- a/Zend/zend_ini_parser.y +++ b/Zend/zend_ini_parser.y @@ -99,11 +99,11 @@ static void zend_ini_init_string(zval *result) */ static void zend_ini_add_string(zval *result, zval *op1, zval *op2) { - int length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2); + int op1_len = Z_STRLEN_P(op1); + int length = op1_len + Z_STRLEN_P(op2); - ZVAL_STR(result, STR_ALLOC(length, 1)); - memcpy(Z_STRVAL_P(result), Z_STRVAL_P(op1), Z_STRLEN_P(op1)); - memcpy(Z_STRVAL_P(result)+Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2)); + ZVAL_STR(result, STR_REALLOC(Z_STR_P(op1), length, 1)); + memcpy(Z_STRVAL_P(result)+op1_len, Z_STRVAL_P(op2), Z_STRLEN_P(op2)); Z_STRVAL_P(result)[length] = 0; } /* }}} */ @@ -273,26 +273,26 @@ statement: printf("SECTION: [%s]\n", Z_STRVAL($2)); #endif ZEND_INI_PARSER_CB(&$2, NULL, NULL, ZEND_INI_PARSER_SECTION, ZEND_INI_PARSER_ARG TSRMLS_CC); - STR_FREE(Z_STR($2)); + STR_RELEASE(Z_STR($2)); } | TC_LABEL '=' string_or_value { #if DEBUG_CFG_PARSER printf("NORMAL: '%s' = '%s'\n", Z_STRVAL($1), Z_STRVAL($3)); #endif ZEND_INI_PARSER_CB(&$1, &$3, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC); - STR_FREE(Z_STR($1)); - STR_FREE(Z_STR($3)); + STR_RELEASE(Z_STR($1)); + STR_RELEASE(Z_STR($3)); } | TC_OFFSET option_offset ']' '=' string_or_value { #if DEBUG_CFG_PARSER printf("OFFSET: '%s'[%s] = '%s'\n", Z_STRVAL($1), Z_STRVAL($2), Z_STRVAL($5)); #endif ZEND_INI_PARSER_CB(&$1, &$5, &$2, ZEND_INI_PARSER_POP_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC); - STR_FREE(Z_STR($1)); - STR_FREE(Z_STR($2)); - STR_FREE(Z_STR($5)); + STR_RELEASE(Z_STR($1)); + STR_RELEASE(Z_STR($2)); + STR_RELEASE(Z_STR($5)); } - | TC_LABEL { ZEND_INI_PARSER_CB(&$1, NULL, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC); STR_FREE(Z_STR($1)); } + | TC_LABEL { ZEND_INI_PARSER_CB(&$1, NULL, NULL, ZEND_INI_PARSER_ENTRY, ZEND_INI_PARSER_ARG TSRMLS_CC); STR_RELEASE(Z_STR($1)); } | END_OF_LINE ; diff --git a/Zend/zend_language_scanner.c b/Zend/zend_language_scanner.c index 67ac83ca17..4e30fccdac 100644 --- a/Zend/zend_language_scanner.c +++ b/Zend/zend_language_scanner.c @@ -653,7 +653,7 @@ ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_D /* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */ if (Z_REFCOUNT_P(str) == 1) { - Z_STR_P(str) = STR_EREALLOC(Z_STR_P(str), Z_STRLEN_P(str) + ZEND_MMAP_AHEAD); + Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), Z_STRLEN_P(str) + ZEND_MMAP_AHEAD, 0); } else { zend_string *tmp; @@ -4184,7 +4184,7 @@ yy318: zend_dirname(dirname->val, dirname->len); if (strcmp(dirname->val, ".") == 0) { - dirname = STR_EREALLOC(dirname, MAXPATHLEN); + dirname = STR_REALLOC(dirname, MAXPATHLEN, 0); #if HAVE_GETCWD VCWD_GETCWD(dirname->val, MAXPATHLEN); #elif HAVE_GETWD diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index e7c2837dd2..b315307d89 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -651,7 +651,7 @@ ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_D /* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */ if (Z_REFCOUNT_P(str) == 1) { - Z_STR_P(str) = STR_EREALLOC(Z_STR_P(str), Z_STRLEN_P(str) + ZEND_MMAP_AHEAD); + Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), Z_STRLEN_P(str) + ZEND_MMAP_AHEAD, 0); } else { zend_string *tmp; @@ -1658,7 +1658,7 @@ NEWLINE ("\r"|"\n"|"\r\n") zend_dirname(dirname->val, dirname->len); if (strcmp(dirname->val, ".") == 0) { - dirname = STR_EREALLOC(dirname, MAXPATHLEN); + dirname = STR_REALLOC(dirname, MAXPATHLEN, 0); #if HAVE_GETCWD VCWD_GETCWD(dirname->val, MAXPATHLEN); #elif HAVE_GETWD diff --git a/Zend/zend_list.c b/Zend/zend_list.c index 59a561f6e6..3dbe72c030 100644 --- a/Zend/zend_list.c +++ b/Zend/zend_list.c @@ -145,6 +145,7 @@ void list_entry_destructor(zval *zv) } else { zend_error(E_WARNING,"Unknown list entry type in request shutdown (%d)", res->type); } + efree(res); } void plist_entry_destructor(zval *zv) @@ -171,6 +172,7 @@ void plist_entry_destructor(zval *zv) } else { zend_error(E_WARNING,"Unknown persistent list entry type in module shutdown (%d)", res->type); } + free(res); } int zend_init_rsrc_list(TSRMLS_D) @@ -228,7 +230,7 @@ ZEND_API int zend_register_list_destructors(void (*ld)(void *), void (*pld)(void zend_rsrc_list_dtors_entry *lde; zval zv; - lde = emalloc(sizeof(zend_rsrc_list_dtors_entry)); + lde = malloc(sizeof(zend_rsrc_list_dtors_entry)); lde->list_dtor=(void (*)(void *)) ld; lde->plist_dtor=(void (*)(void *)) pld; lde->list_dtor_ex = lde->plist_dtor_ex = NULL; @@ -250,7 +252,7 @@ ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_fu zend_rsrc_list_dtors_entry *lde; zval zv; - lde = emalloc(sizeof(zend_rsrc_list_dtors_entry)); + lde = malloc(sizeof(zend_rsrc_list_dtors_entry)); lde->list_dtor = NULL; lde->plist_dtor = NULL; lde->list_dtor_ex = ld; @@ -283,11 +285,16 @@ ZEND_API int zend_fetch_list_dtor_id(const char *type_name) return 0; } +static void list_destructors_dtor(zval *zv) +{ + free(Z_PTR_P(zv)); +} + int zend_init_rsrc_list_dtors(void) { int retval; - retval = zend_hash_init(&list_destructors, 50, NULL, NULL, 1); + retval = zend_hash_init(&list_destructors, 50, NULL, list_destructors_dtor, 1); list_destructors.nNextFreeElement=1; /* we don't want resource type 0 */ return retval; diff --git a/Zend/zend_modules.h b/Zend/zend_modules.h index fbd4087ec2..283b069f48 100644 --- a/Zend/zend_modules.h +++ b/Zend/zend_modules.h @@ -125,11 +125,9 @@ struct _zend_module_dep { extern ZEND_API HashTable module_registry; void module_destructor(zend_module_entry *module); -int module_registry_cleanup(zend_module_entry *module TSRMLS_DC); int module_registry_request_startup(zend_module_entry *module TSRMLS_DC); int module_registry_unload_temp(const zend_module_entry *module TSRMLS_DC); -#define ZEND_MODULE_DTOR (void (*)(zval *)) module_destructor #endif /* diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 4fb41e794f..8a9b26d3e7 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -120,11 +120,13 @@ ZEND_API void destroy_zend_function(zend_function *function TSRMLS_DC) } } -ZEND_API void zend_function_dtor(zend_function *function) +ZEND_API void zend_function_dtor(zval *zv) { + zend_function *function = Z_PTR_P(zv); TSRMLS_FETCH(); destroy_zend_function(function TSRMLS_CC); + pefree(function, function->type == ZEND_INTERNAL_FUNCTION); } static void zend_cleanup_op_array_data(zend_op_array *op_array) @@ -267,9 +269,9 @@ void _destroy_zend_class_traits_info(zend_class_entry *ce) } } -ZEND_API void destroy_zend_class(zend_class_entry **pce) +ZEND_API void destroy_zend_class(zval *zv) { - zend_class_entry *ce = *pce; + zend_class_entry *ce = Z_PTR_P(zv); if (--ce->refcount > 0) { return; @@ -342,9 +344,11 @@ ZEND_API void destroy_zend_class(zend_class_entry **pce) } } -void zend_class_add_ref(zend_class_entry **ce) +void zend_class_add_ref(zval *zv) { - (*ce)->refcount++; + zend_class_entry *ce = Z_PTR_P(zv); + + ce->refcount++; } ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC) diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c index f0e3a5f98f..5a61c1bea0 100644 --- a/Zend/zend_operators.c +++ b/Zend/zend_operators.c @@ -1302,7 +1302,7 @@ ZEND_API int shift_right_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2) /* {{{ */ { int length = Z_STRLEN_P(op1) + 1; - zend_string *buf = STR_EREALLOC(Z_STR_P(op1), length + 1); + zend_string *buf = STR_REALLOC(Z_STR_P(op1), length + 1, 0); buf->val[length - 1] = (char) Z_LVAL_P(op2); buf->val[length] = 0; @@ -1315,7 +1315,7 @@ ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2) ZEND_API int add_string_to_string(zval *result, const zval *op1, const zval *op2) /* {{{ */ { int length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2); - zend_string *buf = STR_EREALLOC(Z_STR_P(op1), length + 1); + zend_string *buf = STR_REALLOC(Z_STR_P(op1), length + 1, 0); memcpy(buf->val + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2)); buf->val[length] = 0; @@ -1360,7 +1360,7 @@ ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{ zend_error(E_ERROR, "String size overflow"); } - Z_STR_P(result) = STR_EREALLOC(Z_STR_P(result), res_len+1); + Z_STR_P(result) = STR_REALLOC(Z_STR_P(result), res_len+1, 0 ); memcpy(Z_STRVAL_P(result)+Z_STRLEN_P(result), Z_STRVAL_P(op2), Z_STRLEN_P(op2)); Z_STRVAL_P(result)[res_len]=0; diff --git a/Zend/zend_string.c b/Zend/zend_string.c index 05cd6a2d19..0fda838983 100644 --- a/Zend/zend_string.c +++ b/Zend/zend_string.c @@ -34,12 +34,19 @@ ZEND_API zend_ulong zend_hash_func(const char *str, uint len) return zend_inline_hash_func(str, len); } +static void _str_dtor(zval *zv) +{ + zend_string *str = Z_STR_P(zv); + str->gc.u.v.flags &= ~IS_STR_INTERNED; + str->gc.refcount = 1; +} + void zend_interned_strings_init(TSRMLS_D) { #ifndef ZTS zend_string *str; - zend_hash_init(&CG(interned_strings), 0, NULL, NULL, 1); + zend_hash_init(&CG(interned_strings), 0, NULL, _str_dtor, 1); CG(interned_strings).nTableMask = CG(interned_strings).nTableSize - 1; CG(interned_strings).arData = (Bucket*) pecalloc(CG(interned_strings).nTableSize, sizeof(Bucket), CG(interned_strings).flags & HASH_FLAG_PERSISTENT); @@ -65,8 +72,9 @@ void zend_interned_strings_init(TSRMLS_D) void zend_interned_strings_dtor(TSRMLS_D) { #ifndef ZTS - free(CG(interned_strings).arData); - free(CG(interned_strings).arHash); + zend_hash_destroy(&CG(interned_strings)); +//??? free(CG(interned_strings).arData); +//??? free(CG(interned_strings).arHash); #endif } @@ -89,9 +97,7 @@ static zend_string *zend_new_interned_string_int(zend_string *str TSRMLS_DC) p = CG(interned_strings).arData + idx; if ((p->h == h) && (p->key->len == str->len)) { if (!memcmp(p->key->val, str->val, str->len)) { -//??? if (free_src) { -//??? efree((void *)arKey); -//??? } + STR_RELEASE(str); return p->key; } } @@ -166,6 +172,7 @@ static void zend_interned_strings_snapshot_int(TSRMLS_D) while (idx > 0) { idx--; p = CG(interned_strings).arData + idx; + ZEND_ASSERT(p->key->gc.u.v.flags & IS_STR_PERSISTENT); p->key->gc.u.v.flags |= IS_STR_PERMANENT; } #endif diff --git a/Zend/zend_string.h b/Zend/zend_string.h index 67490d7a95..55db943994 100644 --- a/Zend/zend_string.h +++ b/Zend/zend_string.h @@ -51,7 +51,7 @@ END_EXTERN_C() #define STR_INIT(str, len, persistent) zend_str_init(str, len, persistent) #define STR_COPY(s) zend_str_copy(s) #define STR_DUP(s, persistent) zend_str_dup(s, persistent) -#define STR_EREALLOC(s, len) zend_str_erealloc(s, len) +#define STR_REALLOC(s, len, persistent) zend_str_realloc(s, len, persistent) #define STR_FREE(s) zend_str_free(s) #define STR_RELEASE(s) zend_str_release(s) #define STR_EMPTY_ALLOC() CG(empty_string) @@ -100,6 +100,7 @@ static zend_always_inline zend_string *zend_str_alloc(int len, int persistent) ret->gc.refcount = 1; ret->gc.u.v.type = IS_STRING; ret->gc.u.v.flags = (persistent ? IS_STR_PERSISTENT : 0); + ret->gc.u.v.buffer = 0; ret->h = 0; ret->len = len; return ret; @@ -130,19 +131,19 @@ static zend_always_inline zend_string *zend_str_dup(zend_string *s, int persiste } } -static zend_always_inline zend_string *zend_str_erealloc(zend_string *s, int len) +static zend_always_inline zend_string *zend_str_realloc(zend_string *s, int len, int persistent) { zend_string *ret; if (IS_INTERNED(s)) { - ret = STR_ALLOC(len, 0); + ret = STR_ALLOC(len, persistent); memcpy(ret->val, s->val, (len > s->len ? s->len : len) + 1); } else if (STR_REFCOUNT(s) == 1) { - ret = erealloc(s, sizeof(zend_string) + len); + ret = perealloc(s, sizeof(zend_string) + len, persistent); ret->len = len; STR_FORGET_HASH_VAL(ret); } else { - ret = STR_ALLOC(len, 0); + ret = STR_ALLOC(len, persistent); memcpy(ret->val, s->val, (len > s->len ? s->len : len) + 1); STR_DELREF(s); } @@ -152,6 +153,7 @@ static zend_always_inline zend_string *zend_str_erealloc(zend_string *s, int len static zend_always_inline void zend_str_free(zend_string *s) { if (!IS_INTERNED(s)) { + ZEND_ASSERT(STR_REFCOUNT(s) <= 1); pefree(s, s->gc.u.v.flags & IS_STR_PERSISTENT); } } @@ -160,7 +162,7 @@ static zend_always_inline void zend_str_release(zend_string *s) { if (!IS_INTERNED(s)) { if (STR_DELREF(s) == 0) { - STR_FREE(s); + pefree(s, s->gc.u.v.flags & IS_STR_PERSISTENT); } } } diff --git a/Zend/zend_types.h b/Zend/zend_types.h index 5d143ed11d..5591c285b0 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -416,6 +416,7 @@ struct _zend_ast_ref { zend_resource *_res = emalloc(sizeof(zend_resource)); \ _res->gc.refcount = 1; \ _res->gc.u.v.type = IS_RESOURCE; \ + _res->gc.u.v.buffer = 0; \ _res->handle = (h); \ _res->type = (t); \ _res->ptr = (p); \ @@ -428,6 +429,7 @@ struct _zend_ast_ref { zend_resource *_res = malloc(sizeof(zend_resource)); \ _res->gc.refcount = 1; \ _res->gc.u.v.type = IS_RESOURCE; \ + _res->gc.u.v.buffer = 0; \ _res->handle = (h); \ _res->type = (t); \ _res->ptr = (p); \ @@ -446,6 +448,7 @@ struct _zend_ast_ref { zend_reference *_ref = emalloc(sizeof(zend_reference)); \ _ref->gc.refcount = 1; \ _ref->gc.u.v.type = IS_REFERENCE; \ + _ref->gc.u.v.buffer = 0; \ _ref->val = *(r); \ Z_REF_P(z) = _ref; \ Z_TYPE_P(z) = IS_REFERENCE; \ @@ -456,6 +459,7 @@ struct _zend_ast_ref { zend_ast_ref *_ast = emalloc(sizeof(zend_ast_ref)); \ _ast->gc.refcount = 1; \ _ast->gc.u.v.type = IS_CONSTANT_AST; \ + _ast->gc.u.v.buffer = 0; \ _ast->ast = (a); \ Z_AST_P(__z) = _ast; \ Z_TYPE_P(__z) = IS_CONSTANT_AST; \ @@ -485,6 +489,7 @@ struct _zend_ast_ref { zend_str_offset *x = emalloc(sizeof(zend_str_offset)); \ x->gc.refcount = 1; \ x->gc.u.v.type = IS_STR_OFFSET; \ + x->gc.u.v.buffer = 0; \ x->str = (s); \ x->offset = (o); \ Z_STR_OFFSET_P(z) = x; \ diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c index 6c4076a4e4..b9fc79ff35 100644 --- a/Zend/zend_variables.c +++ b/Zend/zend_variables.c @@ -33,7 +33,7 @@ ZEND_API void _zval_dtor_func(zval *zvalue ZEND_FILE_LINE_DC) case IS_STRING: case IS_CONSTANT: CHECK_ZVAL_STRING_REL(zvalue); - STR_FREE(Z_STR_P(zvalue)); + STR_RELEASE(Z_STR_P(zvalue)); break; case IS_ARRAY: case IS_CONSTANT_ARRAY: { @@ -78,6 +78,54 @@ ZEND_API void _zval_dtor_func(zval *zvalue ZEND_FILE_LINE_DC) } } +ZEND_API void _zval_dtor_func_for_ptr(zval *zvalue ZEND_FILE_LINE_DC) +{ + switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) { + case IS_STRING: + case IS_CONSTANT: + CHECK_ZVAL_STRING_REL(zvalue); + STR_FREE(Z_STR_P(zvalue)); + break; + case IS_ARRAY: + case IS_CONSTANT_ARRAY: { + TSRMLS_FETCH(); + + if (Z_ARRVAL_P(zvalue) != &EG(symbol_table).ht) { + /* break possible cycles */ + Z_TYPE_P(zvalue) = IS_NULL; + zend_hash_destroy(Z_ARRVAL_P(zvalue)); + efree(Z_ARR_P(zvalue)); + } + } + break; + case IS_CONSTANT_AST: + zend_ast_destroy(Z_AST_P(zvalue)->ast); + efree(Z_AST_P(zvalue)); + break; + case IS_OBJECT: + { + TSRMLS_FETCH(); + + zend_objects_store_del(Z_OBJ_P(zvalue) TSRMLS_CC); + } + break; + case IS_RESOURCE: + { + TSRMLS_FETCH(); + + /* destroy resource */ + zend_list_delete(Z_RES_P(zvalue)); + } + break; + case IS_LONG: + case IS_DOUBLE: + case IS_BOOL: + case IS_NULL: + default: + return; + break; + } +} ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC) { @@ -85,7 +133,7 @@ ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC) case IS_STRING: case IS_CONSTANT: CHECK_ZVAL_STRING_REL(zvalue); - STR_FREE(Z_STR_P(zvalue)); + STR_RELEASE(Z_STR_P(zvalue)); break; case IS_ARRAY: case IS_CONSTANT_ARRAY: @@ -103,6 +151,29 @@ ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC) } } +ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC) +{ + switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) { + case IS_STRING: + case IS_CONSTANT: + CHECK_ZVAL_STRING_REL(zvalue); + STR_FREE(Z_STR_P(zvalue)); + break; + case IS_ARRAY: + case IS_CONSTANT_ARRAY: + case IS_CONSTANT_AST: + case IS_OBJECT: + case IS_RESOURCE: + zend_error(E_CORE_ERROR, "Internal zval's can't be arrays, objects or resources"); + break; + case IS_LONG: + case IS_DOUBLE: + case IS_BOOL: + case IS_NULL: + default: + break; + } +} ZEND_API void zval_add_ref(zval *p) { @@ -130,7 +201,7 @@ ZEND_API void _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC) } ZVAL_NEW_ARR(zvalue); zend_hash_init(Z_ARRVAL_P(zvalue), zend_hash_num_elements(ht), NULL, ZVAL_PTR_DTOR, 0); - zend_hash_copy(Z_ARRVAL_P(zvalue), ht, (copy_ctor_func_t) zval_add_ref); + zend_hash_copy(Z_ARRVAL_P(zvalue), ht, zval_add_ref); } break; case IS_CONSTANT_AST: { diff --git a/Zend/zend_variables.h b/Zend/zend_variables.h index 9ce1312b0d..ab5c5b38b8 100644 --- a/Zend/zend_variables.h +++ b/Zend/zend_variables.h @@ -26,6 +26,7 @@ BEGIN_EXTERN_C() ZEND_API void _zval_dtor_func(zval *zvalue ZEND_FILE_LINE_DC); +ZEND_API void _zval_dtor_func_for_ptr(zval *zvalue ZEND_FILE_LINE_DC); static zend_always_inline void _zval_dtor(zval *zvalue ZEND_FILE_LINE_DC) { @@ -49,6 +50,7 @@ ZEND_API int zval_copy_static_var(zval *p TSRMLS_DC, int num_args, va_list args, ZEND_API int zend_print_variable(zval *var); ZEND_API void _zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC); +ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC); ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC); ZEND_API void _zval_internal_ptr_dtor(zval *zvalue ZEND_FILE_LINE_DC); ZEND_API void _zval_dtor_wrapper(zval *zvalue); diff --git a/ext/spl/php_spl.c b/ext/spl/php_spl.c index 35b6e549f2..238b7574a0 100644 --- a/ext/spl/php_spl.c +++ b/ext/spl/php_spl.c @@ -573,7 +573,7 @@ PHP_FUNCTION(spl_autoload_register) if (obj_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) { /* add object id to the hash to ensure uniqueness, for more reference look at bug #40091 */ - STR_EREALLOC(lc_name, lc_name->len + 2 + sizeof(zend_uint)); + STR_REALLOC(lc_name, lc_name->len + 2 + sizeof(zend_uint), 0); memcpy(lc_name->val + lc_name->len - 2 - sizeof(zend_uint), &Z_OBJ_HANDLE_P(obj_ptr), sizeof(zend_uint)); lc_name->val[lc_name->len] = '\0'; alfi.obj = obj_ptr; @@ -685,7 +685,7 @@ PHP_FUNCTION(spl_autoload_unregister) /* remove specific */ success = zend_hash_del(SPL_G(autoload_functions), lc_name); if (success != SUCCESS && obj_ptr) { - STR_EREALLOC(lc_name, lc_name->len + 2 + sizeof(zend_uint)); + STR_REALLOC(lc_name, lc_name->len + 2 + sizeof(zend_uint), 0); memcpy(lc_name->val + lc_name->len - 2 - sizeof(zend_uint), &Z_OBJ_HANDLE_P(obj_ptr), sizeof(zend_uint)); lc_name->val[lc_name->len] = '\0'; success = zend_hash_del(SPL_G(autoload_functions), lc_name); diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c index 903ca7882f..ec28e2e4fd 100644 --- a/ext/spl/spl_array.c +++ b/ext/spl/spl_array.c @@ -784,8 +784,7 @@ static HashTable *spl_array_get_properties(zval *object TSRMLS_DC) /* {{{ */ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* {{{ */ { zval *storage; - int name_len; - char *zname; + zend_string *zname; zend_class_entry *base; spl_array_object *intern = (spl_array_object*)Z_OBJ_P(obj); @@ -811,9 +810,9 @@ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* zval_add_ref(storage); base = (Z_OBJ_HT_P(obj) == &spl_handler_ArrayIterator) ? spl_ce_ArrayIterator : spl_ce_ArrayObject; - zname = spl_gen_private_prop_name(base, "storage", sizeof("storage")-1, &name_len TSRMLS_CC); - zend_symtable_str_update(intern->debug_info, zname, name_len, storage); - efree(zname); + zname = spl_gen_private_prop_name(base, "storage", sizeof("storage")-1 TSRMLS_CC); + zend_symtable_update(intern->debug_info, zname, storage); + STR_RELEASE(zname); } return intern->debug_info; diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c index f2093d9cb4..0d2621c6ed 100644 --- a/ext/spl/spl_directory.c +++ b/ext/spl/spl_directory.c @@ -586,8 +586,9 @@ static HashTable *spl_filesystem_object_get_debug_info(zval *obj, int *is_temp T spl_filesystem_object *intern = (spl_filesystem_object*)Z_OBJ_P(obj); zval tmp; HashTable *rv; - char *pnstr, *path; - int pnlen, path_len; + zend_string *pnstr; + char *path; + int path_len; char stmp[2]; *is_temp = 1; @@ -601,14 +602,14 @@ static HashTable *spl_filesystem_object_get_debug_info(zval *obj, int *is_temp T zend_hash_copy(rv, intern->std.properties, (copy_ctor_func_t) zval_add_ref); - pnstr = spl_gen_private_prop_name(spl_ce_SplFileInfo, "pathName", sizeof("pathName")-1, &pnlen TSRMLS_CC); + pnstr = spl_gen_private_prop_name(spl_ce_SplFileInfo, "pathName", sizeof("pathName")-1 TSRMLS_CC); path = spl_filesystem_object_get_pathname(intern, &path_len TSRMLS_CC); ZVAL_STRINGL(&tmp, path, path_len); - zend_symtable_str_update(rv, pnstr, pnlen, &tmp); - efree(pnstr); + zend_symtable_update(rv, pnstr, &tmp); + STR_RELEASE(pnstr); if (intern->file_name) { - pnstr = spl_gen_private_prop_name(spl_ce_SplFileInfo, "fileName", sizeof("fileName")-1, &pnlen TSRMLS_CC); + pnstr = spl_gen_private_prop_name(spl_ce_SplFileInfo, "fileName", sizeof("fileName")-1 TSRMLS_CC); spl_filesystem_object_get_path(intern, &path_len TSRMLS_CC); if (path_len && path_len < intern->file_name_len) { @@ -616,45 +617,45 @@ static HashTable *spl_filesystem_object_get_debug_info(zval *obj, int *is_temp T } else { ZVAL_STRINGL(&tmp, intern->file_name, intern->file_name_len); } - zend_symtable_str_update(rv, pnstr, pnlen, &tmp); - efree(pnstr); + zend_symtable_update(rv, pnstr, &tmp); + STR_RELEASE(pnstr); } if (intern->type == SPL_FS_DIR) { #ifdef HAVE_GLOB - pnstr = spl_gen_private_prop_name(spl_ce_DirectoryIterator, "glob", sizeof("glob")-1, &pnlen TSRMLS_CC); + pnstr = spl_gen_private_prop_name(spl_ce_DirectoryIterator, "glob", sizeof("glob")-1 TSRMLS_CC); if (php_stream_is(intern->u.dir.dirp ,&php_glob_stream_ops)) { ZVAL_STRINGL(&tmp, intern->_path, intern->_path_len); } else { ZVAL_BOOL(&tmp, 0); } - zend_symtable_str_update(rv, pnstr, pnlen, &tmp); - efree(pnstr); + zend_symtable_update(rv, pnstr, &tmp); + STR_RELEASE(pnstr); #endif - pnstr = spl_gen_private_prop_name(spl_ce_RecursiveDirectoryIterator, "subPathName", sizeof("subPathName")-1, &pnlen TSRMLS_CC); + pnstr = spl_gen_private_prop_name(spl_ce_RecursiveDirectoryIterator, "subPathName", sizeof("subPathName")-1 TSRMLS_CC); if (intern->u.dir.sub_path) { ZVAL_STRINGL(&tmp, intern->u.dir.sub_path, intern->u.dir.sub_path_len); } else { ZVAL_STRINGL(&tmp, "", 0); } - zend_symtable_str_update(rv, pnstr, pnlen, &tmp); - efree(pnstr); + zend_symtable_update(rv, pnstr, &tmp); + STR_RELEASE(pnstr); } if (intern->type == SPL_FS_FILE) { - pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "openMode", sizeof("openMode")-1, &pnlen TSRMLS_CC); + pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "openMode", sizeof("openMode")-1 TSRMLS_CC); ZVAL_STRINGL(&tmp, intern->u.file.open_mode, intern->u.file.open_mode_len); - zend_symtable_str_update(rv, pnstr, pnlen, &tmp); - efree(pnstr); + zend_symtable_update(rv, pnstr, &tmp); + STR_RELEASE(pnstr); stmp[1] = '\0'; stmp[0] = intern->u.file.delimiter; - pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "delimiter", sizeof("delimiter")-1, &pnlen TSRMLS_CC); + pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "delimiter", sizeof("delimiter")-1 TSRMLS_CC); ZVAL_STRINGL(&tmp, stmp, 1); - zend_symtable_str_update(rv, pnstr, pnlen, &tmp); - efree(pnstr); + zend_symtable_update(rv, pnstr, &tmp); + STR_RELEASE(pnstr); stmp[0] = intern->u.file.enclosure; - pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "enclosure", sizeof("enclosure")-1, &pnlen TSRMLS_CC); + pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "enclosure", sizeof("enclosure")-1 TSRMLS_CC); ZVAL_STRINGL(&tmp, stmp, 1); - zend_symtable_str_update(rv, pnstr, pnlen, &tmp); - efree(pnstr); + zend_symtable_update(rv, pnstr, &tmp); + STR_RELEASE(pnstr); } return rv; diff --git a/ext/spl/spl_dllist.c b/ext/spl/spl_dllist.c index 1fc4f13cad..35fa40a7c1 100644 --- a/ext/spl/spl_dllist.c +++ b/ext/spl/spl_dllist.c @@ -500,8 +500,7 @@ static HashTable* spl_dllist_object_get_debug_info(zval *obj, int *is_temp TSRML spl_dllist_object *intern = (spl_dllist_object*)Z_OBJ_P(obj); spl_ptr_llist_element *current = intern->llist->head, *next; zval tmp, dllist_array; - char *pnstr; - int pnlen; + zend_string *pnstr; int i = 0; *is_temp = 0; @@ -518,10 +517,10 @@ static HashTable* spl_dllist_object_get_debug_info(zval *obj, int *is_temp TSRML } zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref); - pnstr = spl_gen_private_prop_name(spl_ce_SplDoublyLinkedList, "flags", sizeof("flags")-1, &pnlen TSRMLS_CC); + pnstr = spl_gen_private_prop_name(spl_ce_SplDoublyLinkedList, "flags", sizeof("flags")-1 TSRMLS_CC); ZVAL_LONG(&tmp, intern->flags); - zend_hash_str_add(intern->debug_info, pnstr, pnlen, &tmp); - efree(pnstr); + zend_hash_add(intern->debug_info, pnstr, &tmp); + STR_RELEASE(pnstr); array_init(&dllist_array); @@ -535,9 +534,9 @@ static HashTable* spl_dllist_object_get_debug_info(zval *obj, int *is_temp TSRML current = next; } - pnstr = spl_gen_private_prop_name(spl_ce_SplDoublyLinkedList, "dllist", sizeof("dllist")-1, &pnlen TSRMLS_CC); - zend_hash_str_add(intern->debug_info, pnstr, pnlen, &dllist_array); - efree(pnstr); + pnstr = spl_gen_private_prop_name(spl_ce_SplDoublyLinkedList, "dllist", sizeof("dllist")-1 TSRMLS_CC); + zend_hash_add(intern->debug_info, pnstr, &dllist_array); + STR_RELEASE(pnstr); } return intern->debug_info; diff --git a/ext/spl/spl_functions.c b/ext/spl/spl_functions.c index e3cf1323c3..97a9509caa 100644 --- a/ext/spl/spl_functions.c +++ b/ext/spl/spl_functions.c @@ -133,13 +133,9 @@ int spl_add_classes(zend_class_entry *pce, zval *list, int sub, int allow, int c } /* }}} */ -char * spl_gen_private_prop_name(zend_class_entry *ce, char *prop_name, int prop_len, int *name_len TSRMLS_DC) /* {{{ */ +zend_string * spl_gen_private_prop_name(zend_class_entry *ce, char *prop_name, int prop_len TSRMLS_DC) /* {{{ */ { - char *rv; - - zend_mangle_property_name(&rv, name_len, ce->name->val, ce->name->len, prop_name, prop_len, 0); - - return rv; + return zend_mangle_property_name(ce->name->val, ce->name->len, prop_name, prop_len, 0); } /* }}} */ diff --git a/ext/spl/spl_functions.h b/ext/spl/spl_functions.h index a15da36357..1d116ff783 100644 --- a/ext/spl/spl_functions.h +++ b/ext/spl/spl_functions.h @@ -66,7 +66,7 @@ void spl_add_traits(zval * list, zend_class_entry * pce, int allow, int ce_flags int spl_add_classes(zend_class_entry *pce, zval *list, int sub, int allow, int ce_flags TSRMLS_DC); /* caller must efree(return) */ -char * spl_gen_private_prop_name(zend_class_entry *ce, char *prop_name, int prop_len, int *name_len TSRMLS_DC); +zend_string *spl_gen_private_prop_name(zend_class_entry *ce, char *prop_name, int prop_len TSRMLS_DC); #define SPL_ME(class_name, function_name, arg_info, flags) \ PHP_ME( spl_ ## class_name, function_name, arg_info, flags) diff --git a/ext/spl/spl_heap.c b/ext/spl/spl_heap.c index 1520bfb401..45b50c2d25 100644 --- a/ext/spl/spl_heap.c +++ b/ext/spl/spl_heap.c @@ -508,8 +508,7 @@ static int spl_heap_object_count_elements(zval *object, long *count TSRMLS_DC) / static HashTable* spl_heap_object_get_debug_info_helper(zend_class_entry *ce, zval *obj, int *is_temp TSRMLS_DC) { /* {{{ */ spl_heap_object *intern = (spl_heap_object*)Z_OBJ_P(obj); zval tmp, heap_array; - char *pnstr; - int pnlen; + zend_string *pnstr; int i; *is_temp = 0; @@ -527,15 +526,15 @@ static HashTable* spl_heap_object_get_debug_info_helper(zend_class_entry *ce, zv zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref); - pnstr = spl_gen_private_prop_name(ce, "flags", sizeof("flags")-1, &pnlen TSRMLS_CC); + pnstr = spl_gen_private_prop_name(ce, "flags", sizeof("flags")-1 TSRMLS_CC); ZVAL_LONG(&tmp, intern->flags); - zend_hash_str_update(intern->debug_info, pnstr, pnlen, &tmp); - efree(pnstr); + zend_hash_update(intern->debug_info, pnstr, &tmp); + STR_RELEASE(pnstr); - pnstr = spl_gen_private_prop_name(ce, "isCorrupted", sizeof("isCorrupted")-1, &pnlen TSRMLS_CC); + pnstr = spl_gen_private_prop_name(ce, "isCorrupted", sizeof("isCorrupted")-1 TSRMLS_CC); ZVAL_BOOL(&tmp, intern->heap->flags&SPL_HEAP_CORRUPTED); - zend_hash_str_update(intern->debug_info, pnstr, pnlen, &tmp); - efree(pnstr); + zend_hash_update(intern->debug_info, pnstr, &tmp); + STR_RELEASE(pnstr); array_init(&heap_array); @@ -544,9 +543,9 @@ static HashTable* spl_heap_object_get_debug_info_helper(zend_class_entry *ce, zv Z_ADDREF_P(&intern->heap->elements[i]); } - pnstr = spl_gen_private_prop_name(ce, "heap", sizeof("heap")-1, &pnlen TSRMLS_CC); - zend_hash_str_update(intern->debug_info, pnstr, pnlen, &heap_array); - efree(pnstr); + pnstr = spl_gen_private_prop_name(ce, "heap", sizeof("heap")-1 TSRMLS_CC); + zend_hash_update(intern->debug_info, pnstr, &heap_array); + STR_RELEASE(pnstr); } return intern->debug_info; diff --git a/ext/spl/spl_observer.c b/ext/spl/spl_observer.c index 92baee4b0c..c91379bf20 100644 --- a/ext/spl/spl_observer.c +++ b/ext/spl/spl_observer.c @@ -303,8 +303,7 @@ static HashTable* spl_object_storage_debug_info(zval *obj, int *is_temp TSRMLS_D HashPosition pos; zval tmp, storage; char md5str[33]; - int name_len; - char *zname; + zend_string *zname; *is_temp = 0; @@ -334,9 +333,9 @@ static HashTable* spl_object_storage_debug_info(zval *obj, int *is_temp TSRMLS_D zend_hash_move_forward_ex(&intern->storage, &pos); } - zname = spl_gen_private_prop_name(spl_ce_SplObjectStorage, "storage", sizeof("storage")-1, &name_len TSRMLS_CC); - zend_symtable_str_update(intern->debug_info, zname, name_len, &storage); - efree(zname); + zname = spl_gen_private_prop_name(spl_ce_SplObjectStorage, "storage", sizeof("storage")-1 TSRMLS_CC); + zend_symtable_update(intern->debug_info, zname, &storage); + STR_RELEASE(zname); } return intern->debug_info; diff --git a/ext/standard/formatted_print.c b/ext/standard/formatted_print.c index 00ecfb2892..cc5925bee7 100644 --- a/ext/standard/formatted_print.c +++ b/ext/standard/formatted_print.c @@ -56,7 +56,7 @@ php_sprintf_appendchar(zend_string **buffer, int *pos, char add TSRMLS_DC) { if (!*buffer || (*pos + 1) >= (*buffer)->len) { PRINTF_DEBUG(("%s(): ereallocing buffer to %d bytes\n", get_active_function_name(TSRMLS_C), (*buffer)->len)); - *buffer = STR_EREALLOC(*buffer, (*buffer)->len << 1); + *buffer = STR_REALLOC(*buffer, (*buffer)->len << 1, 0); } PRINTF_DEBUG(("sprintf: appending '%c', pos=\n", add, *pos)); (*buffer)->val[(*pos)++] = add; @@ -100,7 +100,7 @@ php_sprintf_appendstring(zend_string **buffer, int *pos, char *add, size <<= 1; } PRINTF_DEBUG(("sprintf ereallocing buffer to %d bytes\n", size)); - *buffer = STR_EREALLOC(*buffer, size); + *buffer = STR_REALLOC(*buffer, size, 0); } if (alignment == ALIGN_RIGHT) { if ((neg || always_sign) && padding=='0') { diff --git a/ext/standard/html.c b/ext/standard/html.c index 402b3aaac5..8a9da90ec4 100644 --- a/ext/standard/html.c +++ b/ext/standard/html.c @@ -1277,7 +1277,7 @@ PHPAPI zend_string *php_escape_html_entities_ex(unsigned char *old, size_t oldle * In HTML5, entities may take up to 33 bytes */ if (len > maxlen - 40) { /* maxlen can never be smaller than 128 */ //??? replaced = safe_erealloc(replaced, maxlen , 1, 128 + 1); - replaced = STR_EREALLOC(replaced, maxlen + 128); + replaced = STR_REALLOC(replaced, maxlen + 128, 0); maxlen += 128; } @@ -1410,7 +1410,7 @@ encode_amp: if (maxlen - len < ent_len + 2 /* & and ; */) { /* ent_len < oldlen, which is certainly <= SIZE_MAX/2 */ //??? replaced = safe_erealloc(replaced, maxlen, 1, ent_len + 128 + 1); - replaced = STR_EREALLOC(replaced, maxlen + ent_len + 128); + replaced = STR_REALLOC(replaced, maxlen + ent_len + 128, 0); maxlen += ent_len + 128; } replaced->val[len++] = '&'; diff --git a/ext/standard/metaphone.c b/ext/standard/metaphone.c index 98f5d299ed..290b63eb91 100644 --- a/ext/standard/metaphone.c +++ b/ext/standard/metaphone.c @@ -144,7 +144,7 @@ static char Lookahead(char *word, int how_far) * could be one though; or more too). */ #define Phonize(c) { \ if (p_idx >= max_buffer_len) { \ - *phoned_word = STR_EREALLOC(*phoned_word, 1 + max_buffer_len); \ + *phoned_word = STR_REALLOC(*phoned_word, 1 + max_buffer_len, 0); \ max_buffer_len += 2; \ } \ (*phoned_word)->val[p_idx++] = c; \ @@ -153,7 +153,7 @@ static char Lookahead(char *word, int how_far) /* Slap a null character on the end of the phoned word */ #define End_Phoned_Word { \ if (p_idx == max_buffer_len) { \ - *phoned_word = STR_EREALLOC(*phoned_word, max_buffer_len); \ + *phoned_word = STR_REALLOC(*phoned_word, max_buffer_len, 0); \ } \ (*phoned_word)->val[p_idx] = '\0'; \ (*phoned_word)->len = p_idx; \ diff --git a/ext/standard/quot_print.c b/ext/standard/quot_print.c index 0738ead2fd..a1bc44fda0 100644 --- a/ext/standard/quot_print.c +++ b/ext/standard/quot_print.c @@ -188,7 +188,7 @@ PHPAPI zend_string *php_quot_print_encode(const unsigned char *str, size_t lengt } } *d = '\0'; - ret = STR_EREALLOC(ret, d - (unsigned char*)ret->val); + ret = STR_REALLOC(ret, d - (unsigned char*)ret->val, 0); return ret; } /* }}} */ diff --git a/ext/standard/url_scanner_ex.c b/ext/standard/url_scanner_ex.c index b48a52661a..08ccd0207f 100644 --- a/ext/standard/url_scanner_ex.c +++ b/ext/standard/url_scanner_ex.c @@ -44,6 +44,11 @@ #include "php_smart_str.h" +static void tag_dtor(zval *zv) +{ + free(Z_PTR_P(zv)); +} + static PHP_INI_MH(OnUpdateTags) { url_adapt_state_ex_t *ctx; @@ -64,7 +69,7 @@ static PHP_INI_MH(OnUpdateTags) } } - zend_hash_init(ctx->tags, 0, NULL, NULL, 1); + zend_hash_init(ctx->tags, 0, NULL, tag_dtor, 1); for (key = php_strtok_r(tmp, ",", &lasts); key; @@ -95,7 +100,7 @@ PHP_INI_BEGIN() STD_PHP_INI_ENTRY("url_rewriter.tags", "a=href,area=href,frame=src,form=,fieldset=", PHP_INI_ALL, OnUpdateTags, url_adapt_state_ex, php_basic_globals, basic_globals) PHP_INI_END() -#line 102 "ext/standard/url_scanner_ex.re" +#line 107 "ext/standard/url_scanner_ex.re" #define YYFILL(n) goto done @@ -114,7 +119,7 @@ static inline void append_modified_url(smart_str *url, smart_str *dest, smart_st scan: -#line 118 "ext/standard/url_scanner_ex.c" +#line 123 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -160,19 +165,19 @@ scan: if (yych <= '9') goto yy6; if (yych >= ';') goto yy4; ++YYCURSOR; -#line 120 "ext/standard/url_scanner_ex.re" +#line 125 "ext/standard/url_scanner_ex.re" { smart_str_append(dest, url); return; } -#line 166 "ext/standard/url_scanner_ex.c" +#line 171 "ext/standard/url_scanner_ex.c" yy4: ++YYCURSOR; -#line 121 "ext/standard/url_scanner_ex.re" +#line 126 "ext/standard/url_scanner_ex.re" { sep = separator; goto scan; } -#line 171 "ext/standard/url_scanner_ex.c" +#line 176 "ext/standard/url_scanner_ex.c" yy6: ++YYCURSOR; -#line 122 "ext/standard/url_scanner_ex.re" +#line 127 "ext/standard/url_scanner_ex.re" { bash = p - 1; goto done; } -#line 176 "ext/standard/url_scanner_ex.c" +#line 181 "ext/standard/url_scanner_ex.c" yy8: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -180,11 +185,11 @@ yy8: if (yybm[0+yych] & 128) { goto yy8; } -#line 123 "ext/standard/url_scanner_ex.re" +#line 128 "ext/standard/url_scanner_ex.re" { goto scan; } -#line 186 "ext/standard/url_scanner_ex.c" +#line 191 "ext/standard/url_scanner_ex.c" } -#line 124 "ext/standard/url_scanner_ex.re" +#line 129 "ext/standard/url_scanner_ex.re" done: @@ -364,7 +369,7 @@ state_plain_begin: state_plain: start = YYCURSOR; -#line 368 "ext/standard/url_scanner_ex.c" +#line 373 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -407,9 +412,9 @@ state_plain: goto yy15; } ++YYCURSOR; -#line 303 "ext/standard/url_scanner_ex.re" +#line 308 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); STATE = STATE_TAG; goto state_tag; } -#line 413 "ext/standard/url_scanner_ex.c" +#line 418 "ext/standard/url_scanner_ex.c" yy15: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -417,17 +422,17 @@ yy15: if (yybm[0+yych] & 128) { goto yy15; } -#line 304 "ext/standard/url_scanner_ex.re" +#line 309 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); goto state_plain; } -#line 423 "ext/standard/url_scanner_ex.c" +#line 428 "ext/standard/url_scanner_ex.c" } -#line 305 "ext/standard/url_scanner_ex.re" +#line 310 "ext/standard/url_scanner_ex.re" state_tag: start = YYCURSOR; -#line 431 "ext/standard/url_scanner_ex.c" +#line 436 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -478,14 +483,14 @@ yy20: yych = *YYCURSOR; goto yy25; yy21: -#line 310 "ext/standard/url_scanner_ex.re" +#line 315 "ext/standard/url_scanner_ex.re" { handle_tag(STD_ARGS); /* Sets STATE */; passthru(STD_ARGS); if (STATE == STATE_PLAIN) goto state_plain; else goto state_next_arg; } -#line 484 "ext/standard/url_scanner_ex.c" +#line 489 "ext/standard/url_scanner_ex.c" yy22: ++YYCURSOR; -#line 311 "ext/standard/url_scanner_ex.re" +#line 316 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); goto state_plain_begin; } -#line 489 "ext/standard/url_scanner_ex.c" +#line 494 "ext/standard/url_scanner_ex.c" yy24: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -496,7 +501,7 @@ yy25: } goto yy21; } -#line 312 "ext/standard/url_scanner_ex.re" +#line 317 "ext/standard/url_scanner_ex.re" state_next_arg_begin: @@ -505,7 +510,7 @@ state_next_arg_begin: state_next_arg: start = YYCURSOR; -#line 509 "ext/standard/url_scanner_ex.c" +#line 514 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -570,28 +575,28 @@ yy28: ++YYCURSOR; if ((yych = *YYCURSOR) == '>') goto yy39; yy29: -#line 323 "ext/standard/url_scanner_ex.re" +#line 328 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); goto state_plain_begin; } -#line 576 "ext/standard/url_scanner_ex.c" +#line 581 "ext/standard/url_scanner_ex.c" yy30: ++YYCURSOR; yy31: -#line 320 "ext/standard/url_scanner_ex.re" +#line 325 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); handle_form(STD_ARGS); goto state_plain_begin; } -#line 582 "ext/standard/url_scanner_ex.c" +#line 587 "ext/standard/url_scanner_ex.c" yy32: ++YYCURSOR; yych = *YYCURSOR; goto yy38; yy33: -#line 321 "ext/standard/url_scanner_ex.re" +#line 326 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); goto state_next_arg; } -#line 590 "ext/standard/url_scanner_ex.c" +#line 595 "ext/standard/url_scanner_ex.c" yy34: ++YYCURSOR; -#line 322 "ext/standard/url_scanner_ex.re" +#line 327 "ext/standard/url_scanner_ex.re" { --YYCURSOR; STATE = STATE_ARG; goto state_arg; } -#line 595 "ext/standard/url_scanner_ex.c" +#line 600 "ext/standard/url_scanner_ex.c" yy36: yych = *++YYCURSOR; goto yy29; @@ -609,13 +614,13 @@ yy39: yych = *YYCURSOR; goto yy31; } -#line 324 "ext/standard/url_scanner_ex.re" +#line 329 "ext/standard/url_scanner_ex.re" state_arg: start = YYCURSOR; -#line 619 "ext/standard/url_scanner_ex.c" +#line 624 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -663,14 +668,14 @@ yy42: yych = *YYCURSOR; goto yy47; yy43: -#line 329 "ext/standard/url_scanner_ex.re" +#line 334 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); handle_arg(STD_ARGS); STATE = STATE_BEFORE_VAL; goto state_before_val; } -#line 669 "ext/standard/url_scanner_ex.c" +#line 674 "ext/standard/url_scanner_ex.c" yy44: ++YYCURSOR; -#line 330 "ext/standard/url_scanner_ex.re" +#line 335 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); STATE = STATE_NEXT_ARG; goto state_next_arg; } -#line 674 "ext/standard/url_scanner_ex.c" +#line 679 "ext/standard/url_scanner_ex.c" yy46: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -681,13 +686,13 @@ yy47: } goto yy43; } -#line 331 "ext/standard/url_scanner_ex.re" +#line 336 "ext/standard/url_scanner_ex.re" state_before_val: start = YYCURSOR; -#line 691 "ext/standard/url_scanner_ex.c" +#line 696 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -734,17 +739,17 @@ yy50: if (yych == ' ') goto yy57; if (yych == '=') goto yy55; yy51: -#line 337 "ext/standard/url_scanner_ex.re" +#line 342 "ext/standard/url_scanner_ex.re" { --YYCURSOR; goto state_next_arg_begin; } -#line 740 "ext/standard/url_scanner_ex.c" +#line 745 "ext/standard/url_scanner_ex.c" yy52: ++YYCURSOR; yych = *YYCURSOR; goto yy56; yy53: -#line 336 "ext/standard/url_scanner_ex.re" +#line 341 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); STATE = STATE_VAL; goto state_val; } -#line 748 "ext/standard/url_scanner_ex.c" +#line 753 "ext/standard/url_scanner_ex.c" yy54: yych = *++YYCURSOR; goto yy51; @@ -766,14 +771,14 @@ yy57: YYCURSOR = YYMARKER; goto yy51; } -#line 338 "ext/standard/url_scanner_ex.re" +#line 343 "ext/standard/url_scanner_ex.re" state_val: start = YYCURSOR; -#line 777 "ext/standard/url_scanner_ex.c" +#line 782 "ext/standard/url_scanner_ex.c" { YYCTYPE yych; static const unsigned char yybm[] = { @@ -834,9 +839,9 @@ state_val: yych = *(YYMARKER = ++YYCURSOR); if (yych != '>') goto yy76; yy63: -#line 347 "ext/standard/url_scanner_ex.re" +#line 352 "ext/standard/url_scanner_ex.re" { passthru(STD_ARGS); goto state_next_arg_begin; } -#line 840 "ext/standard/url_scanner_ex.c" +#line 845 "ext/standard/url_scanner_ex.c" yy64: yych = *(YYMARKER = ++YYCURSOR); if (yych == '>') goto yy63; @@ -846,9 +851,9 @@ yy65: yych = *YYCURSOR; goto yy69; yy66: -#line 346 "ext/standard/url_scanner_ex.re" +#line 351 "ext/standard/url_scanner_ex.re" { handle_val(STD_ARGS, 0, ' '); goto state_next_arg_begin; } -#line 852 "ext/standard/url_scanner_ex.c" +#line 857 "ext/standard/url_scanner_ex.c" yy67: yych = *++YYCURSOR; goto yy63; @@ -875,9 +880,9 @@ yy72: goto yy63; yy73: ++YYCURSOR; -#line 345 "ext/standard/url_scanner_ex.re" +#line 350 "ext/standard/url_scanner_ex.re" { handle_val(STD_ARGS, 1, '\''); goto state_next_arg_begin; } -#line 881 "ext/standard/url_scanner_ex.c" +#line 886 "ext/standard/url_scanner_ex.c" yy75: ++YYCURSOR; if (YYLIMIT <= YYCURSOR) YYFILL(1); @@ -888,11 +893,11 @@ yy76: } if (yych >= '>') goto yy72; ++YYCURSOR; -#line 344 "ext/standard/url_scanner_ex.re" +#line 349 "ext/standard/url_scanner_ex.re" { handle_val(STD_ARGS, 1, '"'); goto state_next_arg_begin; } -#line 894 "ext/standard/url_scanner_ex.c" +#line 899 "ext/standard/url_scanner_ex.c" } -#line 348 "ext/standard/url_scanner_ex.re" +#line 353 "ext/standard/url_scanner_ex.re" stop: diff --git a/ext/standard/url_scanner_ex.re b/ext/standard/url_scanner_ex.re index fa4220897c..bfc0252299 100644 --- a/ext/standard/url_scanner_ex.re +++ b/ext/standard/url_scanner_ex.re @@ -42,6 +42,11 @@ #include "php_smart_str.h" +static void tag_dtor(zval *zv) +{ + free(Z_PTR_P(zv)); +} + static PHP_INI_MH(OnUpdateTags) { url_adapt_state_ex_t *ctx; @@ -62,7 +67,7 @@ static PHP_INI_MH(OnUpdateTags) } } - zend_hash_init(ctx->tags, 0, NULL, NULL, 1); + zend_hash_init(ctx->tags, 0, NULL, tag_dtor, 1); for (key = php_strtok_r(tmp, ",", &lasts); key; diff --git a/ext/standard/var.c b/ext/standard/var.c index 4cd8d8f1f7..6ae7d24c2e 100644 --- a/ext/standard/var.c +++ b/ext/standard/var.c @@ -669,26 +669,26 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt zend_class_entry *ce; ce = zend_get_class_entry(struc TSRMLS_CC); if (ce) { - char *prot_name, *priv_name; + zend_string *prot_name, *priv_name; int prop_name_length; do { - zend_mangle_property_name(&priv_name, &prop_name_length, ce->name->val, ce->name->len, Z_STRVAL_P(name), Z_STRLEN_P(name), ce->type & ZEND_INTERNAL_CLASS); - if ((d = zend_hash_str_find(propers, priv_name, prop_name_length)) != NULL) { - php_var_serialize_string(buf, priv_name, prop_name_length); - pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS); + priv_name = zend_mangle_property_name(ce->name->val, ce->name->len, Z_STRVAL_P(name), Z_STRLEN_P(name), ce->type & ZEND_INTERNAL_CLASS); + if ((d = zend_hash_find(propers, priv_name)) != NULL) { + php_var_serialize_string(buf, priv_name->val, priv_name->len); + STR_FREE(priv_name); php_var_serialize_intern(buf, d, var_hash TSRMLS_CC); break; } - pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS); - zend_mangle_property_name(&prot_name, &prop_name_length, "*", 1, Z_STRVAL_P(name), Z_STRLEN_P(name), ce->type & ZEND_INTERNAL_CLASS); - if ((d = zend_hash_str_find(propers, prot_name, prop_name_length)) != NULL) { - php_var_serialize_string(buf, prot_name, prop_name_length); - pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS); + STR_FREE(priv_name); + prot_name = zend_mangle_property_name("*", 1, Z_STRVAL_P(name), Z_STRLEN_P(name), ce->type & ZEND_INTERNAL_CLASS); + if ((d = zend_hash_find(propers, prot_name)) != NULL) { + php_var_serialize_string(buf, prot_name->val, prot_name->len); + STR_FREE(prot_name); php_var_serialize_intern(buf, d, var_hash TSRMLS_CC); break; } - pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS); + STR_FREE(prot_name); php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRLEN_P(name)); php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC); php_error_docref(NULL TSRMLS_CC, E_NOTICE, "\"%s\" returned as member variable from __sleep() but does not exist", Z_STRVAL_P(name)); diff --git a/main/SAPI.c b/main/SAPI.c index bb6dc7c04e..d9f55a58be 100644 --- a/main/SAPI.c +++ b/main/SAPI.c @@ -57,10 +57,15 @@ SAPI_API int sapi_globals_id; sapi_globals_struct sapi_globals; #endif +static void _type_dtor(zval *zv) +{ + free(Z_PTR_P(zv)); +} + static void sapi_globals_ctor(sapi_globals_struct *sapi_globals TSRMLS_DC) { memset(sapi_globals, 0, sizeof(*sapi_globals)); - zend_hash_init_ex(&sapi_globals->known_post_content_types, 5, NULL, NULL, 1, 0); + zend_hash_init_ex(&sapi_globals->known_post_content_types, 5, NULL, _type_dtor, 1, 0); php_setup_sapi_content_types(TSRMLS_C); } diff --git a/main/php_ini.c b/main/php_ini.c index 118743fba3..cb68d83e65 100644 --- a/main/php_ini.c +++ b/main/php_ini.c @@ -193,9 +193,9 @@ PHPAPI void config_zval_dtor(zval *zvalue) { if (Z_TYPE_P(zvalue) == IS_ARRAY) { zend_hash_destroy(Z_ARRVAL_P(zvalue)); - free(Z_ARRVAL_P(zvalue)); + free(Z_ARR_P(zvalue)); } else if (Z_TYPE_P(zvalue) == IS_STRING) { - free(Z_STRVAL_P(zvalue)); + STR_RELEASE(Z_STR_P(zvalue)); } } /* Reset / free active_ini_sectin global */ @@ -591,8 +591,6 @@ int php_init_config(TSRMLS_D) zval tmp; ZVAL_STR(&tmp, STR_INIT(fh.filename, strlen(fh.filename), 1)); - Z_SET_REFCOUNT(tmp, 0); - zend_hash_str_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path")-1, &tmp); if (php_ini_opened_path) { efree(php_ini_opened_path); diff --git a/main/php_variables.c b/main/php_variables.c index b3d2b17763..1d57ceda28 100644 --- a/main/php_variables.c +++ b/main/php_variables.c @@ -561,18 +561,15 @@ static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC) if (SG(request_info).argc) { Z_ADDREF(arr); - Z_ADDREF(argc); - zend_hash_str_update(&EG(symbol_table).ht, "argv", sizeof("argv"), &arr); - zend_hash_str_add(&EG(symbol_table).ht, "argc", sizeof("argc"), &argc); + zend_hash_str_update(&EG(symbol_table).ht, "argv", sizeof("argv")-1, &arr); + zend_hash_str_add(&EG(symbol_table).ht, "argc", sizeof("argc")-1, &argc); } - if (track_vars_array) { + if (track_vars_array && Z_TYPE_P(track_vars_array) == IS_ARRAY) { Z_ADDREF(arr); - Z_ADDREF(argc); - zend_hash_str_update(Z_ARRVAL_P(track_vars_array), "argv", sizeof("argv"), &arr); - zend_hash_str_update(Z_ARRVAL_P(track_vars_array), "argc", sizeof("argc"), &argc); + zend_hash_str_update(Z_ARRVAL_P(track_vars_array), "argv", sizeof("argv")-1, &arr); + zend_hash_str_update(Z_ARRVAL_P(track_vars_array), "argc", sizeof("argc")-1, &argc); } zval_ptr_dtor(&arr); - zval_ptr_dtor(&argc); } /* }}} */ @@ -735,7 +732,6 @@ static zend_bool php_auto_globals_create_server(zend_string *name TSRMLS_DC) if ((argc = zend_hash_str_find(&EG(symbol_table).ht, "argc", sizeof("argc")-1)) != NULL && (argv = zend_hash_str_find(&EG(symbol_table).ht, "argv", sizeof("argv")-1)) != NULL) { - Z_ADDREF_P(argc); Z_ADDREF_P(argv); zend_hash_str_update(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv")-1, argv); zend_hash_str_update(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "argc", sizeof("argc")-1, argc); @@ -817,13 +813,13 @@ static zend_bool php_auto_globals_create_request(zend_string *name TSRMLS_DC) void php_startup_auto_globals(TSRMLS_D) { - zend_register_auto_global(STR_INIT("_GET", sizeof("_GET")-1, 0), 0, php_auto_globals_create_get TSRMLS_CC); - zend_register_auto_global(STR_INIT("_POST", sizeof("_POST")-1, 0), 0, php_auto_globals_create_post TSRMLS_CC); - zend_register_auto_global(STR_INIT("_COOKIE", sizeof("_COOKIE")-1, 0), 0, php_auto_globals_create_cookie TSRMLS_CC); - zend_register_auto_global(STR_INIT("_SERVER", sizeof("_SERVER")-1, 0), PG(auto_globals_jit), php_auto_globals_create_server TSRMLS_CC); - zend_register_auto_global(STR_INIT("_ENV", sizeof("_ENV")-1, 0), PG(auto_globals_jit), php_auto_globals_create_env TSRMLS_CC); - zend_register_auto_global(STR_INIT("_REQUEST", sizeof("_REQUEST")-1, 0), PG(auto_globals_jit), php_auto_globals_create_request TSRMLS_CC); - zend_register_auto_global(STR_INIT("_FILES", sizeof("_FILES")-1, 0), 0, php_auto_globals_create_files TSRMLS_CC); + zend_register_auto_global(STR_INIT("_GET", sizeof("_GET")-1, 1), 0, php_auto_globals_create_get TSRMLS_CC); + zend_register_auto_global(STR_INIT("_POST", sizeof("_POST")-1, 1), 0, php_auto_globals_create_post TSRMLS_CC); + zend_register_auto_global(STR_INIT("_COOKIE", sizeof("_COOKIE")-1, 1), 0, php_auto_globals_create_cookie TSRMLS_CC); + zend_register_auto_global(STR_INIT("_SERVER", sizeof("_SERVER")-1, 1), PG(auto_globals_jit), php_auto_globals_create_server TSRMLS_CC); + zend_register_auto_global(STR_INIT("_ENV", sizeof("_ENV")-1, 1), PG(auto_globals_jit), php_auto_globals_create_env TSRMLS_CC); + zend_register_auto_global(STR_INIT("_REQUEST", sizeof("_REQUEST")-1, 1), PG(auto_globals_jit), php_auto_globals_create_request TSRMLS_CC); + zend_register_auto_global(STR_INIT("_FILES", sizeof("_FILES")-1, 1), 0, php_auto_globals_create_files TSRMLS_CC); } /* diff --git a/main/rfc1867.c b/main/rfc1867.c index ed4e275cbb..90e823d86c 100644 --- a/main/rfc1867.c +++ b/main/rfc1867.c @@ -758,7 +758,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */ zend_hash_init(&PG(rfc1867_protected_variables), 5, NULL, NULL, 0); ALLOC_HASHTABLE(uploaded_files); - zend_hash_init(uploaded_files, 5, NULL, (dtor_func_t) free_estring, 0); + zend_hash_init(uploaded_files, 5, NULL, free_string_zval, 0); SG(rfc1867_uploaded_files) = uploaded_files; array_init(&PG(http_globals)[TRACK_VARS_FILES]); |