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

18 files changed, 97 insertions, 90 deletions

diff --git a/Zend/zend.c b/Zend/zend.c
index 783f47cc3e..a494c97dc9 100644
--- 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 206d9cfbed..d759803345 100644
--- 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 776f7903e4..5691fd0b69 100644
--- 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 ca83c2e95e..45bbb4a563 100644
--- 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 6e4005a1dc..5176817041 100644
--- 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 3db755fb84..5c9651feb8 100644
--- 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 ea02c0f160..339a71b901 100644
--- 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 6eb65ce28b..483628dbaf 100644
--- 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 e987ac1cd4..9dae1fcfca 100644
--- 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 47b07eec79..f016f85f00 100644
--- 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 44ec35e3b6..14483a427f 100644
--- 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 7b91edfb91..dc625815f4 100644
--- 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 ce0fcad5ab..de3e4b5573 100644
--- 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 55a1d12cc7..29e5db0ebf 100644
--- 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 5bfffa0292..e3a1df1f24 100644
--- 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 2f05b5f55f..72092cca64 100644
--- 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 671d8e59ff..47b2c522bd 100644
--- 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 d1a3cf6a9b..660404883c 100644
--- 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);
 	}
 
 	{