Use better data structures (incomplete)

diff --git a/Zend/zend.c b/Zend/zend.c
index 92c938a5df272a67ccc875db3f08bb517c639638..a060602aba600f733461d979c0e7e4d210d8f490 100644 (file)
--- 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 eb771866b58f08a553808cb96a912267f3949ccf..4d212c5e1f889c4c3796bdcd8f2d1ec7ada6fd5a 100644 (file)
--- 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 bd5867f3a58f9bb5d583b891c0e4d04049e33958..cb539b0f4ca485ffbb2125b4c1fb646ee488c451 100644 (file)
--- 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 c35a10217178b1d2f01cb18aa334616aaf9f32da..85c52dd953002145b814ff392e40c553a2df48c2 100644 (file)
--- 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 75c5a827d5533ddb6254d50376f4643c2269e3c5..58d4cc1e50f2a844286c2749278f869b7cea4a43 100644 (file)
--- 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 96c3c34a7a29ce33e5730ba27df4a4d4246946ae..8af44237bfce202bdb2947ce81e86d1aaba4cecf 100644 (file)
--- 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 f6cbac39686f87247e4c325d0db3d6bc0cfc8bcf..04162c8b70bb2bc13ccbdda0fee525c81ca12dbe 100644 (file)
--- 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 86c5d56f0a5fb7f8749582b89eeb72d2c71d32a7..5ededead25429faf45f73c7ea3712e8c1a0fbcc0 100644 (file)
--- 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 14f060d0c74f560a135dce6dbfb88542ac912a81..08df3477709f6c5edbe20f469a6405e08626fb68 100644 (file)
--- 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 8ad16de2d8fc78d6fabcfdf0f479699dd780c5ce..5a287e05702587c3166cfb4f7775f41c85471cf0 100644 (file)
--- 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 7176c1f147d2f8ef766f5a82622d460890d0d6d0..32a2a7545a1b3b5da22ffdf9d7e2d8f6358fe281 100644 (file)
--- 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 a4adb46639d4f4a1b98ca9c0dda0ac26288fd572..882049830bfeb2539239a15fd24b5e9d8fb9f721 100644 (file)
--- 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 37943bc222df5e1d9f3cf0bfc3474a0dd09a89b5..268f21bb86f1657203ff3963fe13010b4ecf2360 100644 (file)
--- 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 67ac83ca176903f9e9e09c9e5eb58f12bfe69173..4e30fccdac26986aefe2da92f7bfbde06c7a032d 100644 (file)
--- 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 e7c2837dd2c78e9aca28a619ed37f0a435dbbd1a..b315307d897c1dcb6d9294b8a303e20d5a1cf919 100644 (file)
--- 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 59a561f6e6dacb27dbeb09d8bdd71802f1db3619..3dbe72c030fba0e9cf9368fe552642446aa5abbb 100644 (file)
--- 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 fbd4087ec29520031da2b3ba4e5f69e27fea97a6..283b069f488e159784149146ecb24462fcc6ed81 100644 (file)
--- 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 4fb41e794f03499b820da0c3a5e0d110bb311b64..8a9b26d3e7b9eba21eb7035392bffedb3dff57b3 100644 (file)
--- 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 f0e3a5f98fa68367421f82a9f1cf813a4516f712..5a61c1bea0a49c1be567afab08222ad81eb7e4a3 100644 (file)
--- 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 05cd6a2d19c7013aade2701253bcad819348110b..0fda838983f41a4631c21fe874be6462ec3098d0 100644 (file)
--- 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 67490d7a95ee4f84e443309116a5bca331f91eab..55db9439947d1af6630210a85bdd5e3941853bb9 100644 (file)
--- 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 5d143ed11de8c13be9e37ee15d5825cbbf336ade..5591c285b08e46055336e3aee9379ff85f62e603 100644 (file)
--- 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 6c4076a4e42e938d89de0be8ee8ac19b571f18de..b9fc79ff3502133dfba5cbcc46230319c9ed3a23 100644 (file)
--- 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 9ce1312b0dc73b609e6f31c490276418551106fa..ab5c5b38b887fc40a0eb893f45978d51c5e0c1d8 100644 (file)
--- 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 35b6e549f25aa4189d4d3244b4944cc7249ccab1..238b7574a0a4a76b6d90eda771b82e4bec17ca68 100644 (file)
--- 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 903ca7882fc8f8f6270b663bb556a7d9417f6b64..ec28e2e4fdcc5e8f465158e741998dd295dd87bf 100644 (file)
--- 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 f2093d9cb44f28ad8871846305a2aa5ca3b14f7e..0d2621c6ed43e66fbce05ec43c8a4b3261abd04c 100644 (file)
--- 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 1fc4f13cad9f4eba2f9e238c9afb3628e141e559..35fa40a7c1c7ff92dc704f24add30f428a2c8cc0 100644 (file)
--- 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 e3cf1323c38b38ebed5fd38ffe0c7fd0952f1c9d..97a9509caaf0c620feb9cafead6fbd45f3a1bfb3 100644 (file)
--- 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 a15da3635737cbbc2141b240c7df97234c5dbc47..1d116ff783fd2637fed1609293ae4d201adc20c7 100644 (file)
--- 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 1520bfb4016dfee0b4ab3b52156815316c1c2eff..45b50c2d25e142dee15b4428fc85fee221de0c80 100644 (file)
--- 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 92baee4b0c35296218544a5ca05d5d8d6677cf93..c91379bf208bbb408e4a0718b31e3345bf84e3a3 100644 (file)
--- 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 00ecfb2892e138d122db34508013824b133046bb..cc5925bee7a29b3d27a461a77136750493fa0488 100644 (file)
--- 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 402b3aaac55a00da6e28f3baa8f0ec7c07876920..8a9da90ec44a5a739fd75bb7878f9f9ee54ab716 100644 (file)
--- 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 98f5d299ed0535215d7a704fc81bb192bb6adebb..290b63eb91beb95f9d1bfc751b392b54f1d787ee 100644 (file)
--- 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 0738ead2fdff28b9aac6b7c88a745f2d62fad04a..a1bc44fda0db644439c99ffc890c3d9826ffc0f4 100644 (file)
--- 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 b48a52661a9f43668e9427628901ed899f67f714..08ccd0207fc1907b181884d2d0ab32f8c1ed8c23 100644 (file)
--- 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 fa4220897c70b53903d35afd3d89ba73781fe155..bfc0252299c6dae12f9173906ef738503863a799 100644 (file)
--- 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 4cd8d8f1f790d7c6d6f79817bfc50b80c17d866a..6ae7d24c2e57d9f8d22e06238eb70487bcba6cb4 100644 (file)
--- 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 bb6dc7c04ebce6679529562439bf64df2d8eff35..d9f55a58be28179f88f42ce6a735102debb4f236 100644 (file)
--- 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 118743fba3c77e1dc5b4b112724c30d62c2fb0a0..cb68d83e656adbc9bfa65e9de2eb550d913a1363 100644 (file)
--- 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 b3d2b17763ef94ce7eb25d97a885561c9f71cdc1..1d57ceda2825bdea34b273c5e634b421d948a51b 100644 (file)
--- 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 ed4e275cbb46daa1ccdfd97abc52caabfef585fb..90e823d86cbb02002fdd2e7d3fd66508e8af805b 100644 (file)
--- 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]);