Refactored EG(active_symbol_table) to be zend_array* instead of HashTable*

diff --git a/Zend/zend.c b/Zend/zend.c
index 783f47cc3ea3fe0996f46f3047da50629718eafb..a494c97dc94b49cafd6adbe17a75ea3b5975b99c 100644 (file)
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -1184,8 +1184,8 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
                        if (!EG(active_symbol_table)) {
                                ZVAL_NULL(&params[4]);
                        } else {
-                               array_init_size(&params[4], zend_hash_num_elements(EG(active_symbol_table)));
-                               zend_hash_copy(Z_ARRVAL(params[4]), EG(active_symbol_table), zval_add_ref);
+                               array_init_size(&params[4], zend_hash_num_elements(&EG(active_symbol_table)->ht));
+                               zend_hash_copy(Z_ARRVAL(params[4]), &EG(active_symbol_table)->ht, zval_add_ref);
                        }
 
                        ZVAL_COPY_VALUE(&orig_user_error_handler, &EG(user_error_handler));

diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index 206d9cfbed80471405823c582a669be049f78090..d759803345e38c6060b6c2c81df0705c47aaef7c 100644 (file)
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -44,7 +44,7 @@ typedef struct _zend_fcall_info {
        size_t size;
        HashTable *function_table;
        zval function_name;
-       HashTable *symbol_table;
+       zend_array *symbol_table;
        zval *retval;
        zend_uint param_count;
        zval *params;
@@ -452,7 +452,7 @@ ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval
 
 
 ZEND_API int call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, zend_uint param_count, zval params[] TSRMLS_DC);
-ZEND_API int call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, zend_uint param_count, zval params[], int no_separation, HashTable *symbol_table TSRMLS_DC);
+ZEND_API int call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, zend_uint param_count, zval params[], int no_separation, zend_array *symbol_table TSRMLS_DC);
 
 ZEND_API extern const zend_fcall_info empty_fcall_info;
 ZEND_API extern const zend_fcall_info_cache empty_fcall_info_cache;
@@ -519,7 +519,7 @@ ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, zend_st
 
 ZEND_API int zend_delete_global_variable(zend_string *name TSRMLS_DC);
 
-ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC);
+ZEND_API void zend_reset_all_cv(zend_array *symbol_table TSRMLS_DC);
 
 ZEND_API void zend_rebuild_symbol_table(TSRMLS_D);
 

diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index 776f7903e463d62afe43ae0dd0f94c7a1248aad0..5691fd0b6910276f8577113348cbf4ccd8a72abb 100644 (file)
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -1726,9 +1726,9 @@ ZEND_FUNCTION(get_defined_vars)
                zend_rebuild_symbol_table(TSRMLS_C);
        }
 
-       array_init_size(return_value, zend_hash_num_elements(EG(active_symbol_table)));
+       array_init_size(return_value, zend_hash_num_elements(&EG(active_symbol_table)->ht));
 
-       zend_hash_copy(Z_ARRVAL_P(return_value), EG(active_symbol_table), zval_add_ref);
+       zend_hash_copy(Z_ARRVAL_P(return_value), &EG(active_symbol_table)->ht, zval_add_ref);
 }
 /* }}} */
 

diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index ca83c2e95e059f8d7d5b88c9b847af50855a6f9c..45bbb4a563ae0cb0311abc475a1e6ab87a11d973 100644 (file)
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -379,7 +379,7 @@ struct _zend_execute_data {
        zend_function_state function_state;
        zend_op_array *op_array;
        zval object;
-       HashTable *symbol_table;
+       zend_array *symbol_table;
        struct _zend_execute_data *prev_execute_data;
        zval old_error_reporting;
        zend_bool nested;

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 6e4005a1dca015d17d496710c9262a49638c82ca..517681704190096ae1edc2ed964dbe184b7dd3c5 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -212,7 +212,7 @@ static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, zend_uint var, int
        zval *ret = NULL;
 
        if (EG(active_symbol_table)) {
-               ret = zend_hash_find(EG(active_symbol_table), cv);
+               ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
                if (ret) {
                        ZVAL_INDIRECT(ptr, ret);
                        return ret;
@@ -231,7 +231,7 @@ static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, zend_uint var, int
                        /* break missing intentionally */
                case BP_VAR_W:
                        if (EG(active_symbol_table)) {
-                               ret = zend_hash_update(EG(active_symbol_table), cv, ret);
+                               ret = zend_hash_update(&EG(active_symbol_table)->ht, cv, ret);
                                ZVAL_INDIRECT(ptr, ret);
                        } else {
                                ZVAL_NULL(ptr);
@@ -248,7 +248,7 @@ static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_R(zval *ptr, zend_uint
        zval *ret = NULL;
 
        if (EG(active_symbol_table)) {
-               ret = zend_hash_find(EG(active_symbol_table), cv);
+               ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
                if (ret) {
                        ZVAL_INDIRECT(ptr, ret);
                        return ret;
@@ -265,7 +265,7 @@ static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_UNSET(zval *ptr, zend_
        zval *ret;
 
        if (EG(active_symbol_table)) {
-               ret = zend_hash_find(EG(active_symbol_table), cv);
+               ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
                if (ret) {
                        ZVAL_INDIRECT(ptr, ret);
                        return ret;
@@ -282,7 +282,7 @@ static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_IS(zval *ptr, zend_uin
        zval *ret;
 
        if (EG(active_symbol_table)) {
-               ret = zend_hash_find(EG(active_symbol_table), cv);
+               ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
                if (ret) {
                        ZVAL_INDIRECT(ptr, ret);
                        return ret;
@@ -298,12 +298,12 @@ static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_RW(zval *ptr, zend_uin
        zval *ret;
 
        if (EG(active_symbol_table)) {
-               ret = zend_hash_find(EG(active_symbol_table), cv);
+               ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
                if (ret) {
                        ZVAL_INDIRECT(ptr, ret);
                        return ret;
                }
-               ret = zend_hash_update(EG(active_symbol_table), cv, &EG(uninitialized_zval));
+               ret = zend_hash_update(&EG(active_symbol_table)->ht, cv, &EG(uninitialized_zval));
                ZVAL_INDIRECT(ptr, ret);
                zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
                return ret;
@@ -320,12 +320,12 @@ static zend_never_inline zval *_get_zval_cv_lookup_BP_VAR_W(zval *ptr, zend_uint
        zval *ret;
 
        if (EG(active_symbol_table)) {
-               ret = zend_hash_find(EG(active_symbol_table), cv);
+               ret = zend_hash_find(&EG(active_symbol_table)->ht, cv);
                if (ret) {
                        ZVAL_INDIRECT(ptr, ret);
                        return ret;
                }
-               ret = zend_hash_update(EG(active_symbol_table), cv, &EG(uninitialized_zval));
+               ret = zend_hash_update(&EG(active_symbol_table)->ht, cv, &EG(uninitialized_zval));
                ZVAL_INDIRECT(ptr, ret);
                return ret;
        } else {
@@ -1060,7 +1060,7 @@ static inline HashTable *zend_get_target_symbol_table(int fetch_type TSRMLS_DC)
                        if (!EG(active_symbol_table)) {
                                zend_rebuild_symbol_table(TSRMLS_C);
                        }
-                       return EG(active_symbol_table);
+                       return &EG(active_symbol_table)->ht;
                        break;
                case ZEND_FETCH_GLOBAL:
                case ZEND_FETCH_GLOBAL_LOCK:
@@ -1570,15 +1570,15 @@ ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, zend_fcall_i
        }
 }
 
-void zend_clean_and_cache_symbol_table(HashTable *symbol_table TSRMLS_DC) /* {{{ */
+void zend_clean_and_cache_symbol_table(zend_array *symbol_table TSRMLS_DC) /* {{{ */
 {
        if (EG(symtable_cache_ptr) >= EG(symtable_cache_limit)) {
-               zend_hash_destroy(symbol_table);
-               FREE_HASHTABLE(symbol_table);
+               zend_hash_destroy(&symbol_table->ht);
+               efree(symbol_table);
        } else {
                /* clean before putting into the cache, since clean
                   could call dtors, which could use cached hash */
-               zend_hash_clean(symbol_table);
+               zend_hash_clean(&symbol_table->ht);
                *(++EG(symtable_cache_ptr)) = symbol_table;
        }
 }
@@ -1732,7 +1732,7 @@ static zend_always_inline zend_execute_data *i_create_execute_data_from_op_array
                        ZVAL_COPY(EX_VAR_NUM(op_array->this_var), &EG(This));
                } else {
                        ZVAL_COPY(EX_VAR_NUM(op_array->this_var), &EG(This));
-                       zval *zv = zend_hash_str_add(EG(active_symbol_table), "this", sizeof("this")-1, EX_VAR(op_array->this_var));
+                       zval *zv = zend_hash_str_add(&EG(active_symbol_table)->ht, "this", sizeof("this")-1, EX_VAR(op_array->this_var));
                        if (zv) {
                                ZVAL_INDIRECT(EX_VAR_NUM(op_array->this_var), zv);
                        }

diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index 3db755fb841c00e0a162cd92c9c8d91b11885c49..5c9651feb800ab4ce9ce7dfe8f39e45e83d991ce 100644 (file)
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -374,7 +374,7 @@ ZEND_API zval *zend_get_zval_ptr(int op_type, const znode_op *node, const zend_e
 
 ZEND_API int zend_do_fcall(ZEND_OPCODE_HANDLER_ARGS);
 
-void zend_clean_and_cache_symbol_table(HashTable *symbol_table TSRMLS_DC);
+void zend_clean_and_cache_symbol_table(zend_array *symbol_table TSRMLS_DC);
 void zend_free_compiled_variables(zend_execute_data *execute_data TSRMLS_DC);
 
 #define CACHED_PTR(num) \

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index ea02c0f160a9094321cf09e38ddac7e9b083d3c3..339a71b901f5920bfad495a79bb90652fef4e494 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -157,7 +157,7 @@ void init_executor(TSRMLS_D) /* {{{ */
        zend_vm_stack_push(&tmp TSRMLS_CC);
 
        zend_hash_init(&EG(symbol_table).ht, 50, NULL, ZVAL_PTR_DTOR, 0);
-       EG(active_symbol_table) = &EG(symbol_table).ht;
+       EG(active_symbol_table) = &EG(symbol_table);
 
        zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_activator TSRMLS_CC);
        EG(opline_ptr) = NULL;
@@ -302,8 +302,8 @@ void shutdown_executor(TSRMLS_D) /* {{{ */
                }
 
                while (EG(symtable_cache_ptr)>=EG(symtable_cache)) {
-                       zend_hash_destroy(*EG(symtable_cache_ptr));
-                       FREE_HASHTABLE(*EG(symtable_cache_ptr));
+                       zend_hash_destroy(&(*EG(symtable_cache_ptr))->ht);
+                       efree(*EG(symtable_cache_ptr));
                        EG(symtable_cache_ptr)--;
                }
        } zend_end_try();
@@ -714,7 +714,7 @@ int call_user_function(HashTable *function_table, zval *object, zval *function_n
 }
 /* }}} */
 
-int call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, zend_uint param_count, zval params[], int no_separation, HashTable *symbol_table TSRMLS_DC) /* {{{ */
+int call_user_function_ex(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, zend_uint param_count, zval params[], int no_separation, zend_array *symbol_table TSRMLS_DC) /* {{{ */
 {
        zend_fcall_info fci;
 
@@ -735,7 +735,7 @@ int call_user_function_ex(HashTable *function_table, zval *object, zval *functio
 int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TSRMLS_DC) /* {{{ */
 {
        zend_uint i;
-       HashTable *calling_symbol_table;
+       zend_array *calling_symbol_table;
        zend_op_array *original_op_array;
        zend_op **original_opline_ptr;
        zend_class_entry *current_scope;
@@ -1636,7 +1636,7 @@ void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC) /* {{{ */
+ZEND_API void zend_reset_all_cv(zend_array *symbol_table TSRMLS_DC) /* {{{ */
 {
        zend_execute_data *ex;
        int i;
@@ -1654,7 +1654,7 @@ ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC) /* {{{ */
 ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, zend_string *name TSRMLS_DC) /* {{{ */
 {
        if (zend_hash_del(ht, name) == SUCCESS) {
-               while (ex && ex->symbol_table == ht) {
+               while (ex && &ex->symbol_table->ht == ht) {
                        int i;
 
                        if (ex->op_array) {
@@ -1679,7 +1679,7 @@ ZEND_API int zend_delete_global_variable(zend_string *name TSRMLS_DC) /* {{{ */
 
        if (zend_hash_del(&EG(symbol_table).ht, name) == SUCCESS) {
                for (ex = EG(current_execute_data); ex; ex = ex->prev_execute_data) {
-                       if (ex->op_array && ex->symbol_table == &EG(symbol_table).ht) {
+                       if (ex->op_array && ex->symbol_table == &EG(symbol_table)) {
                                int i;
                                for (i = 0; i < ex->op_array->last_var; i++) {
                                        if (ex->op_array->vars[i]->h == name->h &&
@@ -1720,8 +1720,10 @@ ZEND_API void zend_rebuild_symbol_table(TSRMLS_D) /* {{{ */
                                /*printf("Cache hit!  Reusing %x\n", symtable_cache[symtable_cache_ptr]);*/
                                EG(active_symbol_table) = *(EG(symtable_cache_ptr)--);
                        } else {
-                               ALLOC_HASHTABLE(EG(active_symbol_table));
-                               zend_hash_init(EG(active_symbol_table), ex->op_array->last_var, NULL, ZVAL_PTR_DTOR, 0);
+                               EG(active_symbol_table) = emalloc(sizeof(zend_array));
+                               EG(active_symbol_table)->gc.refcount = 0;
+                               EG(active_symbol_table)->gc.u.v.type = IS_ARRAY;
+                               zend_hash_init(&EG(active_symbol_table)->ht, ex->op_array->last_var, NULL, ZVAL_PTR_DTOR, 0);
                                /*printf("Cache miss!  Initialized %x\n", EG(active_symbol_table));*/
                        }
                        ex->symbol_table = EG(active_symbol_table);
@@ -1733,7 +1735,7 @@ ZEND_API void zend_rebuild_symbol_table(TSRMLS_D) /* {{{ */
                        }
                        for (i = 0; i < ex->op_array->last_var; i++) {
                                if (Z_TYPE_P(EX_VAR_NUM_2(ex, i)) != IS_UNDEF) {
-                                       zval *zv = zend_hash_update(EG(active_symbol_table),
+                                       zval *zv = zend_hash_update(&EG(active_symbol_table)->ht,
                                                ex->op_array->vars[i],
                                                EX_VAR_NUM_2(ex, i));
                                        ZVAL_INDIRECT(EX_VAR_NUM_2(ex, i), zv);

diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c
index 6eb65ce28bbf6fcb0004cf21ef461ced3b287385..483628dbaf6b52a410e9c1c85899e2a2eae2440f 100644 (file)
--- a/Zend/zend_generators.c
+++ b/Zend/zend_generators.c
@@ -245,7 +245,7 @@ ZEND_API void zend_generator_create_zval(zend_op_array *op_array, zval *return_v
        zend_generator *generator;
        zend_execute_data *current_execute_data;
        zend_op **opline_ptr;
-       HashTable *current_symbol_table;
+       zend_array *current_symbol_table;
        zend_execute_data *execute_data;
        zend_vm_stack current_stack = EG(argument_stack);
 
@@ -335,7 +335,7 @@ ZEND_API void zend_generator_resume(zend_generator *generator TSRMLS_DC) /* {{{
                zend_execute_data *original_execute_data = EG(current_execute_data);
                zend_op **original_opline_ptr = EG(opline_ptr);
                zend_op_array *original_active_op_array = EG(active_op_array);
-               HashTable *original_active_symbol_table = EG(active_symbol_table);
+               zend_array *original_active_symbol_table = EG(active_symbol_table);
                zval original_This;
                zend_class_entry *original_scope = EG(scope);
                zend_class_entry *original_called_scope = EG(called_scope);

diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index e987ac1cd48738e30da9828889988c1415a5d7b7..9dae1fcfcaf5fe808c2e775df4a2a723592c6240 100644 (file)
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -162,13 +162,13 @@ struct _zend_executor_globals {
        zval error_zval;
 
        /* symbol table cache */
-       HashTable *symtable_cache[SYMTABLE_CACHE_SIZE];
-       HashTable **symtable_cache_limit;
-       HashTable **symtable_cache_ptr;
+       zend_array *symtable_cache[SYMTABLE_CACHE_SIZE];
+       zend_array **symtable_cache_limit;
+       zend_array **symtable_cache_ptr;
 
        zend_op **opline_ptr;
 
-       HashTable *active_symbol_table;
+       zend_array *active_symbol_table;
        zend_array symbol_table;                /* main symbol table */
 
        HashTable included_files;       /* files already included */

diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c
index 47b07eec79a26c8ce9cc271f72bd6d9e1b572bd5..f016f85f0071c37f86429f817a78469bd1ae1049 100644 (file)
--- a/Zend/zend_variables.c
+++ b/Zend/zend_variables.c
@@ -306,13 +306,13 @@ ZEND_API int zval_copy_static_var(zval *p TSRMLS_DC, int num_args, va_list args,
                if (!EG(active_symbol_table)) {
                        zend_rebuild_symbol_table(TSRMLS_C);
                }
-               p = zend_hash_find(EG(active_symbol_table), key->key);
+               p = zend_hash_find(&EG(active_symbol_table)->ht, key->key);
                if (!p) {
                        p = &tmp;
                        ZVAL_NULL(&tmp);
                        if (is_ref) {
                                ZVAL_NEW_REF(&tmp, &tmp);
-                               zend_hash_add(EG(active_symbol_table), key->key, &tmp);
+                               zend_hash_add(&EG(active_symbol_table)->ht, key->key, &tmp);
                        } else {
                                zend_error(E_NOTICE,"Undefined variable: %s", key->key->val);
                        }

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 44ec35e3b64ffa9cc2dbe36f9ef305b9db5be600..14483a427fcd0b01a8cba7788fe08262f58dcea6 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -3032,7 +3032,7 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV)
        ZVAL_OBJ(EX_VAR_NUM(opline->op2.var), EG(exception));
        if (EG(active_symbol_table)) {
                zend_string *cv = CV_DEF_OF(opline->op2.var);
-               zval *zv = zend_hash_update(EG(active_symbol_table), cv, EX_VAR_NUM(opline->op2.var));
+               zval *zv = zend_hash_update(&EG(active_symbol_table)->ht, cv, EX_VAR_NUM(opline->op2.var));
                ZVAL_INDIRECT(EX_VAR_NUM(opline->op2.var), zv);
        }
        if (UNEXPECTED(EG(exception) != exception)) {
@@ -4066,7 +4066,7 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -4615,7 +4615,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 7b91edfb9194b0c53f663b1125bc77b1774592b4..dc625815f47a222ecbb2aac897913fabe4e89c57 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -4090,7 +4090,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -4176,7 +4176,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -5754,7 +5754,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -5840,7 +5840,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -6429,7 +6429,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -6515,7 +6515,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -7196,7 +7196,7 @@ static int ZEND_FASTCALL  ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
        ZVAL_OBJ(EX_VAR_NUM(opline->op2.var), EG(exception));
        if (EG(active_symbol_table)) {
                zend_string *cv = CV_DEF_OF(opline->op2.var);
-               zval *zv = zend_hash_update(EG(active_symbol_table), cv, EX_VAR_NUM(opline->op2.var));
+               zval *zv = zend_hash_update(&EG(active_symbol_table)->ht, cv, EX_VAR_NUM(opline->op2.var));
                ZVAL_INDIRECT(EX_VAR_NUM(opline->op2.var), zv);
        }
        if (UNEXPECTED(EG(exception) != exception)) {
@@ -9149,7 +9149,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -9235,7 +9235,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -10800,7 +10800,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -10886,7 +10886,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -11364,7 +11364,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -11450,7 +11450,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -15625,7 +15625,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -15859,7 +15859,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -20166,7 +20166,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -20400,7 +20400,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -21592,7 +21592,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -21678,7 +21678,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -32829,7 +32829,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -33061,7 +33061,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -37119,7 +37119,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -37351,7 +37351,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {
@@ -38425,7 +38425,7 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND
                if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table), cv TSRMLS_CC);
+                       zend_delete_variable(EX(prev_execute_data), &EG(active_symbol_table)->ht, cv TSRMLS_CC);
                        ZVAL_UNDEF(EX_VAR_NUM(opline->op1.var));
                } else if (Z_TYPE_P(EX_VAR_NUM(opline->op1.var)) != IS_UNDEF) {
                        zval_ptr_dtor(EX_VAR_NUM(opline->op1.var));
@@ -38511,7 +38511,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
                } else if (EG(active_symbol_table)) {
                        zend_string *cv = CV_DEF_OF(opline->op1.var);
 
-                       if ((value = zend_hash_find(EG(active_symbol_table), cv)) == NULL) {
+                       if ((value = zend_hash_find(&EG(active_symbol_table)->ht, cv)) == NULL) {
                                isset = 0;
                        }
                } else {

diff --git a/ext/standard/array.c b/ext/standard/array.c
index ce0fcad5abe4152ad6e7c9babd651dda08ac308d..de3e4b5573ef46c6bdfe690e659b6235cad9dd9c 100644 (file)
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -1338,7 +1338,7 @@ PHP_FUNCTION(extract)
                var_exists = 0;
 
                if (key_type == HASH_KEY_IS_STRING) {
-                       var_exists = zend_hash_exists(EG(active_symbol_table), var_name);
+                       var_exists = zend_hash_exists(&EG(active_symbol_table)->ht, var_name);
                } else if (key_type == HASH_KEY_IS_LONG && (extract_type == EXTR_PREFIX_ALL || extract_type == EXTR_PREFIX_INVALID)) {
                        zval num;
 
@@ -1409,15 +1409,15 @@ PHP_FUNCTION(extract)
                                SEPARATE_ZVAL_TO_MAKE_IS_REF(entry);
                                Z_ADDREF_P(entry);
 
-                               if ((orig_var = zend_hash_find(EG(active_symbol_table), Z_STR(final_name))) != NULL) {
+                               if ((orig_var = zend_hash_find(&EG(active_symbol_table)->ht, Z_STR(final_name))) != NULL) {
                                        zval_ptr_dtor(orig_var);
                                        ZVAL_COPY_VALUE(orig_var, entry);
                                } else {
-                                       zend_hash_update(EG(active_symbol_table), Z_STR(final_name), entry);
+                                       zend_hash_update(&EG(active_symbol_table)->ht, Z_STR(final_name), entry);
                                }
                        } else {
                                ZVAL_DUP(&data, entry);
-                               ZEND_SET_SYMBOL_WITH_LENGTH(EG(active_symbol_table), Z_STRVAL(final_name), Z_STRLEN(final_name), &data, 1, 0);
+                               ZEND_SET_SYMBOL_WITH_LENGTH(&EG(active_symbol_table)->ht, Z_STRVAL(final_name), Z_STRLEN(final_name), &data, 1, 0);
                        }
                        count++;
                }
@@ -1489,7 +1489,7 @@ PHP_FUNCTION(compact)
        }
 
        for (i=0; i<ZEND_NUM_ARGS(); i++) {
-               php_compact_var(EG(active_symbol_table), return_value, &args[i] TSRMLS_CC);
+               php_compact_var(&EG(active_symbol_table)->ht, return_value, &args[i] TSRMLS_CC);
        }
 }
 /* }}} */
@@ -2043,7 +2043,7 @@ PHP_FUNCTION(array_unshift)
        new_hash = php_splice(Z_ARRVAL_P(stack), 0, 0, &args[0], argc, NULL);
        old_hash = *Z_ARRVAL_P(stack);
        if (Z_ARRVAL_P(stack) == &EG(symbol_table).ht) {
-               zend_reset_all_cv(&EG(symbol_table).ht TSRMLS_CC);
+               zend_reset_all_cv(&EG(symbol_table) TSRMLS_CC);
        }
        *Z_ARRVAL_P(stack) = *new_hash;
        FREE_HASHTABLE(new_hash);
@@ -2126,7 +2126,7 @@ PHP_FUNCTION(array_splice)
        /* Replace input array's hashtable with the new one */
        old_hash = *Z_ARRVAL_P(array);
        if (Z_ARRVAL_P(array) == &EG(symbol_table).ht) {
-               zend_reset_all_cv(&EG(symbol_table).ht TSRMLS_CC);
+               zend_reset_all_cv(&EG(symbol_table) TSRMLS_CC);
        }
        *Z_ARRVAL_P(array) = *new_hash;
        FREE_HASHTABLE(new_hash);
@@ -2789,7 +2789,7 @@ PHP_FUNCTION(array_pad)
        /* Copy the result hash into return value */
        old_hash = *Z_ARRVAL_P(return_value);
        if (Z_ARRVAL_P(return_value) == &EG(symbol_table).ht) {
-               zend_reset_all_cv(&EG(symbol_table).ht TSRMLS_CC);
+               zend_reset_all_cv(&EG(symbol_table) TSRMLS_CC);
        }
        *Z_ARRVAL_P(return_value) = *new_hash;
        FREE_HASHTABLE(new_hash);

diff --git a/ext/standard/http_fopen_wrapper.c b/ext/standard/http_fopen_wrapper.c
index 55a1d12cc78c237263b4910a4e321cb9f51a54b4..29e5db0ebf23ebf7c404b9af4c80a5a4df8df3a2 100644 (file)
--- a/ext/standard/http_fopen_wrapper.c
+++ b/ext/standard/http_fopen_wrapper.c
@@ -659,10 +659,10 @@ finish:
        if (header_init) {
                zval ztmp;
                array_init(&ztmp);
-               ZEND_SET_SYMBOL(EG(active_symbol_table), "http_response_header", &ztmp);
+               ZEND_SET_SYMBOL(&EG(active_symbol_table)->ht, "http_response_header", &ztmp);
        }
 
-       response_header = zend_hash_str_find(EG(active_symbol_table), "http_response_header", sizeof("http_response_header")-1);
+       response_header = zend_hash_str_find(&EG(active_symbol_table)->ht, "http_response_header", sizeof("http_response_header")-1);
 
        if (!php_stream_eof(stream)) {
                size_t tmp_line_len;

diff --git a/ext/standard/string.c b/ext/standard/string.c
index 5bfffa02923f01c8dd8c4a33f30ee32025ad86e6..e3a1df1f241191485dc993163c7878454c5abbaa 100644 (file)
--- a/ext/standard/string.c
+++ b/ext/standard/string.c
@@ -4420,7 +4420,7 @@ PHP_FUNCTION(parse_str)
                if (!EG(active_symbol_table)) {
                        zend_rebuild_symbol_table(TSRMLS_C);
                }
-//???          Z_ARRVAL(tmp) = EG(active_symbol_table);
+               ZVAL_ARR(&tmp, EG(active_symbol_table));
                sapi_module.treat_data(PARSE_STRING, res, &tmp TSRMLS_CC);
        } else  {
                zval ret;
@@ -4428,6 +4428,9 @@ PHP_FUNCTION(parse_str)
                array_init(&ret);
                sapi_module.treat_data(PARSE_STRING, res, &ret TSRMLS_CC);
                /* Clear out the array that was passed in. */
+               if (Z_ISREF_P(arrayArg)) {
+                       arrayArg = Z_REFVAL_P(arrayArg);
+               }
                zval_dtor(arrayArg);
                ZVAL_COPY_VALUE(arrayArg, &ret);
        }

diff --git a/main/main.c b/main/main.c
index 2f05b5f55f43c190aaa413116e6a6b1dba8e384e..72092cca64cd8414c8c8b0f8e27fdc44d3cde78c 100644 (file)
--- a/main/main.c
+++ b/main/main.c
@@ -863,7 +863,7 @@ PHPAPI void php_verror(const char *docref, const char *params, int type, const c
                if (EG(active_symbol_table)) {
                        zval tmp;
                        ZVAL_STRINGL(&tmp, buffer, buffer_len);
-                       zend_hash_str_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg")-1, &tmp);
+                       zend_hash_str_update(&EG(active_symbol_table)->ht, "php_errormsg", sizeof("php_errormsg")-1, &tmp);
                }
        }
        if (replace_buffer) {
@@ -1195,7 +1195,7 @@ static void php_error_cb(int type, const char *error_filename, const uint error_
                if (EG(active_symbol_table)) {
                        zval tmp;
                        ZVAL_STRINGL(&tmp, buffer, buffer_len);
-                       zend_hash_str_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg")-1, &tmp);
+                       zend_hash_str_update(&EG(active_symbol_table)->ht, "php_errormsg", sizeof("php_errormsg")-1, &tmp);
                }
        }
 

diff --git a/main/php_variables.c b/main/php_variables.c
index 671d8e59ff5cccd37d9fe0337cb2b63e761dbd04..47b2c522bde0ff92ae55886602dc0fccb7e6c0d4 100644 (file)
--- a/main/php_variables.c
+++ b/main/php_variables.c
@@ -67,7 +67,7 @@ PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars
 
        assert(var_name != NULL);
 
-       if (track_vars_array) {
+       if (track_vars_array && Z_TYPE_P(track_vars_array) == IS_ARRAY) {
                symtable1 = Z_ARRVAL_P(track_vars_array);
        }
 
@@ -110,7 +110,8 @@ PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars
        }
 
        /* GLOBALS hijack attempt, reject parameter */
-       if (symtable1 == EG(active_symbol_table) &&
+       if (symtable1 && EG(active_symbol_table) &&
+               symtable1 == &EG(active_symbol_table)->ht &&
                var_len == sizeof("GLOBALS")-1 &&
                !memcmp(var, "GLOBALS", sizeof("GLOBALS")-1)) {
                zval_dtor(val);
@@ -353,6 +354,7 @@ SAPI_API SAPI_TREAT_DATA_FUNC(php_default_treat_data)
        char *strtok_buf = NULL;
        long count = 0;
        
+       ZVAL_UNDEF(&array);
        switch (arg) {
                case PARSE_POST:
                case PARSE_GET:

diff --git a/sapi/phpdbg/phpdbg_info.c b/sapi/phpdbg/phpdbg_info.c
index d1a3cf6a9b08837f8389c1deb1291b9623a41690..660404883ce68605f58bbbe771fd786623545118 100644 (file)
--- a/sapi/phpdbg/phpdbg_info.c
+++ b/sapi/phpdbg/phpdbg_info.c
@@ -92,13 +92,13 @@ PHPDBG_INFO(vars) /* {{{ */
 
        zend_hash_init(&vars, 8, NULL, NULL, 0);
 
-       zend_hash_internal_pointer_reset_ex(EG(active_symbol_table), &pos);
-       while (zend_hash_get_current_key_ex(EG(active_symbol_table), &var, NULL, 0, &pos) == HASH_KEY_IS_STRING) {
-               data = zend_hash_get_current_data_ex(EG(active_symbol_table), &pos);
+       zend_hash_internal_pointer_reset_ex(&EG(active_symbol_table)->ht, &pos);
+       while (zend_hash_get_current_key_ex(&EG(active_symbol_table)->ht, &var, NULL, 0, &pos) == HASH_KEY_IS_STRING) {
+               data = zend_hash_get_current_data_ex(&EG(active_symbol_table)->ht, &pos);
                if (*(var->val) != '_') {
                        zend_hash_update(&vars, var, data);
                }
-               zend_hash_move_forward_ex(EG(active_symbol_table), &pos);
+               zend_hash_move_forward_ex(&EG(active_symbol_table)->ht, &pos);
        }
 
        {